* [PATCH 01/37] scsi: define all additional sense codes and their qualifiers
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 02/37] scsi: constants: use defined sense codes Damien Le Moal
` (36 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Introduce the file include/scsi/scsi_sense.h to define all existing
additional sense codes and their combinations with additional sense code
qualifiers, according to the most current T10 list available at
https://www.t10.org/lists/asc-num.txt.
Additional sense codes (ASCs) are individually defined as an 8-bit value
with the ASC_ name prefix. The combination of all ASCs with T10 defined
possible non-zero code qualifiers are defined as 16-bits values. The
16-bits value for ASCs with a zero ASCQ are defined together with the ASC
8-code using the ASC() macro.
The sense key macro definitions in include/scsi/scsi_proto.h are also
moved into this new file and scsi_sense.h is included in scsi_proto.h. The
helper function scsi_sense_code() is defined to facilitate generating a
16-bits sense code from 8-bits ASC and ASCQ. The accessors
scsi_sense_code_asc() and scsi_sense_code_ascq() are defined for the
reverse operation, that is, to respectively extract an ASC and an ASCQ
from a 16-bits sense code.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
include/scsi/scsi_proto.h | 20 +-
include/scsi/scsi_sense.h | 943 ++++++++++++++++++++++++++++++++++++++
2 files changed, 944 insertions(+), 19 deletions(-)
create mode 100644 include/scsi/scsi_sense.h
diff --git a/include/scsi/scsi_proto.h b/include/scsi/scsi_proto.h
index c6b4a4dc8d9c..f742a3bfeb86 100644
--- a/include/scsi/scsi_proto.h
+++ b/include/scsi/scsi_proto.h
@@ -12,6 +12,7 @@
#include <linux/build_bug.h>
#include <linux/types.h>
+#include <scsi/scsi_sense.h>
/*
* SCSI opcodes
@@ -218,25 +219,6 @@ enum sam_status {
#define STATUS_MASK 0xfe
-/*
- * SENSE KEYS
- */
-#define NO_SENSE 0x00
-#define RECOVERED_ERROR 0x01
-#define NOT_READY 0x02
-#define MEDIUM_ERROR 0x03
-#define HARDWARE_ERROR 0x04
-#define ILLEGAL_REQUEST 0x05
-#define UNIT_ATTENTION 0x06
-#define DATA_PROTECT 0x07
-#define BLANK_CHECK 0x08
-#define VENDOR_SPECIFIC 0x09
-#define COPY_ABORTED 0x0a
-#define ABORTED_COMMAND 0x0b
-#define VOLUME_OVERFLOW 0x0d
-#define MISCOMPARE 0x0e
-#define COMPLETED 0x0f
-
/*
* Additional Sense Codes (ASC).
*/
diff --git a/include/scsi/scsi_sense.h b/include/scsi/scsi_sense.h
new file mode 100644
index 000000000000..e668ac1c2302
--- /dev/null
+++ b/include/scsi/scsi_sense.h
@@ -0,0 +1,943 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Definitions of SCSI sense keys, additional sense codes and additional sense
+ * code qualifiers.
+ */
+#ifndef _SCSI_SENSE_H_
+#define _SCSI_SENSE_H_
+
+#include <linux/types.h>
+
+/*
+ * Sense keys.
+ * See: https://www.t10.org/lists/2sensekey.htm
+ */
+enum scsi_sense_key {
+ NO_SENSE = 0x00,
+ RECOVERED_ERROR = 0x01,
+ NOT_READY = 0x02,
+ MEDIUM_ERROR = 0x03,
+ HARDWARE_ERROR = 0x04,
+ ILLEGAL_REQUEST = 0x05,
+ UNIT_ATTENTION = 0x06,
+ DATA_PROTECT = 0x07,
+ BLANK_CHECK = 0x08,
+ VENDOR_SPECIFIC = 0x09,
+ COPY_ABORTED = 0x0a,
+ ABORTED_COMMAND = 0x0b,
+ VOLUME_OVERFLOW = 0x0d,
+ MISCOMPARE = 0x0e,
+ COMPLETED = 0x0f,
+};
+
+#define ASC_DEF(name) ASC_##name
+#define ASC(name, code) \
+ ASC_DEF(name) = (code), \
+ name = ((code) << 8) | 0x00
+
+/*
+ * SCSI additional sense codes and sense codes qualifiers.
+ * See: https://www.t10.org/lists/asc-num.txt
+ * The definitions are sorted in increasing sense code value order.
+ * The additional sense code and its qualifier are combined as a single value
+ * equal to (ASC << 8) | ASCQ.
+ */
+enum scsi_sense_code {
+ ASC(NO_ADDITIONAL_SENSE_INFORMATION, 0x00),
+ FILEMARK_DETECTED = 0x0001,
+ END_OF_PARTITION_MEDIUM_DETECTED = 0x0002,
+ SETMARK_DETECTED = 0x0003,
+ BEGINNING_OF_PARTITION_MEDIUM_DETECTED = 0x0004,
+ END_OF_DATA_DETECTED = 0x0005,
+ IO_PROCESS_TERMINATED = 0x0006,
+ PROGRAMMABLE_EARLY_WARNING_DETECTED = 0x0007,
+ AUDIO_PLAY_OP_IN_PROGRESS = 0x0011,
+ AUDIO_PLAY_OP_PAUSED = 0x0012,
+ AUDIO_PLAY_OP_SUCCESSFULLY_COMPLETED = 0x0013,
+ AUDIO_PLAY_OP_STOPPED_DUE_TO_ERROR = 0x0014,
+ NO_CURRENT_AUDIO_STATUS_TO_RETURN = 0x0015,
+ OP_IN_PROGRESS = 0x0016,
+ CLEANING_REQUESTED = 0x0017,
+ ERASE_OP_IN_PROGRESS = 0x0018,
+ LOCATE_OP_IN_PROGRESS = 0x0019,
+ REWIND_OP_IN_PROGRESS = 0x001A,
+ SET_CAPACITY_OP_IN_PROGRESS = 0x001B,
+ VERIFY_OP_IN_PROGRESS = 0x001C,
+ ATA_PASS_THROUGH_INFORMATION_AVAILABLE = 0x001D,
+ CONFLICTING_SA_CREATION_REQUEST = 0x001E,
+ LU_TRANSITIONING_TO_ANOTHER_POWER_CONDITION = 0x001F,
+ EXTENDED_COPY_INFORMATION_AVAILABLE = 0x0020,
+ ATOMIC_COMMAND_ABORTED_DUE_TO_ACA = 0x0021,
+ DEFERRED_MICROCODE_IS_PENDING = 0x0022,
+ OVERLAPPING_ATOMIC_COMMAND_IN_PROGRESS = 0x0023,
+
+ ASC(NO_INDEX_SECTOR_SIGNAL, 0x01),
+
+ ASC(NO_SEEK_COMPLETE, 0x02),
+
+ ASC(PERIPHERAL_DEVICE_WRITE_FAULT, 0x03),
+ NO_WRITE_CURRENT = 0x0301,
+ EXCESSIVE_WRITE_ERRORS = 0x0302,
+
+ ASC(LU_NOT_READY, 0x04),
+ LU_IS_IN_PROCESS_OF_BECOMING_READY = 0x0401,
+ LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED = 0x0402,
+ LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED = 0x0403,
+ LU_NOT_READY_FORMAT_IN_PROGRESS = 0x0404,
+ LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405,
+ LU_NOT_READY_RECALCULATION_IN_PROGRESS = 0x0406,
+ LU_NOT_READY_OP_IN_PROGRESS = 0x0407,
+ LU_NOT_READY_LONG_WRITE_IN_PROGRESS = 0x0408,
+ LU_NOT_READY_SELFTEST_IN_PROGRESS = 0x0409,
+ LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION = 0x040A,
+ LU_NOT_ACCESSIBLE_TARGET_PORT_IN_STANDBY_STATE = 0x040B,
+ LU_NOT_ACCESSIBLE_TARGET_PORT_IN_UNAVAILABLE_STATE = 0x040C,
+ LU_NOT_READY_STRUCTURE_CHECK_REQUIRED = 0x040D,
+ LU_NOT_READY_SECURITY_SESSION_IN_PROGRESS = 0x040E,
+ LU_NOT_READY_AUXILIARY_MEMORY_NOT_ACCESSIBLE = 0x0410,
+ LU_NOT_READY_NOTIFY_REQUIRED = 0x0411,
+ LU_NOT_READY_OFFLINE = 0x0412,
+ LU_NOT_READY_SA_CREATION_IN_PROGRESS = 0x0413,
+ LU_NOT_READY_SPACE_ALLOCATION_IN_PROGRESS = 0x0414,
+ LU_NOT_READY_ROBOTICS_DISABLED = 0x0415,
+ LU_NOT_READY_CONFIG_REQUIRED = 0x0416,
+ LU_NOT_READY_CALIBRATION_REQUIRED = 0x0417,
+ LU_NOT_READY_A_DOOR_IS_OPEN = 0x0418,
+ LU_NOT_READY_OPERATING_IN_SEQUENTIAL_MODE = 0x0419,
+ LU_NOT_READY_START_STOP_UNIT_COMMAND_IN_PROGRESS = 0x041A,
+ LU_NOT_READY_SANITIZE_IN_PROGRESS = 0x041B,
+ LU_NOT_READY_ADDITIONAL_POWER_USE_NOT_YET_GRANTED = 0x041C,
+ LU_NOT_READY_CONFIG_IN_PROGRESS = 0x041D,
+ LU_NOT_READY_MICROCODE_ACTIVATION_REQUIRED = 0x041E,
+ LU_NOT_READY_MICROCODE_DOWNLOAD_REQUIRED = 0x041F,
+ LU_NOT_READY_LU_RESET_REQUIRED = 0x0420,
+ LU_NOT_READY_HARD_RESET_REQUIRED = 0x0421,
+ LU_NOT_READY_POWER_CYCLE_REQUIRED = 0x0422,
+ LU_NOT_READY_AFFILIATION_REQUIRED = 0x0423,
+ DEPOPULATION_IN_PROGRESS = 0x0424,
+ DEPOPULATION_RESTORATION_IN_PROGRESS = 0x0425,
+
+ ASC(LU_DOES_NOT_RESPOND_TO_SELECTION, 0x05),
+
+ ASC(NO_REFERENCE_POSITION_FOUND, 0x06),
+
+ ASC(MULTIPLE_PERIPHERAL_DEVICES_SELECTED, 0x07),
+
+ ASC(LU_COMMUNICATION_FAILURE, 0x08),
+ LU_COMMUNICATION_TIMEOUT = 0x0801,
+ LU_COMMUNICATION_PARITY_ERROR = 0x0802,
+ LU_COMMUNICATION_CRC_ERROR = 0x0803,
+ UNREACHABLE_COPY_TARGET = 0x0804,
+
+ ASC(TRACK_FOLLOWING_ERROR, 0x09),
+ TRACKING_SERVO_FAILURE = 0x0901,
+ FOCUS_SERVO_FAILURE = 0x0902,
+ SPINDLE_SERVO_FAILURE = 0x0903,
+ HEAD_SELECT_FAULT = 0x0904,
+ VIBRATION_INDUCED_TRACKING_ERROR = 0x0905,
+
+ ASC(ERROR_LOG_OVERFLOW, 0x0A),
+
+ ASC(WARNING, 0x0B),
+ WARNING_SPECIFIED_TEMPERATURE_EXCEEDED = 0x0B01,
+ WARNING_ENCLOSURE_DEGRADED = 0x0B02,
+ WARNING_BACKGROUND_SELFTEST_FAILED = 0x0B03,
+ WARNING_BACKGROUND_PRESCAN_DETECTED_MEDIUM_ERROR = 0x0B04,
+ WARNING_BACKGROUND_MEDIUM_SCAN_DETECTED_MEDIUM_ERROR = 0x0B05,
+ WARNING_NONVOLATILE_CACHE_NOW_VOLATILE = 0x0B06,
+ WARNING_DEGRADED_POWER_TO_NONVOLATILE_CACHE = 0x0B07,
+ WARNING_POWER_LOSS_EXPECTED = 0x0B08,
+ WARNING_DEVICE_STATISTICS_NOTIFICATION_ACTIVE = 0x0B09,
+ WARNING_HIGH_CRITICAL_TEMPERATURE_LIMIT_EXCEEDED = 0x0B0A,
+ WARNING_LOW_CRITICAL_TEMPERATURE_LIMIT_EXCEEDED = 0x0B0B,
+ WARNING_HIGH_OPERATING_TEMPERATURE_LIMIT_EXCEEDED = 0x0B0C,
+ WARNING_LOW_OPERATING_TEMPERATURE_LIMIT_EXCEEDED = 0x0B0D,
+ WARNING_HIGH_CRITICAL_HUMIDITY_LIMIT_EXCEEDED = 0x0B0E,
+ WARNING_LOW_CRITICAL_HUMIDITY_LIMIT_EXCEEDED = 0x0B0F,
+ WARNING_HIGH_OPERATING_HUMIDITY_LIMIT_EXCEEDED = 0x0B10,
+ WARNING_LOW_OPERATING_HUMIDITY_LIMIT_EXCEEDED = 0x0B11,
+ WARNING_MICROCODE_SECURITY_AT_RISK = 0x0B12,
+ WARNING_MICROCODE_DIGITAL_SIGNATURE_VALIDATION_FAILURE = 0x0B13,
+ WARNING_PHYSICAL_ELEMENT_STATUS_CHANGE = 0x0B14,
+
+ ASC(WRITE_ERROR, 0x0C),
+ WRITE_ERROR_RECOVERED_WITH_AUTO_REALLOCATION = 0x0C01,
+ WRITE_ERROR_AUTO_REALLOCATION_FAILED = 0x0C02,
+ WRITE_ERROR_RECOMMEND_REASSIGNMENT = 0x0C03,
+ COMPRESSION_CHECK_MISCOMPARE_ERROR = 0x0C04,
+ DATA_EXPANSION_OCCURRED_DURING_COMPRESSION = 0x0C05,
+ BLOCK_NOT_COMPRESSIBLE = 0x0C06,
+ WRITE_ERROR_RECOVERY_NEEDED = 0x0C07,
+ WRITE_ERROR_RECOVERY_FAILED = 0x0C08,
+ WRITE_ERROR_LOSS_OF_STREAMING = 0x0C09,
+ WRITE_ERROR_PADDING_BLOCKS_ADDED = 0x0C0A,
+ AUXILIARY_MEMORY_WRITE_ERROR = 0x0C0B,
+ WRITE_ERROR_UNEXPECTED_UNSOLICITED_DATA = 0x0C0C,
+ WRITE_ERROR_NOT_ENOUGH_UNSOLICITED_DATA = 0x0C0D,
+ MULTIPLE_WRITE_ERRORS = 0x0C0E,
+ DEFECTS_IN_ERROR_WINDOW = 0x0C0F,
+ INCOMPLETE_MULTIPLE_ATOMIC_WRITE_OPERATIONS = 0x0C10,
+ WRITE_ERROR_RECOVERY_SCAN_NEEDED = 0x0C11,
+ WRITE_ERROR_INSUFFICIENT_ZONE_RESOURCES = 0x0C12,
+
+ ASC(ERROR_DETECTED_BY_THIRD_PARTY_TEMPORARY_INITIATOR, 0x0D),
+ THIRD_PARTY_DEVICE_FAILURE = 0x0D01,
+ COPY_TARGET_DEVICE_NOT_REACHABLE = 0x0D02,
+ INCORRECT_COPY_TARGET_DEVICE_TYPE = 0x0D03,
+ COPY_TARGET_DEVICE_DATA_UNDERRUN = 0x0D04,
+ COPY_TARGET_DEVICE_DATA_OVERRUN = 0x0D05,
+
+ ASC(INVALID_INFORMATION_UNIT, 0x0E),
+ INFORMATION_UNIT_TOO_SHORT = 0x0E01,
+ INFORMATION_UNIT_TOO_LONG = 0x0E02,
+ INVALID_FIELD_IN_COMMAND_INFORMATION_UNIT = 0x0E03,
+
+ ASC(ID_CRC_OR_ECC_ERROR, 0x10),
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED = 0x1001,
+ LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED = 0x1002,
+ LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED = 0x1003,
+ LOGICAL_BLOCK_PROTECTION_ERROR_ON_RECOVER_BUFFERED_DATA = 0x1004,
+ LOGICAL_BLOCK_PROTECTION_METHOD_ERROR = 0x1005,
+
+ ASC(UNRECOVERED_READ_ERROR, 0x11),
+ READ_RETRIES_EXHAUSTED = 0x1101,
+ ERROR_TOO_LONG_TO_CORRECT = 0x1102,
+ MULTIPLE_READ_ERRORS = 0x1103,
+ UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED = 0x1104,
+ LEC_UNCORRECTABLE_ERROR = 0x1105,
+ CIRC_UNRECOVERED_ERROR = 0x1106,
+ DATA_RESYNCHRONIZATION_ERROR = 0x1107,
+ INCOMPLETE_BLOCK_READ = 0x1108,
+ NO_GAP_FOUND = 0x1109,
+ MISCORRECTED_ERROR = 0x110A,
+ UNRECOVERED_READ_ERROR_RECOMMEND_REASSIGNMENT = 0x110B,
+ UNRECOVERED_READ_ERROR_RECOMMEND_REWRITE_THE_DATA = 0x110C,
+ DECOMPRESSION_CRC_ERROR = 0x110D,
+ CANNOT_DECOMPRESS_USING_DECLARED_ALGORITHM = 0x110E,
+ ERROR_READING_UPC_EAN_NUMBER = 0x110F,
+ ERROR_READING_ISRC_NUMBER = 0x1110,
+ READ_ERROR_LOSS_OF_STREAMING = 0x1111,
+ AUXILIARY_MEMORY_READ_ERROR = 0x1112,
+ READ_ERROR_FAILED_RETRANSMISSION_REQUEST = 0x1113,
+ READ_ERROR_LBA_MARKED_BAD_BY_APPLICATION_CLIENT = 0x1114,
+ WRITE_AFTER_SANITIZE_REQUIRED = 0x1115,
+
+ ASC(ADDRESS_MARK_NOT_FOUND_FOR_ID_FIELD, 0x12),
+
+ ASC(ADDRESS_MARK_NOT_FOUND_FOR_DATA_FIELD, 0x13),
+
+ ASC(RECORDED_ENTITY_NOT_FOUND, 0x14),
+ RECORD_NOT_FOUND = 0x1401,
+ FILEMARK_OR_SETMARK_NOT_FOUND = 0x1402,
+ END_OF_DATA_NOT_FOUND = 0x1403,
+ BLOCK_SEQUENCE_ERROR = 0x1404,
+ RECORD_NOT_FOUND_RECOMMEND_REASSIGNMENT = 0x1405,
+ RECORD_NOT_FOUND_DATA_AUTO_REALLOCATED = 0x1406,
+ LOCATE_OPERATION_FAILURE = 0x1407,
+
+ ASC(RANDOM_POSITIONING_ERROR, 0x15),
+ MECHANICAL_POSITIONING_ERROR = 0x1501,
+ POSITIONING_ERROR_DETECTED_BY_READ_OF_MEDIUM = 0x1502,
+
+ ASC(DATA_SYNCHRONIZATION_MARK_ERROR, 0x16),
+ DATA_SYNC_ERROR_DATA_REWRITTEN = 0x1601,
+ DATA_SYNC_ERROR_RECOMMEND_REWRITE = 0x1602,
+ DATA_SYNC_ERROR_DATA_AUTO_REALLOCATED = 0x1603,
+ DATA_SYNC_ERROR_RECOMMEND_REASSIGNMENT = 0x1604,
+
+ ASC(RECOVERED_DATA_WITH_NO_ERROR_CORRECTION_APPLIED, 0x17),
+ RECOVERED_DATA_WITH_RETRIES = 0x1701,
+ RECOVERED_DATA_WITH_POSITIVE_HEAD_OFFSET = 0x1702,
+ RECOVERED_DATA_WITH_NEGATIVE_HEAD_OFFSET = 0x1703,
+ RECOVERED_DATA_WITH_RETRIES_AND_OR_CIRC_APPLIED = 0x1704,
+ RECOVERED_DATA_USING_PREVIOUS_SECTOR_ID = 0x1705,
+ RECOVERED_DATA_WITHOUT_ECC_DATA_AUTO_REALLOCATED = 0x1706,
+ RECOVERED_DATA_WITHOUT_ECC_RECOMMEND_REASSIGNMENT = 0x1707,
+ RECOVERED_DATA_WITHOUT_ECC_RECOMMEND_REWRITE = 0x1708,
+ RECOVERED_DATA_WITHOUT_ECC_DATA_REWRITTEN = 0x1709,
+
+ ASC(RECOVERED_DATA_WITH_ERROR_CORRECTION_APPLIED, 0x18),
+ RECOVERED_DATA_WITH_ERROR_CORRECTION_RETRIES_APPLIED = 0x1801,
+ RECOVERED_DATA_DATA_AUTO_REALLOCATED = 0x1802,
+ RECOVERED_DATA_WITH_CIRC = 0x1803,
+ RECOVERED_DATA_WITH_LEC = 0x1804,
+ RECOVERED_DATA_RECOMMEND_REASSIGNMENT = 0x1805,
+ RECOVERED_DATA_RECOMMEND_REWRITE = 0x1806,
+ RECOVERED_DATA_WITH_ECC_DATA_REWRITTEN = 0x1807,
+ RECOVERED_DATA_WITH_LINKING = 0x1808,
+
+ ASC(DEFECT_LIST_ERROR, 0x19),
+ DEFECT_LIST_NOT_AVAILABLE = 0x1901,
+ DEFECT_LIST_ERROR_IN_PRIMARY_LIST = 0x1902,
+ DEFECT_LIST_ERROR_IN_GROWN_LIST = 0x1903,
+
+ ASC(PARAMETER_LIST_LENGTH_ERROR, 0x1A),
+
+ ASC(SYNCHRONOUS_DATA_TRANSFER_ERROR, 0x1B),
+
+ ASC(DEFECT_LIST_NOT_FOUND, 0x1C),
+ PRIMARY_DEFECT_LIST_NOT_FOUND = 0x1C01,
+ GROWN_DEFECT_LIST_NOT_FOUND = 0x1C02,
+
+ ASC(MISCOMPARE_DURING_VERIFY_OPERATION, 0x1D),
+ MISCOMPARE_VERIFY_OF_UNMAPPED_LBA = 0x1D01,
+
+ ASC(RECOVERED_ID_WITH_ECC_CORRECTION, 0x1E),
+
+ ASC(PARTIAL_DEFECT_LIST_TRANSFER, 0x1F),
+
+ ASC(INVALID_COMMAND_OP_CODE, 0x20),
+ ACCESS_DENIED_INITIATOR_PENDING_ENROLLED = 0x2001,
+ ACCESS_DENIED_NO_ACCESS_RIGHTS = 0x2002,
+ ACCESS_DENIED_INVALID_MGMT_ID_KEY = 0x2003,
+ ILLEGAL_COMMAND_WHILE_IN_WRITE_CAPABLE_STATE = 0x2004,
+ ILLEGAL_COMMAND_WHILE_IN_EXPLICIT_ADDRESS_MODE = 0x2006,
+ ILLEGAL_COMMAND_WHILE_IN_IMPLICIT_ADDRESS_MODE = 0x2007,
+ ACCESS_DENIED_ENROLLMENT_CONFLICT = 0x2008,
+ ACCESS_DENIED_INVALID_LU_IDENTIFIER = 0x2009,
+ ACCESS_DENIED_INVALID_PROXY_TOKEN = 0x200A,
+ ACCESS_DENIED_ACL_LUN_CONFLICT = 0x200B,
+ ILLEGAL_COMMAND_WHEN_NOT_IN_APPEND_ONLY_MODE = 0x200C,
+ NOT_AN_ADMINISTRATIVE_LOGICAL_UNIT = 0x200D,
+ NOT_A_SUBSIDIARY_LOGICAL_UNIT = 0x200E,
+ NOT_A_CONGLOMERATE_LOGICAL_UNIT = 0x200F,
+
+ ASC(LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 0x21),
+ INVALID_ELEMENT_ADDRESS = 0x2101,
+ INVALID_ADDRESS_FOR_WRITE = 0x2102,
+ INVALID_WRITE_CROSSING_LAYER_JUMP = 0x2103,
+ UNALIGNED_WRITE_COMMAND = 0x2104,
+ WRITE_BOUNDARY_VIOLATION = 0x2105,
+ ATTEMPT_TO_READ_INVALID_DATA = 0x2106,
+ READ_BOUNDARY_VIOLATION = 0x2107,
+ MISALIGNED_WRITE_COMMAND = 0x2108,
+ ATTEMPT_TO_ACCESS_GAP_ZONE = 0x2109,
+
+ ASC(ILLEGAL_FUNCTION, 0x22),
+
+ ASC(INVALID_TOKEN_OP, 0x23),
+ INVALID_TOKEN_OP_UNSUPPORTED_TOKEN_TYPE = 0x2301,
+ INVALID_TOKEN_OP_REMOTE_TOKEN_USAGE_NOT_SUPPORTED = 0x2302,
+ INVALID_TOKEN_OP_REMOTE_ROD_TOKEN_CREATION_NOT_SUPPORTED = 0x2303,
+ INVALID_TOKEN_OP_TOKEN_UNKNOWN = 0x2304,
+ INVALID_TOKEN_OP_TOKEN_CORRUPT = 0x2305,
+ INVALID_TOKEN_OP_TOKEN_REVOKED = 0x2306,
+ INVALID_TOKEN_OP_TOKEN_EXPIRED = 0x2307,
+ INVALID_TOKEN_OP_TOKEN_CANCELLED = 0x2308,
+ INVALID_TOKEN_OP_TOKEN_DELETED = 0x2309,
+ INVALID_TOKEN_OP_INVALID_TOKEN_LENGTH = 0x230A,
+
+ ASC(INVALID_FIELD_IN_CDB, 0x24),
+ CDB_DECRYPTION_ERROR = 0x2401,
+ SECURITY_AUDIT_VALUE_FROZEN = 0x2404,
+ SECURITY_WORKING_KEY_FROZEN = 0x2405,
+ NONCE_NOT_UNIQUE = 0x2406,
+ NONCE_TIMESTAMP_OUT_OF_RANGE = 0x2407,
+ INVALID_XCDB = 0x2408,
+ INVALID_FAST_FORMAT = 0x2409,
+
+ ASC(LU_NOT_SUPPORTED, 0x25),
+
+ ASC(INVALID_FIELD_IN_PARAMETER_LIST, 0x26),
+ PARAMETER_NOT_SUPPORTED = 0x2601,
+ PARAMETER_VALUE_INVALID = 0x2602,
+ THRESHOLD_PARAMETERS_NOT_SUPPORTED = 0x2603,
+ INVALID_RELEASE_OF_PERSISTENT_RESERVATION = 0x2604,
+ DATA_DECRYPTION_ERROR = 0x2605,
+ TOO_MANY_TARGET_DESCRIPTORS = 0x2606,
+ UNSUPPORTED_TARGET_DESCRIPTOR_TYPE_CODE = 0x2607,
+ TOO_MANY_SEGMENT_DESCRIPTORS = 0x2608,
+ UNSUPPORTED_SEGMENT_DESCRIPTOR_TYPE_CODE = 0x2609,
+ UNEXPECTED_INEXACT_SEGMENT = 0x260A,
+ INLINE_DATA_LENGTH_EXCEEDED = 0x260B,
+ INVALID_OP_FOR_COPY_SOURCE_OR_DESTINATION = 0x260C,
+ COPY_SEGMENT_GRANULARITY_VIOLATION = 0x260D,
+ INVALID_PARAMETER_WHILE_PORT_IS_ENABLED = 0x260E,
+ INVALID_DATA_OUT_BUFFER_INTEGRITY_CHECK_VALUE = 0x260F,
+ DATA_DECRYPTION_KEY_FAIL_LIMIT_REACHED = 0x2610,
+ INCOMPLETE_KEY_ASSOCIATED_DATA_SET = 0x2611,
+ VENDOR_SPECIFIC_KEY_REFERENCE_NOT_FOUND = 0x2612,
+ APPLICATION_TAG_MODE_PAGE_IS_INVALID = 0x2613,
+ TAPE_STREAM_MIRRORING_PREVENTED = 0x2614,
+ COPY_SOURCE_OR_COPY_DESTINATION_NOT_AUTHORIZED = 0x2615,
+ FAST_COPY_NOT_POSSIBLE = 0x2616,
+
+ ASC(WRITE_PROTECTED, 0x27),
+ HW_WRITE_PROTECTED = 0x2701,
+ LU_SOFTWARE_WRITE_PROTECTED = 0x2702,
+ ASSOCIATED_WRITE_PROTECT = 0x2703,
+ PERSISTENT_WRITE_PROTECT = 0x2704,
+ PERMANENT_WRITE_PROTECT = 0x2705,
+ CONDITIONAL_WRITE_PROTECT = 0x2706,
+ SPACE_ALLOCATION_FAILED_WRITE_PROTECT = 0x2707,
+ ZONE_IS_READ_ONLY = 0x2708,
+
+ ASC(NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED, 0x28),
+ IMPORT_OR_EXPORT_ELEMENT_ACCESSED = 0x2801,
+ FORMAT_LAYER_MAY_HAVE_CHANGED = 0x2802,
+ IMPORT_EXPORT_ELEMENT_ACCESSED_MEDIUM_CHANGED = 0x2803,
+
+ ASC(POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED, 0x29),
+ POWER_ON_OCCURRED = 0x2901,
+ SCSI_BUS_RESET_OCCURRED = 0x2902,
+ BUS_DEVICE_RESET_FUNCTION_OCCURRED = 0x2903,
+ DEVICE_INTERNAL_RESET = 0x2904,
+ TRANSCEIVER_MODE_CHANGED_TO_SINGLE_ENDED = 0x2905,
+ TRANSCEIVER_MODE_CHANGED_TO_LVD = 0x2906,
+ I_T_NEXUS_LOSS_OCCURRED = 0x2907,
+
+ ASC(PARAMETERS_CHANGED, 0x2A),
+ MODE_PARAMETERS_CHANGED = 0x2A01,
+ LOG_PARAMETERS_CHANGED = 0x2A02,
+ RESERVATIONS_PREEMPTED = 0x2A03,
+ RESERVATIONS_RELEASED = 0x2A04,
+ REGISTRATIONS_PREEMPTED = 0x2A05,
+ ASYMMETRIC_ACCESS_STATE_CHANGED = 0x2A06,
+ IMPLICIT_ASYMMETRIC_ACCESS_STATE_TRANSITION_FAILED = 0x2A07,
+ PRIORITY_CHANGED = 0x2A08,
+ CAPACITY_DATA_HAS_CHANGED = 0x2A09,
+ ERROR_HISTORY_I_T_NEXUS_CLEARED = 0x2A0A,
+ ERROR_HISTORY_SNAPSHOT_RELEASED = 0x2A0B,
+ ERROR_RECOVERY_ATTRIBUTES_HAVE_CHANGED = 0x2A0C,
+ DATA_ENCRYPTION_CAPABILITIES_CHANGED = 0x2A0D,
+ TIMESTAMP_CHANGED = 0x2A10,
+ DATA_ENCRYPTION_PARAMS_CHANGED_BY_ANOTHER_I_T_NEXUS = 0x2A11,
+ DATA_ENCRYPTION_PARAMS_CHANGED_BY_VENDOR_SPECIFIC_EVENT = 0x2A12,
+ DATA_ENCRYPTION_KEY_INSTANCE_COUNTER_HAS_CHANGED = 0x2A13,
+ SA_CREATION_CAPABILITIES_DATA_HAS_CHANGED = 0x2A14,
+ MEDIUM_REMOVAL_PREVENTION_PREEMPTED = 0x2A15,
+ ZONE_RESET_WRITE_POINTER_RECOMMENDED = 0x2A16,
+
+ ASC(COPY_CANNOT_EXECUTE_SINCE_HOST_CANNOT_DISCONNECT, 0x2B),
+
+ ASC(COMMAND_SEQUENCE_ERROR, 0x2C),
+ TOO_MANY_WINDOWS_SPECIFIED = 0x2C01,
+ INVALID_COMBINATION_OF_WINDOWS_SPECIFIED = 0x2C02,
+ CURRENT_PROGRAM_AREA_IS_NOT_EMPTY = 0x2C03,
+ CURRENT_PROGRAM_AREA_IS_EMPTY = 0x2C04,
+ ILLEGAL_POWER_CONDITION_REQUEST = 0x2C05,
+ PERSISTENT_PREVENT_CONFLICT = 0x2C06,
+ PREVIOUS_BUSY_STATUS = 0x2C07,
+ PREVIOUS_TASK_SET_FULL_STATUS = 0x2C08,
+ PREVIOUS_RESERVATION_CONFLICT_STATUS = 0x2C09,
+ PARTITION_OR_COLLECTION_CONTAINS_USER_OBJECTS = 0x2C0A,
+ NOT_RESERVED = 0x2C0B,
+ ORWRITE_GENERATION_DOES_NOT_MATCH = 0x2C0C,
+ RESET_WRITE_POINTER_NOT_ALLOWED = 0x2C0D,
+ ZONE_IS_OFFLINE = 0x2C0E,
+ STREAM_NOT_OPEN = 0x2C0F,
+ UNWRITTEN_DATA_IN_ZONE = 0x2C10,
+ DESCRIPTOR_FORMAT_SENSE_DATA_REQUIRED = 0x2C11,
+ ZONE_IS_INACTIVE = 0x2C12,
+ WELL_KNOWN_LU_ACCESS_REQUIRED = 0x2C13,
+
+ ASC(OVERWRITE_ERROR_ON_UPDATE_IN_PLACE, 0x2D),
+
+ ASC(INSUFFICIENT_TIME_FOR_OPERATION, 0x2E),
+ COMMAND_TIMEOUT_BEFORE_PROCESSING = 0x2E01,
+ COMMAND_TIMEOUT_DURING_PROCESSING = 0x2E02,
+ COMMAND_TIMEOUT_DURING_PROCESSING_DUE_TO_ERROR_RECOVERY = 0x2E03,
+
+ ASC(COMMANDS_CLEARED_BY_ANOTHER_INITIATOR, 0x2F),
+ COMMANDS_CLEARED_BY_POWER_LOSS_NOTIFICATION = 0x2F01,
+ COMMANDS_CLEARED_BY_DEVICE_SERVER = 0x2F02,
+ SOME_COMMANDS_CLEARED_BY_QUEUING_LAYER_EVENT = 0x2F03,
+
+ ASC(INCOMPATIBLE_MEDIUM_INSTALLED, 0x30),
+ CANNOT_READ_MEDIUM_UNKNOWN_FORMAT = 0x3001,
+ CANNOT_READ_MEDIUM_INCOMPATIBLE_FORMAT = 0x3002,
+ CLEANING_CARTRIDGE_INSTALLED = 0x3003,
+ CANNOT_WRITE_MEDIUM_UNKNOWN_FORMAT = 0x3004,
+ CANNOT_WRITE_MEDIUM_INCOMPATIBLE_FORMAT = 0x3005,
+ CANNOT_FORMAT_MEDIUM_INCOMPATIBLE_MEDIUM = 0x3006,
+ CLEANING_FAILURE = 0x3007,
+ CANNOT_WRITE_APPLICATION_CODE_MISMATCH = 0x3008,
+ CURRENT_SESSION_NOT_FIXATED_FOR_APPEND = 0x3009,
+ CLEANING_REQUEST_REJECTED = 0x300A,
+ WORM_MEDIUM_OVERWRITE_ATTEMPTED = 0x300C,
+ WORM_MEDIUM_INTEGRITY_CHECK = 0x300D,
+ MEDIUM_NOT_FORMATTED = 0x3010,
+ INCOMPATIBLE_VOLUME_TYPE = 0x3011,
+ INCOMPATIBLE_VOLUME_QUALIFIER = 0x3012,
+ CLEANING_VOLUME_EXPIRED = 0x3013,
+
+ ASC(MEDIUM_FORMAT_CORRUPTED, 0x31),
+ FORMAT_COMMAND_FAILED = 0x3101,
+ ZONED_FORMATTING_FAILED_DUE_TO_SPARE_LINKING = 0x3102,
+ SANITIZE_COMMAND_FAILED = 0x3103,
+ DEPOPULATION_FAILED = 0x3104,
+ DEPOPULATION_RESTORATION_FAILED = 0x3105,
+
+ ASC(NO_DEFECT_SPARE_LOCATION_AVAILABLE, 0x32),
+ DEFECT_LIST_UPDATE_FAILURE = 0x3201,
+
+ ASC(TAPE_LENGTH_ERROR, 0x33),
+
+ ASC(ENCLOSURE_FAILURE, 0x34),
+
+ ASC(ENCLOSURE_SERVICES_FAILURE, 0x35),
+ UNSUPPORTED_ENCLOSURE_FUNCTION = 0x3501,
+ ENCLOSURE_SERVICES_UNAVAILABLE = 0x3502,
+ ENCLOSURE_SERVICES_TRANSFER_FAILURE = 0x3503,
+ ENCLOSURE_SERVICES_TRANSFER_REFUSED = 0x3504,
+ ENCLOSURE_SERVICES_CHECKSUM_ERROR = 0x3505,
+
+ ASC(RIBBON_INK_OR_TONER_FAILURE, 0x36),
+
+ ASC(ROUNDED_PARAMETER, 0x37),
+
+ ASC(EVENT_STATUS_NOTIFICATION, 0x38),
+ ESN_POWER_MANAGEMENT_CLASS_EVENT = 0x3802,
+ ESN_MEDIA_CLASS_EVENT = 0x3804,
+ ESN_DEVICE_BUSY_CLASS_EVENT = 0x3806,
+ THIN_PROVISIONING_SOFT_THRESHOLD_REACHED = 0x3807,
+ DEPOPULATION_INTERRUPTED = 0x3808,
+ DEPOPULATION_RESTORATION_INTERRUPTED = 0x3809,
+
+ ASC(SAVING_PARAMETERS_NOT_SUPPORTED, 0x39),
+
+ ASC(MEDIUM_NOT_PRESENT, 0x3A),
+ MEDIUM_NOT_PRESENT_TRAY_CLOSED = 0x3A01,
+ MEDIUM_NOT_PRESENT_TRAY_OPEN = 0x3A02,
+ MEDIUM_NOT_PRESENT_LOADABLE = 0x3A03,
+ MEDIUM_NOT_PRESENT_MEDIUM_AUXILIARY_MEMORY_ACCESSIBLE = 0x3A04,
+
+ ASC(SEQUENTIAL_POSITIONING_ERROR, 0x3B),
+ TAPE_POSITION_ERROR_AT_BEGINNING_OF_MEDIUM = 0x3B01,
+ TAPE_POSITION_ERROR_AT_END_OF_MEDIUM = 0x3B02,
+ TAPE_OR_ELECTRONIC_VERTICAL_FORMS_UNIT_NOT_READY = 0x3B03,
+ SLEW_FAILURE = 0x3B04,
+ PAPER_JAM = 0x3B05,
+ FAILED_TO_SENSE_TOP_OF_FORM = 0x3B06,
+ FAILED_TO_SENSE_BOTTOM_OF_FORM = 0x3B07,
+ REPOSITION_ERROR = 0x3B08,
+ READ_PAST_END_OF_MEDIUM = 0x3B09,
+ READ_PAST_BEGINNING_OF_MEDIUM = 0x3B0A,
+ POSITION_PAST_END_OF_MEDIUM = 0x3B0B,
+ POSITION_PAST_BEGINNING_OF_MEDIUM = 0x3B0C,
+ MEDIUM_DESTINATION_ELEMENT_FULL = 0x3B0D,
+ MEDIUM_SOURCE_ELEMENT_EMPTY = 0x3B0E,
+ END_OF_MEDIUM_REACHED = 0x3B0F,
+ MEDIUM_MAGAZINE_NOT_ACCESSIBLE = 0x3B11,
+ MEDIUM_MAGAZINE_REMOVED = 0x3B12,
+ MEDIUM_MAGAZINE_INSERTED = 0x3B13,
+ MEDIUM_MAGAZINE_LOCKED = 0x3B14,
+ MEDIUM_MAGAZINE_UNLOCKED = 0x3B15,
+ MECHANICAL_POSITIONING_OR_CHANGER_ERROR = 0x3B16,
+ READ_PAST_END_OF_USER_OBJECT = 0x3B17,
+ ELEMENT_DISABLED = 0x3B18,
+ ELEMENT_ENABLED = 0x3B19,
+ DATA_TRANSFER_DEVICE_REMOVED = 0x3B1A,
+ DATA_TRANSFER_DEVICE_INSERTED = 0x3B1B,
+ TOO_MANY_LOGICAL_OBJECTS_ON_PARTITION_TO_SUPPORT_OP = 0x3B1C,
+ ELEMENT_STATIC_INFORMATION_CHANGED = 0x3B20,
+
+ ASC(INVALID_BITS_IN_IDENTIFY_MESSAGE, 0x3D),
+
+ ASC(LU_HAS_NOT_SELF_CONFIGURED_YET, 0x3E),
+ LU_FAILURE = 0x3E01,
+ TIMEOUT_ON_LOGICAL_UNIT = 0x3E02,
+ LU_FAILED_SELF_TEST = 0x3E03,
+ LU_UNABLE_TO_UPDATE_SELFTEST_LOG = 0x3E04,
+
+ ASC(TARGET_OPERATING_CONDITIONS_HAVE_CHANGED, 0x3F),
+ MICROCODE_HAS_BEEN_CHANGED = 0x3F01,
+ CHANGED_OPERATING_DEFINITION = 0x3F02,
+ INQUIRY_DATA_HAS_CHANGED = 0x3F03,
+ COMPONENT_DEVICE_ATTACHED = 0x3F04,
+ DEVICE_IDENTIFIER_CHANGED = 0x3F05,
+ REDUNDANCY_GROUP_CREATED_OR_MODIFIED = 0x3F06,
+ REDUNDANCY_GROUP_DELETED = 0x3F07,
+ SPARE_CREATED_OR_MODIFIED = 0x3F08,
+ SPARE_DELETED = 0x3F09,
+ VOLUME_SET_CREATED_OR_MODIFIED = 0x3F0A,
+ VOLUME_SET_DELETED = 0x3F0B,
+ VOLUME_SET_DEASSIGNED = 0x3F0C,
+ VOLUME_SET_REASSIGNED = 0x3F0D,
+ REPORTED_LUNS_DATA_HAS_CHANGED = 0x3F0E,
+ ECHO_BUFFER_OVERWRITTEN = 0x3F0F,
+ MEDIUM_LOADABLE = 0x3F10,
+ MEDIUM_AUXILIARY_MEMORY_ACCESSIBLE = 0x3F11,
+ iSCSI_IP_ADDRESS_ADDED = 0x3F12,
+ iSCSI_IP_ADDRESS_REMOVED = 0x3F13,
+ iSCSI_IP_ADDRESS_CHANGED = 0x3F14,
+ INSPECT_REFERRALS_SENSE_DESCRIPTORS = 0x3F15,
+ MICROCODE_HAS_BEEN_CHANGED_WITHOUT_RESET = 0x3F16,
+ ZONE_TRANSITION_TO_FULL = 0x3F17,
+ BIND_COMPLETED = 0x3F18,
+ BIND_REDIRECTED = 0x3F19,
+ SUBSIDIARY_BINDING_CHANGED = 0x3F1A,
+
+ ASC(RAM_FAILURE, 0x40),
+ /* DIAGNOSTIC_FAILURE_ON_COMPONENT_NN = 0x40NN */
+
+ ASC(DATA_PATH_FAILURE, 0x41),
+
+ ASC(POWER_ON_OR_SELFTEST_FAILURE, 0x42),
+
+ ASC(MESSAGE_ERROR, 0x43),
+
+ ASC(INTERNAL_TARGET_FAILURE, 0x44),
+ PERSISTENT_RESERVATION_INFORMATION_LOST = 0x4401,
+ ATA_DEVICE_FAILED_SET_FEATURES = 0x4471,
+
+ ASC(SELECT_OR_RESELECT_FAILURE, 0x45),
+
+ ASC(UNSUCCESSFUL_SOFT_RESET, 0x46),
+
+ ASC(SCSI_PARITY_ERROR, 0x47),
+ DATA_PHASE_CRC_ERROR_DETECTED = 0x4701,
+ SCSI_PARITY_ERROR_DETECTED_DURING_ST_DATA_PHASE = 0x4702,
+ INFORMATION_UNIT_iuCRC_ERROR_DETECTED = 0x4703,
+ ASYNCHRONOUS_INFORMATION_PROTECTION_ERROR_DETECTED = 0x4704,
+ PROTOCOL_SERVICE_CRC_ERROR = 0x4705,
+ PHY_TEST_FUNCTION_IN_PROGRESS = 0x4706,
+ SOME_COMMANDS_CLEARED_BY_ISCSI_PROTOCOL_EVENT = 0x477F,
+
+ ASC(INITIATOR_DETECTED_ERROR_MESSAGE_RECEIVED, 0x48),
+
+ ASC(INVALID_MESSAGE_ERROR, 0x49),
+
+ ASC(COMMAND_PHASE_ERROR, 0x4A),
+
+ ASC(DATA_PHASE_ERROR, 0x4B),
+ INVALID_TARGET_PORT_TRANSFER_TAG_RECEIVED = 0x4B01,
+ TOO_MUCH_WRITE_DATA = 0x4B02,
+ ACK_NAK_TIMEOUT = 0x4B03,
+ NAK_RECEIVED = 0x4B04,
+ DATA_OFFSET_ERROR = 0x4B05,
+ INITIATOR_RESPONSE_TIMEOUT = 0x4B06,
+ CONNECTION_LOST = 0x4B07,
+ DATA_IN_BUFFER_OVERFLOW_BUFFER_SIZE = 0x4B08,
+ DATA_IN_BUFFER_OVERFLOW_BUFFER_DESCRIPTOR_AREA = 0x4B09,
+ DATA_IN_BUFFER_ERROR = 0x4B0A,
+ DATA_OUT_BUFFER_OVERFLOW_BUFFER_SIZE = 0x4B0B,
+ DATA_OUT_BUFFER_OVERFLOW_BUFFER_DESCRIPTOR_AREA = 0x4B0C,
+ DATA_OUT_BUFFER_ERROR = 0x4B0D,
+ PCIE_FABRIC_ERROR = 0x4B0E,
+ PCIE_COMPLETION_TIMEOUT = 0x4B0F,
+ PCIE_COMPLETER_ABORT = 0x4B10,
+ PCIE_POISONED_TLP_RECEIVED = 0x4B11,
+ PCIE_ECRC_CHECK_FAILED = 0x4B12,
+ PCIE_UNSUPPORTED_REQUEST = 0x4B13,
+ PCIE_ACS_VIOLATION = 0x4B14,
+ PCIE_TLP_PREFIX_BLOCKED = 0x4B15,
+
+ ASC(LU_FAILED_SELF_CONFIGURATION, 0x4C),
+
+ ASC(TAGGED_OVERLAPPED_COMMANDS, 0x4D),
+
+ ASC(OVERLAPPED_COMMANDS_ATTEMPTED, 0x4E),
+
+ ASC(WRITE_APPEND_ERROR, 0x50),
+ WRITE_APPEND_POSITION_ERROR = 0x5001,
+ POSITION_ERROR_RELATED_TO_TIMING = 0x5002,
+
+ ASC(ERASE_FAILURE, 0x51),
+ ERASE_FAILURE_INCOMPLETE_ERASE_OP_DETECTED = 0x5101,
+
+ ASC(CARTRIDGE_FAULT, 0x52),
+
+ ASC(MEDIA_LOAD_OR_EJECT_FAILED, 0x53),
+ UNLOAD_TAPE_FAILURE = 0x5301,
+ MEDIUM_REMOVAL_PREVENTED = 0x5302,
+ MEDIUM_REMOVAL_PREVENTED_BY_DATA_TRANSFER_ELEMENT = 0x5303,
+ MEDIUM_THREAD_OR_UNTHREAD_FAILURE = 0x5304,
+ VOLUME_IDENTIFIER_INVALID = 0x5305,
+ VOLUME_IDENTIFIER_MISSING = 0x5306,
+ DUPLICATE_VOLUME_IDENTIFIER = 0x5307,
+ ELEMENT_STATUS_UNKNOWN = 0x5308,
+ DATA_TRANSFER_DEVICE_ERR_LOAD_FAILED = 0x5309,
+ DATA_TRANSFER_DEVICE_ERR_UNLOAD_FAILED = 0x530A,
+ DATA_TRANSFER_DEVICE_ERR_UNLOAD_MISSING = 0x530B,
+ DATA_TRANSFER_DEVICE_ERR_EJECT_FAILED = 0x530C,
+ DATA_TRANSFER_DEVICE_ERR_LIBRARY_COMMUNICATION_FAILED = 0x530D,
+
+ ASC(SCSI_TO_HOST_SYSTEM_INTERFACE_FAILURE, 0x54),
+
+ ASC(SYSTEM_RESOURCE_FAILURE, 0x55),
+ SYSTEM_BUFFER_FULL = 0x5501,
+ INSUFFICIENT_RESERVATION_RESOURCES = 0x5502,
+ INSUFFICIENT_RESOURCES = 0x5503,
+ INSUFFICIENT_REGISTRATION_RESOURCES = 0x5504,
+ INSUFFICIENT_ACCESS_CONTROL_RESOURCES = 0x5505,
+ AUXILIARY_MEMORY_OUT_OF_SPACE = 0x5506,
+ QUOTA_ERROR = 0x5507,
+ MAXIMUM_NUMBER_OF_SUPPLEMENTAL_DECRYPTION_KEYS_EXCEEDED = 0x5508,
+ MEDIUM_AUXILIARY_MEMORY_NOT_ACCESSIBLE = 0x5509,
+ DATA_CURRENTLY_UNAVAILABLE = 0x550A,
+ INSUFFICIENT_POWER_FOR_OPERATION = 0x550B,
+ INSUFFICIENT_RESOURCES_TO_CREATE_ROD = 0x550C,
+ INSUFFICIENT_RESOURCES_TO_CREATE_ROD_TOKEN = 0x550D,
+ INSUFFICIENT_ZONE_RESOURCES = 0x550E,
+ INSUFFICIENT_ZONE_RESOURCES_TO_COMPLETE_WRITE = 0x550F,
+ MAXIMUM_NUMBER_OF_STREAMS_OPEN = 0x5510,
+ INSUFFICIENT_RESOURCES_TO_BIND = 0x5511,
+
+ ASC(UNABLE_TO_RECOVER_TABLE_OF_CONTENTS, 0x57),
+
+ ASC(GENERATION_DOES_NOT_EXIST, 0x58),
+
+ ASC(UPDATED_BLOCK_READ, 0x59),
+
+ ASC(OPERATOR_REQUEST_OR_STATE_CHANGE_INPUT, 0x5A),
+ OPERATOR_MEDIUM_REMOVAL_REQUEST = 0x5A01,
+ OPERATOR_SELECTED_WRITE_PROTECT = 0x5A02,
+ OPERATOR_SELECTED_WRITE_PERMIT = 0x5A03,
+
+ ASC(LOG_EXCEPTION, 0x5B),
+ THRESHOLD_CONDITION_MET = 0x5B01,
+ LOG_COUNTER_AT_MAXIMUM = 0x5B02,
+ LOG_LIST_CODES_EXHAUSTED = 0x5B03,
+
+ ASC(RPL_STATUS_CHANGE, 0x5C),
+ SPINDLES_SYNCHRONIZED = 0x5C01,
+ SPINDLES_NOT_SYNCHRONIZED = 0x5C02,
+
+ ASC(FAILURE_PREDICTION_THRESHOLD_EXCEEDED, 0x5D),
+ MEDIA_FAILURE_PREDICTION_THRESHOLD_EXCEEDED = 0x5D01,
+ LU_FAILURE_PREDICTION_THRESHOLD_EXCEEDED = 0x5D02,
+ SPARE_AREA_EXHAUSTION_PREDICTION_THRESHOLD_EXCEEDED = 0x5D03,
+ HW_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D10,
+ HW_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D11,
+ HW_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D12,
+ HW_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D13,
+ HW_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D14,
+ HW_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D15,
+ HW_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D16,
+ HW_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D17,
+ HW_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D18,
+ HW_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D19,
+ HW_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D1A,
+ HW_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D1B,
+ HW_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D1C,
+ HW_IMPENDING_FAILURE_POWER_LOSS_PROTECTION_CIRCUIT = 0x5D1D,
+ CONTROLLER_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D20,
+ CONTROLLER_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D21,
+ CONTROLLER_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D22,
+ CONTROLLER_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D23,
+ CONTROLLER_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D24,
+ CONTROLLER_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D25,
+ CONTROLLER_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D26,
+ CONTROLLER_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D27,
+ CONTROLLER_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D28,
+ CONTROLLER_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D29,
+ CONTROLLER_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D2A,
+ CONTROLLER_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D2B,
+ CONTROLLER_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D2C,
+ DATA_CHANNEL_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D30,
+ DATA_CHANNEL_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D31,
+ DATA_CHANNEL_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D32,
+ DATA_CHANNEL_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D33,
+ DATA_CHANNEL_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D34,
+ DATA_CHANNEL_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D35,
+ DATA_CHANNEL_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D36,
+ DATA_CHANNEL_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D37,
+ DATA_CHANNEL_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D38,
+ DATA_CHANNEL_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D39,
+ DATA_CHANNEL_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D3A,
+ DATA_CHANNEL_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D3B,
+ DATA_CHANNEL_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D3C,
+ SERVO_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D40,
+ SERVO_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D41,
+ SERVO_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D42,
+ SERVO_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D43,
+ SERVO_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D44,
+ SERVO_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D45,
+ SERVO_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D46,
+ SERVO_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D47,
+ SERVO_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D48,
+ SERVO_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D49,
+ SERVO_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D4A,
+ SERVO_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D4B,
+ SERVO_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D4C,
+ SPINDLE_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D50,
+ SPINDLE_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D51,
+ SPINDLE_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D52,
+ SPINDLE_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D53,
+ SPINDLE_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D54,
+ SPINDLE_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D55,
+ SPINDLE_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D56,
+ SPINDLE_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D57,
+ SPINDLE_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D58,
+ SPINDLE_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D59,
+ SPINDLE_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D5A,
+ SPINDLE_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D5B,
+ SPINDLE_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D5C,
+ FW_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D60,
+ FW_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D61,
+ FW_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D62,
+ FW_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D63,
+ FW_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D64,
+ FW_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D65,
+ FW_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D66,
+ FW_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D67,
+ FW_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D68,
+ FW_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D69,
+ FW_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D6A,
+ FW_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D6B,
+ FW_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D6C,
+ MEDIA_IMPENDING_FAILURE_ENDURANCE_LIMIT_MET = 0x5D73,
+ FAILURE_PREDICTION_THRESHOLD_EXCEEDED_FALSE = 0x5DFF,
+
+ ASC(LOW_POWER_CONDITION_ON, 0x5E),
+ IDLE_CONDITION_ACTIVATED_BY_TIMER = 0x5E01,
+ STANDBY_CONDITION_ACTIVATED_BY_TIMER = 0x5E02,
+ IDLE_CONDITION_ACTIVATED_BY_COMMAND = 0x5E03,
+ STANDBY_CONDITION_ACTIVATED_BY_COMMAND = 0x5E04,
+ IDLE_B_CONDITION_ACTIVATED_BY_TIMER = 0x5E05,
+ IDLE_B_CONDITION_ACTIVATED_BY_COMMAND = 0x5E06,
+ IDLE_C_CONDITION_ACTIVATED_BY_TIMER = 0x5E07,
+ IDLE_C_CONDITION_ACTIVATED_BY_COMMAND = 0x5E08,
+ STANDBY_Y_CONDITION_ACTIVATED_BY_TIMER = 0x5E09,
+ STANDBY_Y_CONDITION_ACTIVATED_BY_COMMAND = 0x5E0A,
+ POWER_STATE_CHANGE_TO_ACTIVE = 0x5E41,
+ POWER_STATE_CHANGE_TO_IDLE = 0x5E42,
+ POWER_STATE_CHANGE_TO_STANDBY = 0x5E43,
+ POWER_STATE_CHANGE_TO_SLEEP = 0x5E45,
+ POWER_STATE_CHANGE_TO_DEVICE_CONTROL = 0x5E47,
+
+ ASC(LAMP_FAILURE, 0x60),
+
+ ASC(VIDEO_ACQUISITION_ERROR, 0x61),
+ UNABLE_TO_ACQUIRE_VIDEO = 0x6101,
+ OUT_OF_FOCUS = 0x6102,
+
+ ASC(SCAN_HEAD_POSITIONING_ERROR, 0x62),
+
+ ASC(END_OF_USER_AREA_ENCOUNTERED_ON_THIS_TRACK, 0x63),
+ PACKET_DOES_NOT_FIT_IN_AVAILABLE_SPACE = 0x6301,
+
+ ASC(ILLEGAL_MODE_FOR_THIS_TRACK, 0x64),
+ INVALID_PACKET_SIZE = 0x6401,
+
+ ASC(VOLTAGE_FAULT, 0x65),
+
+ ASC(AUTOMATIC_DOCUMENT_FEEDER_COVER_UP, 0x66),
+ AUTOMATIC_DOCUMENT_FEEDER_LIFT_UP = 0x6601,
+ DOCUMENT_JAM_IN_AUTOMATIC_DOCUMENT_FEEDER = 0x6602,
+ DOCUMENT_MISS_FEED_AUTOMATIC_IN_DOCUMENT_FEEDER = 0x6603,
+
+ ASC(CONFIG_FAILURE, 0x67),
+ CONFIG_OF_INCAPABLE_LOGICAL_UNITS_FAILED = 0x6701,
+ ADD_LU_FAILED = 0x6702,
+ MODIFICATION_OF_LU_FAILED = 0x6703,
+ EXCHANGE_OF_LU_FAILED = 0x6704,
+ REMOVE_OF_LU_FAILED = 0x6705,
+ ATTACHMENT_OF_LU_FAILED = 0x6706,
+ CREATION_OF_LU_FAILED = 0x6707,
+ ASSIGN_FAILURE_OCCURRED = 0x6708,
+ MULTIPLY_ASSIGNED_LOGICAL_UNIT = 0x6709,
+ SET_TARGET_PORT_GROUPS_COMMAND_FAILED = 0x670A,
+ ATA_DEVICE_FEATURE_NOT_ENABLED = 0x670B,
+ COMMAND_REJECTED = 0x670C,
+ EXPLICIT_BIND_NOT_ALLOWED = 0x670D,
+ FEATURE_NOT_ENABLED = 0x670E,
+
+ ASC(LU_NOT_CONFIGURED, 0x68),
+ SUBSIDIARY_LU_NOT_CONFIGURED = 0x6801,
+
+ ASC(DATA_LOSS_ON_LOGICAL_UNIT, 0x69),
+ MULTIPLE_LU_FAILURES = 0x6901,
+ PARITY_DATA_MISMATCH = 0x6902,
+
+ ASC(INFORMATIONAL_REFER_TO_LOG, 0x6A),
+
+ ASC(STATE_CHANGE_HAS_OCCURRED, 0x6B),
+ REDUNDANCY_LEVEL_GOT_BETTER = 0x6B01,
+ REDUNDANCY_LEVEL_GOT_WORSE = 0x6B02,
+
+ ASC(REBUILD_FAILURE_OCCURRED, 0x6C),
+
+ ASC(RECALCULATE_FAILURE_OCCURRED, 0x6D),
+
+ ASC(COMMAND_TO_LU_FAILED, 0x6E),
+
+ ASC(COPY_PROTECTION_KEY_EXCHANGE_FAILURE_AUTHENTICATION_FAILURE, 0x6F),
+ COPY_PROTECTION_KEY_EXCHANGE_FAILURE_KEY_NOT_PRESENT = 0x6F01,
+ COPY_PROTECTION_KEY_EXCHANGE_FAILURE_KEY_NOT_ESTABLISHED = 0x6F02,
+ READ_OF_SCRAMBLED_SECTOR_WITHOUT_AUTHENTICATION = 0x6F03,
+ MEDIA_REGION_CODE_IS_MISMATCHED_TO_LU_REGION = 0x6F04,
+ DRIVE_REGION_MUST_BE_PERMANENT_REGION_RESET_COUNT_ERROR = 0x6F05,
+ INSUFFICIENT_BLOCK_COUNT_FOR_BINDING_NONCE_RECORDING = 0x6F06,
+ CONFLICT_IN_BINDING_NONCE_RECORDING = 0x6F07,
+ INSUFFICIENT_PERMISSION = 0x6F08,
+ INVALID_DRIVE_HOST_PAIRING_SERVER = 0x6F09,
+ DRIVE_HOST_PAIRING_SUSPENDED = 0x6F0A,
+
+ ASC(DECOMPRESSION_EXCEPTION_SHORT_ALGORITHM_ID, 0x70),
+
+ ASC(DECOMPRESSION_EXCEPTION_LONG_ALGORITHM_ID, 0x71),
+
+ ASC(SESSION_FIXATION_ERROR, 0x72),
+ SESSION_FIXATION_ERROR_WRITING_LEAD_IN = 0x7201,
+ SESSION_FIXATION_ERROR_WRITING_LEAD_OUT = 0x7202,
+ SESSION_FIXATION_ERROR_INCOMPLETE_TRACK_IN_SESSION = 0x7203,
+ EMPTY_OR_PARTIALLY_WRITTEN_RESERVED_TRACK = 0x7204,
+ NO_MORE_TRACK_RESERVATIONS_ALLOWED = 0x7205,
+ RMZ_EXTENSION_IS_NOT_ALLOWED = 0x7206,
+ NO_MORE_TEST_ZONE_EXTENSIONS_ARE_ALLOWED = 0x7207,
+
+ ASC(CD_CONTROL_ERROR, 0x73),
+ POWER_CALIBRATION_AREA_ALMOST_FULL = 0x7301,
+ POWER_CALIBRATION_AREA_IS_FULL = 0x7302,
+ POWER_CALIBRATION_AREA_ERROR = 0x7303,
+ PROGRAM_MEMORY_AREA_UPDATE_FAILURE = 0x7304,
+ PROGRAM_MEMORY_AREA_IS_FULL = 0x7305,
+ RMA_PMA_IS_ALMOST_FULL = 0x7306,
+ CURRENT_POWER_CALIBRATION_AREA_ALMOST_FULL = 0x7310,
+ CURRENT_POWER_CALIBRATION_AREA_IS_FULL = 0x7311,
+ RDZ_IS_FULL = 0x7317,
+
+ ASC(SECURITY_ERROR, 0x74),
+ UNABLE_TO_DECRYPT_DATA = 0x7401,
+ UNENCRYPTED_DATA_ENCOUNTERED_WHILE_DECRYPTING = 0x7402,
+ INCORRECT_DATA_ENCRYPTION_KEY = 0x7403,
+ CRYPTOGRAPHIC_INTEGRITY_VALIDATION_FAILED = 0x7404,
+ ERROR_DECRYPTING_DATA = 0x7405,
+ UNKNOWN_SIGNATURE_VERIFICATION_KEY = 0x7406,
+ ENCRYPTION_PARAMS_NOT_USEABLE = 0x7407,
+ DIGITAL_SIGNATURE_VALIDATION_FAILURE = 0x7408,
+ ENCRYPTION_MODE_MISMATCH_ON_READ = 0x7409,
+ ENCRYPTED_BLOCK_NOT_RAW_READ_ENABLED = 0x740A,
+ INCORRECT_ENCRYPTION_PARAMS = 0x740B,
+ UNABLE_TO_DECRYPT_PARAMETER_LIST = 0x740C,
+ ENCRYPTION_ALGORITHM_DISABLED = 0x740D,
+ SA_CREATION_PARAMETER_VALUE_INVALID = 0x7410,
+ SA_CREATION_PARAMETER_VALUE_REJECTED = 0x7411,
+ INVALID_SA_USAGE = 0x7412,
+ DATA_ENCRYPTION_CONFIG_PREVENTED = 0x7421,
+ SA_CREATION_PARAMETER_NOT_SUPPORTED = 0x7430,
+ AUTHENTICATION_FAILED = 0x7440,
+ EXTERNAL_DATA_ENCRYPTION_KEY_MANAGER_ACCESS_ERROR = 0x7461,
+ EXTERNAL_DATA_ENCRYPTION_KEY_MANAGER_ERROR = 0x7462,
+ EXTERNAL_DATA_ENCRYPTION_KEY_NOT_FOUND = 0x7463,
+ EXTERNAL_DATA_ENCRYPTION_REQUEST_NOT_AUTHORIZED = 0x7464,
+ EXTERNAL_DATA_ENCRYPTION_CONTROL_TIMEOUT = 0x746E,
+ EXTERNAL_DATA_ENCRYPTION_CONTROL_ERROR = 0x746F,
+ LU_ACCESS_NOT_AUTHORIZED = 0x7471,
+ SECURITY_CONFLICT_IN_TRANSLATED_DEVICE = 0x7479,
+};
+
+#undef ASC_DEF
+#undef ASC
+
+/*
+ * Use this to build non-standard sense codes.
+ * Note: this is defined as a macro instead of an inline function so that it can
+ * be used to define SCSI failures array variables (see struct scsi_failure).
+ */
+#define scsi_sense_code(asc, ascq) \
+ ((((asc) & 0xff) << 8) | ((ascq) & 0xff))
+
+static inline u8 scsi_sense_code_asc(u16 code)
+{
+ return (code >> 8) & 0xff;
+}
+
+static inline u8 scsi_sense_code_ascq(u16 code)
+{
+ return code & 0xff;
+}
+
+#endif /* _SCSI_SENSE_H_ */
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 02/37] scsi: constants: use defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
2026-08-31 2:04 ` [PATCH 01/37] scsi: define all additional sense codes and their qualifiers Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 03/37] scsi: constants: rename internal struct field names Damien Le Moal
` (35 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
The SENSE_CODE() macro is used for defining the array of struct error_info
which associates a string description to an additional sense code and its
combinations with additional sense code qualifiers. These are however
hardcoded values.
Now that all 16-bits sense codes are defined as macros in
include/scsi/scsi_sense.h, modify sense_codes.h to use the defined
sense code macros. While doing this, 2 missing entries are added for the
codes OVERLAPPING_ATOMIC_COMMAND_IN_PROGRESS and
DEPOPULATION_RESTORATION_INTERRUPTED.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/sense_codes.h | 2496 +++++++++++++++++++++++-------------
1 file changed, 1631 insertions(+), 865 deletions(-)
diff --git a/drivers/scsi/sense_codes.h b/drivers/scsi/sense_codes.h
index 805d4c13d070..2394c227a853 100644
--- a/drivers/scsi/sense_codes.h
+++ b/drivers/scsi/sense_codes.h
@@ -4,876 +4,1642 @@
* http://www.t10.org/lists/asc-num.txt [most recent: 20200817]
*/
-SENSE_CODE(0x0000, "No additional sense information")
-SENSE_CODE(0x0001, "Filemark detected")
-SENSE_CODE(0x0002, "End-of-partition/medium detected")
-SENSE_CODE(0x0003, "Setmark detected")
-SENSE_CODE(0x0004, "Beginning-of-partition/medium detected")
-SENSE_CODE(0x0005, "End-of-data detected")
-SENSE_CODE(0x0006, "I/O process terminated")
-SENSE_CODE(0x0007, "Programmable early warning detected")
-SENSE_CODE(0x0011, "Audio play operation in progress")
-SENSE_CODE(0x0012, "Audio play operation paused")
-SENSE_CODE(0x0013, "Audio play operation successfully completed")
-SENSE_CODE(0x0014, "Audio play operation stopped due to error")
-SENSE_CODE(0x0015, "No current audio status to return")
-SENSE_CODE(0x0016, "Operation in progress")
-SENSE_CODE(0x0017, "Cleaning requested")
-SENSE_CODE(0x0018, "Erase operation in progress")
-SENSE_CODE(0x0019, "Locate operation in progress")
-SENSE_CODE(0x001A, "Rewind operation in progress")
-SENSE_CODE(0x001B, "Set capacity operation in progress")
-SENSE_CODE(0x001C, "Verify operation in progress")
-SENSE_CODE(0x001D, "ATA pass through information available")
-SENSE_CODE(0x001E, "Conflicting SA creation request")
-SENSE_CODE(0x001F, "Logical unit transitioning to another power condition")
-SENSE_CODE(0x0020, "Extended copy information available")
-SENSE_CODE(0x0021, "Atomic command aborted due to ACA")
-SENSE_CODE(0x0022, "Deferred microcode is pending")
-
-SENSE_CODE(0x0100, "No index/sector signal")
-
-SENSE_CODE(0x0200, "No seek complete")
-
-SENSE_CODE(0x0300, "Peripheral device write fault")
-SENSE_CODE(0x0301, "No write current")
-SENSE_CODE(0x0302, "Excessive write errors")
-
-SENSE_CODE(0x0400, "Logical unit not ready, cause not reportable")
-SENSE_CODE(0x0401, "Logical unit is in process of becoming ready")
-SENSE_CODE(0x0402, "Logical unit not ready, initializing command required")
-SENSE_CODE(0x0403, "Logical unit not ready, manual intervention required")
-SENSE_CODE(0x0404, "Logical unit not ready, format in progress")
-SENSE_CODE(0x0405, "Logical unit not ready, rebuild in progress")
-SENSE_CODE(0x0406, "Logical unit not ready, recalculation in progress")
-SENSE_CODE(0x0407, "Logical unit not ready, operation in progress")
-SENSE_CODE(0x0408, "Logical unit not ready, long write in progress")
-SENSE_CODE(0x0409, "Logical unit not ready, self-test in progress")
-SENSE_CODE(0x040A, "Logical unit not accessible, asymmetric access state transition")
-SENSE_CODE(0x040B, "Logical unit not accessible, target port in standby state")
-SENSE_CODE(0x040C, "Logical unit not accessible, target port in unavailable state")
-SENSE_CODE(0x040D, "Logical unit not ready, structure check required")
-SENSE_CODE(0x040E, "Logical unit not ready, security session in progress")
-SENSE_CODE(0x0410, "Logical unit not ready, auxiliary memory not accessible")
-SENSE_CODE(0x0411, "Logical unit not ready, notify (enable spinup) required")
-SENSE_CODE(0x0412, "Logical unit not ready, offline")
-SENSE_CODE(0x0413, "Logical unit not ready, SA creation in progress")
-SENSE_CODE(0x0414, "Logical unit not ready, space allocation in progress")
-SENSE_CODE(0x0415, "Logical unit not ready, robotics disabled")
-SENSE_CODE(0x0416, "Logical unit not ready, configuration required")
-SENSE_CODE(0x0417, "Logical unit not ready, calibration required")
-SENSE_CODE(0x0418, "Logical unit not ready, a door is open")
-SENSE_CODE(0x0419, "Logical unit not ready, operating in sequential mode")
-SENSE_CODE(0x041A, "Logical unit not ready, start stop unit command in progress")
-SENSE_CODE(0x041B, "Logical unit not ready, sanitize in progress")
-SENSE_CODE(0x041C, "Logical unit not ready, additional power use not yet granted")
-SENSE_CODE(0x041D, "Logical unit not ready, configuration in progress")
-SENSE_CODE(0x041E, "Logical unit not ready, microcode activation required")
-SENSE_CODE(0x041F, "Logical unit not ready, microcode download required")
-SENSE_CODE(0x0420, "Logical unit not ready, logical unit reset required")
-SENSE_CODE(0x0421, "Logical unit not ready, hard reset required")
-SENSE_CODE(0x0422, "Logical unit not ready, power cycle required")
-SENSE_CODE(0x0423, "Logical unit not ready, affiliation required")
-SENSE_CODE(0x0424, "Depopulation in progress")
-SENSE_CODE(0x0425, "Depopulation restoration in progress")
-
-SENSE_CODE(0x0500, "Logical unit does not respond to selection")
-
-SENSE_CODE(0x0600, "No reference position found")
-
-SENSE_CODE(0x0700, "Multiple peripheral devices selected")
-
-SENSE_CODE(0x0800, "Logical unit communication failure")
-SENSE_CODE(0x0801, "Logical unit communication time-out")
-SENSE_CODE(0x0802, "Logical unit communication parity error")
-SENSE_CODE(0x0803, "Logical unit communication CRC error (Ultra-DMA/32)")
-SENSE_CODE(0x0804, "Unreachable copy target")
-
-SENSE_CODE(0x0900, "Track following error")
-SENSE_CODE(0x0901, "Tracking servo failure")
-SENSE_CODE(0x0902, "Focus servo failure")
-SENSE_CODE(0x0903, "Spindle servo failure")
-SENSE_CODE(0x0904, "Head select fault")
-SENSE_CODE(0x0905, "Vibration induced tracking error")
-
-SENSE_CODE(0x0A00, "Error log overflow")
-
-SENSE_CODE(0x0B00, "Warning")
-SENSE_CODE(0x0B01, "Warning - specified temperature exceeded")
-SENSE_CODE(0x0B02, "Warning - enclosure degraded")
-SENSE_CODE(0x0B03, "Warning - background self-test failed")
-SENSE_CODE(0x0B04, "Warning - background pre-scan detected medium error")
-SENSE_CODE(0x0B05, "Warning - background medium scan detected medium error")
-SENSE_CODE(0x0B06, "Warning - non-volatile cache now volatile")
-SENSE_CODE(0x0B07, "Warning - degraded power to non-volatile cache")
-SENSE_CODE(0x0B08, "Warning - power loss expected")
-SENSE_CODE(0x0B09, "Warning - device statistics notification active")
-SENSE_CODE(0x0B0A, "Warning - high critical temperature limit exceeded")
-SENSE_CODE(0x0B0B, "Warning - low critical temperature limit exceeded")
-SENSE_CODE(0x0B0C, "Warning - high operating temperature limit exceeded")
-SENSE_CODE(0x0B0D, "Warning - low operating temperature limit exceeded")
-SENSE_CODE(0x0B0E, "Warning - high critical humidity limit exceeded")
-SENSE_CODE(0x0B0F, "Warning - low critical humidity limit exceeded")
-SENSE_CODE(0x0B10, "Warning - high operating humidity limit exceeded")
-SENSE_CODE(0x0B11, "Warning - low operating humidity limit exceeded")
-SENSE_CODE(0x0B12, "Warning - microcode security at risk")
-SENSE_CODE(0x0B13, "Warning - microcode digital signature validation failure")
-SENSE_CODE(0x0B14, "Warning - physical element status change")
-
-SENSE_CODE(0x0C00, "Write error")
-SENSE_CODE(0x0C01, "Write error - recovered with auto reallocation")
-SENSE_CODE(0x0C02, "Write error - auto reallocation failed")
-SENSE_CODE(0x0C03, "Write error - recommend reassignment")
-SENSE_CODE(0x0C04, "Compression check miscompare error")
-SENSE_CODE(0x0C05, "Data expansion occurred during compression")
-SENSE_CODE(0x0C06, "Block not compressible")
-SENSE_CODE(0x0C07, "Write error - recovery needed")
-SENSE_CODE(0x0C08, "Write error - recovery failed")
-SENSE_CODE(0x0C09, "Write error - loss of streaming")
-SENSE_CODE(0x0C0A, "Write error - padding blocks added")
-SENSE_CODE(0x0C0B, "Auxiliary memory write error")
-SENSE_CODE(0x0C0C, "Write error - unexpected unsolicited data")
-SENSE_CODE(0x0C0D, "Write error - not enough unsolicited data")
-SENSE_CODE(0x0C0E, "Multiple write errors")
-SENSE_CODE(0x0C0F, "Defects in error window")
-SENSE_CODE(0x0C10, "Incomplete multiple atomic write operations")
-SENSE_CODE(0x0C11, "Write error - recovery scan needed")
-SENSE_CODE(0x0C12, "Write error - insufficient zone resources")
-
-SENSE_CODE(0x0D00, "Error detected by third party temporary initiator")
-SENSE_CODE(0x0D01, "Third party device failure")
-SENSE_CODE(0x0D02, "Copy target device not reachable")
-SENSE_CODE(0x0D03, "Incorrect copy target device type")
-SENSE_CODE(0x0D04, "Copy target device data underrun")
-SENSE_CODE(0x0D05, "Copy target device data overrun")
-
-SENSE_CODE(0x0E00, "Invalid information unit")
-SENSE_CODE(0x0E01, "Information unit too short")
-SENSE_CODE(0x0E02, "Information unit too long")
-SENSE_CODE(0x0E03, "Invalid field in command information unit")
-
-SENSE_CODE(0x1000, "Id CRC or ECC error")
-SENSE_CODE(0x1001, "Logical block guard check failed")
-SENSE_CODE(0x1002, "Logical block application tag check failed")
-SENSE_CODE(0x1003, "Logical block reference tag check failed")
-SENSE_CODE(0x1004, "Logical block protection error on recover buffered data")
-SENSE_CODE(0x1005, "Logical block protection method error")
-
-SENSE_CODE(0x1100, "Unrecovered read error")
-SENSE_CODE(0x1101, "Read retries exhausted")
-SENSE_CODE(0x1102, "Error too long to correct")
-SENSE_CODE(0x1103, "Multiple read errors")
-SENSE_CODE(0x1104, "Unrecovered read error - auto reallocate failed")
-SENSE_CODE(0x1105, "L-EC uncorrectable error")
-SENSE_CODE(0x1106, "CIRC unrecovered error")
-SENSE_CODE(0x1107, "Data re-synchronization error")
-SENSE_CODE(0x1108, "Incomplete block read")
-SENSE_CODE(0x1109, "No gap found")
-SENSE_CODE(0x110A, "Miscorrected error")
-SENSE_CODE(0x110B, "Unrecovered read error - recommend reassignment")
-SENSE_CODE(0x110C, "Unrecovered read error - recommend rewrite the data")
-SENSE_CODE(0x110D, "De-compression CRC error")
-SENSE_CODE(0x110E, "Cannot decompress using declared algorithm")
-SENSE_CODE(0x110F, "Error reading UPC/EAN number")
-SENSE_CODE(0x1110, "Error reading ISRC number")
-SENSE_CODE(0x1111, "Read error - loss of streaming")
-SENSE_CODE(0x1112, "Auxiliary memory read error")
-SENSE_CODE(0x1113, "Read error - failed retransmission request")
-SENSE_CODE(0x1114, "Read error - lba marked bad by application client")
-SENSE_CODE(0x1115, "Write after sanitize required")
-
-SENSE_CODE(0x1200, "Address mark not found for id field")
-
-SENSE_CODE(0x1300, "Address mark not found for data field")
-
-SENSE_CODE(0x1400, "Recorded entity not found")
-SENSE_CODE(0x1401, "Record not found")
-SENSE_CODE(0x1402, "Filemark or setmark not found")
-SENSE_CODE(0x1403, "End-of-data not found")
-SENSE_CODE(0x1404, "Block sequence error")
-SENSE_CODE(0x1405, "Record not found - recommend reassignment")
-SENSE_CODE(0x1406, "Record not found - data auto-reallocated")
-SENSE_CODE(0x1407, "Locate operation failure")
-
-SENSE_CODE(0x1500, "Random positioning error")
-SENSE_CODE(0x1501, "Mechanical positioning error")
-SENSE_CODE(0x1502, "Positioning error detected by read of medium")
-
-SENSE_CODE(0x1600, "Data synchronization mark error")
-SENSE_CODE(0x1601, "Data sync error - data rewritten")
-SENSE_CODE(0x1602, "Data sync error - recommend rewrite")
-SENSE_CODE(0x1603, "Data sync error - data auto-reallocated")
-SENSE_CODE(0x1604, "Data sync error - recommend reassignment")
-
-SENSE_CODE(0x1700, "Recovered data with no error correction applied")
-SENSE_CODE(0x1701, "Recovered data with retries")
-SENSE_CODE(0x1702, "Recovered data with positive head offset")
-SENSE_CODE(0x1703, "Recovered data with negative head offset")
-SENSE_CODE(0x1704, "Recovered data with retries and/or circ applied")
-SENSE_CODE(0x1705, "Recovered data using previous sector id")
-SENSE_CODE(0x1706, "Recovered data without ECC - data auto-reallocated")
-SENSE_CODE(0x1707, "Recovered data without ECC - recommend reassignment")
-SENSE_CODE(0x1708, "Recovered data without ECC - recommend rewrite")
-SENSE_CODE(0x1709, "Recovered data without ECC - data rewritten")
-
-SENSE_CODE(0x1800, "Recovered data with error correction applied")
-SENSE_CODE(0x1801, "Recovered data with error corr. & retries applied")
-SENSE_CODE(0x1802, "Recovered data - data auto-reallocated")
-SENSE_CODE(0x1803, "Recovered data with CIRC")
-SENSE_CODE(0x1804, "Recovered data with L-EC")
-SENSE_CODE(0x1805, "Recovered data - recommend reassignment")
-SENSE_CODE(0x1806, "Recovered data - recommend rewrite")
-SENSE_CODE(0x1807, "Recovered data with ECC - data rewritten")
-SENSE_CODE(0x1808, "Recovered data with linking")
-
-SENSE_CODE(0x1900, "Defect list error")
-SENSE_CODE(0x1901, "Defect list not available")
-SENSE_CODE(0x1902, "Defect list error in primary list")
-SENSE_CODE(0x1903, "Defect list error in grown list")
-
-SENSE_CODE(0x1A00, "Parameter list length error")
-
-SENSE_CODE(0x1B00, "Synchronous data transfer error")
-
-SENSE_CODE(0x1C00, "Defect list not found")
-SENSE_CODE(0x1C01, "Primary defect list not found")
-SENSE_CODE(0x1C02, "Grown defect list not found")
-
-SENSE_CODE(0x1D00, "Miscompare during verify operation")
-SENSE_CODE(0x1D01, "Miscompare verify of unmapped LBA")
-
-SENSE_CODE(0x1E00, "Recovered id with ECC correction")
-
-SENSE_CODE(0x1F00, "Partial defect list transfer")
-
-SENSE_CODE(0x2000, "Invalid command operation code")
-SENSE_CODE(0x2001, "Access denied - initiator pending-enrolled")
-SENSE_CODE(0x2002, "Access denied - no access rights")
-SENSE_CODE(0x2003, "Access denied - invalid mgmt id key")
-SENSE_CODE(0x2004, "Illegal command while in write capable state")
-SENSE_CODE(0x2005, "Obsolete")
-SENSE_CODE(0x2006, "Illegal command while in explicit address mode")
-SENSE_CODE(0x2007, "Illegal command while in implicit address mode")
-SENSE_CODE(0x2008, "Access denied - enrollment conflict")
-SENSE_CODE(0x2009, "Access denied - invalid LU identifier")
-SENSE_CODE(0x200A, "Access denied - invalid proxy token")
-SENSE_CODE(0x200B, "Access denied - ACL LUN conflict")
-SENSE_CODE(0x200C, "Illegal command when not in append-only mode")
-SENSE_CODE(0x200D, "Not an administrative logical unit")
-SENSE_CODE(0x200E, "Not a subsidiary logical unit")
-SENSE_CODE(0x200F, "Not a conglomerate logical unit")
-
-SENSE_CODE(0x2100, "Logical block address out of range")
-SENSE_CODE(0x2101, "Invalid element address")
-SENSE_CODE(0x2102, "Invalid address for write")
-SENSE_CODE(0x2103, "Invalid write crossing layer jump")
-SENSE_CODE(0x2104, "Unaligned write command")
-SENSE_CODE(0x2105, "Write boundary violation")
-SENSE_CODE(0x2106, "Attempt to read invalid data")
-SENSE_CODE(0x2107, "Read boundary violation")
-SENSE_CODE(0x2108, "Misaligned write command")
-SENSE_CODE(0x2109, "Attempt to access gap zone")
-
-SENSE_CODE(0x2200, "Illegal function (use 20 00, 24 00, or 26 00)")
-
-SENSE_CODE(0x2300, "Invalid token operation, cause not reportable")
-SENSE_CODE(0x2301, "Invalid token operation, unsupported token type")
-SENSE_CODE(0x2302, "Invalid token operation, remote token usage not supported")
-SENSE_CODE(0x2303, "Invalid token operation, remote rod token creation not supported")
-SENSE_CODE(0x2304, "Invalid token operation, token unknown")
-SENSE_CODE(0x2305, "Invalid token operation, token corrupt")
-SENSE_CODE(0x2306, "Invalid token operation, token revoked")
-SENSE_CODE(0x2307, "Invalid token operation, token expired")
-SENSE_CODE(0x2308, "Invalid token operation, token cancelled")
-SENSE_CODE(0x2309, "Invalid token operation, token deleted")
-SENSE_CODE(0x230A, "Invalid token operation, invalid token length")
-
-SENSE_CODE(0x2400, "Invalid field in cdb")
-SENSE_CODE(0x2401, "CDB decryption error")
-SENSE_CODE(0x2402, "Obsolete")
-SENSE_CODE(0x2403, "Obsolete")
-SENSE_CODE(0x2404, "Security audit value frozen")
-SENSE_CODE(0x2405, "Security working key frozen")
-SENSE_CODE(0x2406, "Nonce not unique")
-SENSE_CODE(0x2407, "Nonce timestamp out of range")
-SENSE_CODE(0x2408, "Invalid XCDB")
-SENSE_CODE(0x2409, "Invalid fast format")
-
-SENSE_CODE(0x2500, "Logical unit not supported")
-
-SENSE_CODE(0x2600, "Invalid field in parameter list")
-SENSE_CODE(0x2601, "Parameter not supported")
-SENSE_CODE(0x2602, "Parameter value invalid")
-SENSE_CODE(0x2603, "Threshold parameters not supported")
-SENSE_CODE(0x2604, "Invalid release of persistent reservation")
-SENSE_CODE(0x2605, "Data decryption error")
-SENSE_CODE(0x2606, "Too many target descriptors")
-SENSE_CODE(0x2607, "Unsupported target descriptor type code")
-SENSE_CODE(0x2608, "Too many segment descriptors")
-SENSE_CODE(0x2609, "Unsupported segment descriptor type code")
-SENSE_CODE(0x260A, "Unexpected inexact segment")
-SENSE_CODE(0x260B, "Inline data length exceeded")
-SENSE_CODE(0x260C, "Invalid operation for copy source or destination")
-SENSE_CODE(0x260D, "Copy segment granularity violation")
-SENSE_CODE(0x260E, "Invalid parameter while port is enabled")
-SENSE_CODE(0x260F, "Invalid data-out buffer integrity check value")
-SENSE_CODE(0x2610, "Data decryption key fail limit reached")
-SENSE_CODE(0x2611, "Incomplete key-associated data set")
-SENSE_CODE(0x2612, "Vendor specific key reference not found")
-SENSE_CODE(0x2613, "Application tag mode page is invalid")
-SENSE_CODE(0x2614, "Tape stream mirroring prevented")
-SENSE_CODE(0x2615, "Copy source or copy destination not authorized")
-SENSE_CODE(0x2616, "Fast copy not possible")
-
-SENSE_CODE(0x2700, "Write protected")
-SENSE_CODE(0x2701, "Hardware write protected")
-SENSE_CODE(0x2702, "Logical unit software write protected")
-SENSE_CODE(0x2703, "Associated write protect")
-SENSE_CODE(0x2704, "Persistent write protect")
-SENSE_CODE(0x2705, "Permanent write protect")
-SENSE_CODE(0x2706, "Conditional write protect")
-SENSE_CODE(0x2707, "Space allocation failed write protect")
-SENSE_CODE(0x2708, "Zone is read only")
-
-SENSE_CODE(0x2800, "Not ready to ready change, medium may have changed")
-SENSE_CODE(0x2801, "Import or export element accessed")
-SENSE_CODE(0x2802, "Format-layer may have changed")
-SENSE_CODE(0x2803, "Import/export element accessed, medium changed")
-
-SENSE_CODE(0x2900, "Power on, reset, or bus device reset occurred")
-SENSE_CODE(0x2901, "Power on occurred")
-SENSE_CODE(0x2902, "Scsi bus reset occurred")
-SENSE_CODE(0x2903, "Bus device reset function occurred")
-SENSE_CODE(0x2904, "Device internal reset")
-SENSE_CODE(0x2905, "Transceiver mode changed to single-ended")
-SENSE_CODE(0x2906, "Transceiver mode changed to lvd")
-SENSE_CODE(0x2907, "I_T nexus loss occurred")
-
-SENSE_CODE(0x2A00, "Parameters changed")
-SENSE_CODE(0x2A01, "Mode parameters changed")
-SENSE_CODE(0x2A02, "Log parameters changed")
-SENSE_CODE(0x2A03, "Reservations preempted")
-SENSE_CODE(0x2A04, "Reservations released")
-SENSE_CODE(0x2A05, "Registrations preempted")
-SENSE_CODE(0x2A06, "Asymmetric access state changed")
-SENSE_CODE(0x2A07, "Implicit asymmetric access state transition failed")
-SENSE_CODE(0x2A08, "Priority changed")
-SENSE_CODE(0x2A09, "Capacity data has changed")
-SENSE_CODE(0x2A0A, "Error history I_T nexus cleared")
-SENSE_CODE(0x2A0B, "Error history snapshot released")
-SENSE_CODE(0x2A0C, "Error recovery attributes have changed")
-SENSE_CODE(0x2A0D, "Data encryption capabilities changed")
-SENSE_CODE(0x2A10, "Timestamp changed")
-SENSE_CODE(0x2A11, "Data encryption parameters changed by another i_t nexus")
-SENSE_CODE(0x2A12, "Data encryption parameters changed by vendor specific event")
-SENSE_CODE(0x2A13, "Data encryption key instance counter has changed")
-SENSE_CODE(0x2A14, "SA creation capabilities data has changed")
-SENSE_CODE(0x2A15, "Medium removal prevention preempted")
-SENSE_CODE(0x2A16, "Zone reset write pointer recommended")
-
-SENSE_CODE(0x2B00, "Copy cannot execute since host cannot disconnect")
-
-SENSE_CODE(0x2C00, "Command sequence error")
-SENSE_CODE(0x2C01, "Too many windows specified")
-SENSE_CODE(0x2C02, "Invalid combination of windows specified")
-SENSE_CODE(0x2C03, "Current program area is not empty")
-SENSE_CODE(0x2C04, "Current program area is empty")
-SENSE_CODE(0x2C05, "Illegal power condition request")
-SENSE_CODE(0x2C06, "Persistent prevent conflict")
-SENSE_CODE(0x2C07, "Previous busy status")
-SENSE_CODE(0x2C08, "Previous task set full status")
-SENSE_CODE(0x2C09, "Previous reservation conflict status")
-SENSE_CODE(0x2C0A, "Partition or collection contains user objects")
-SENSE_CODE(0x2C0B, "Not reserved")
-SENSE_CODE(0x2C0C, "Orwrite generation does not match")
-SENSE_CODE(0x2C0D, "Reset write pointer not allowed")
-SENSE_CODE(0x2C0E, "Zone is offline")
-SENSE_CODE(0x2C0F, "Stream not open")
-SENSE_CODE(0x2C10, "Unwritten data in zone")
-SENSE_CODE(0x2C11, "Descriptor format sense data required")
-SENSE_CODE(0x2C12, "Zone is inactive")
-SENSE_CODE(0x2C13, "Well known logical unit access required")
-
-SENSE_CODE(0x2D00, "Overwrite error on update in place")
-
-SENSE_CODE(0x2E00, "Insufficient time for operation")
-SENSE_CODE(0x2E01, "Command timeout before processing")
-SENSE_CODE(0x2E02, "Command timeout during processing")
-SENSE_CODE(0x2E03, "Command timeout during processing due to error recovery")
-
-SENSE_CODE(0x2F00, "Commands cleared by another initiator")
-SENSE_CODE(0x2F01, "Commands cleared by power loss notification")
-SENSE_CODE(0x2F02, "Commands cleared by device server")
-SENSE_CODE(0x2F03, "Some commands cleared by queuing layer event")
-
-SENSE_CODE(0x3000, "Incompatible medium installed")
-SENSE_CODE(0x3001, "Cannot read medium - unknown format")
-SENSE_CODE(0x3002, "Cannot read medium - incompatible format")
-SENSE_CODE(0x3003, "Cleaning cartridge installed")
-SENSE_CODE(0x3004, "Cannot write medium - unknown format")
-SENSE_CODE(0x3005, "Cannot write medium - incompatible format")
-SENSE_CODE(0x3006, "Cannot format medium - incompatible medium")
-SENSE_CODE(0x3007, "Cleaning failure")
-SENSE_CODE(0x3008, "Cannot write - application code mismatch")
-SENSE_CODE(0x3009, "Current session not fixated for append")
-SENSE_CODE(0x300A, "Cleaning request rejected")
-SENSE_CODE(0x300C, "WORM medium - overwrite attempted")
-SENSE_CODE(0x300D, "WORM medium - integrity check")
-SENSE_CODE(0x3010, "Medium not formatted")
-SENSE_CODE(0x3011, "Incompatible volume type")
-SENSE_CODE(0x3012, "Incompatible volume qualifier")
-SENSE_CODE(0x3013, "Cleaning volume expired")
-
-SENSE_CODE(0x3100, "Medium format corrupted")
-SENSE_CODE(0x3101, "Format command failed")
-SENSE_CODE(0x3102, "Zoned formatting failed due to spare linking")
-SENSE_CODE(0x3103, "Sanitize command failed")
-SENSE_CODE(0x3104, "Depopulation failed")
-SENSE_CODE(0x3105, "Depopulation restoration failed")
-
-SENSE_CODE(0x3200, "No defect spare location available")
-SENSE_CODE(0x3201, "Defect list update failure")
-
-SENSE_CODE(0x3300, "Tape length error")
-
-SENSE_CODE(0x3400, "Enclosure failure")
-
-SENSE_CODE(0x3500, "Enclosure services failure")
-SENSE_CODE(0x3501, "Unsupported enclosure function")
-SENSE_CODE(0x3502, "Enclosure services unavailable")
-SENSE_CODE(0x3503, "Enclosure services transfer failure")
-SENSE_CODE(0x3504, "Enclosure services transfer refused")
-SENSE_CODE(0x3505, "Enclosure services checksum error")
-
-SENSE_CODE(0x3600, "Ribbon, ink, or toner failure")
-
-SENSE_CODE(0x3700, "Rounded parameter")
-
-SENSE_CODE(0x3800, "Event status notification")
-SENSE_CODE(0x3802, "Esn - power management class event")
-SENSE_CODE(0x3804, "Esn - media class event")
-SENSE_CODE(0x3806, "Esn - device busy class event")
-SENSE_CODE(0x3807, "Thin Provisioning soft threshold reached")
-SENSE_CODE(0x3808, "Depopulation interrupted")
-
-SENSE_CODE(0x3900, "Saving parameters not supported")
-
-SENSE_CODE(0x3A00, "Medium not present")
-SENSE_CODE(0x3A01, "Medium not present - tray closed")
-SENSE_CODE(0x3A02, "Medium not present - tray open")
-SENSE_CODE(0x3A03, "Medium not present - loadable")
-SENSE_CODE(0x3A04, "Medium not present - medium auxiliary memory accessible")
-
-SENSE_CODE(0x3B00, "Sequential positioning error")
-SENSE_CODE(0x3B01, "Tape position error at beginning-of-medium")
-SENSE_CODE(0x3B02, "Tape position error at end-of-medium")
-SENSE_CODE(0x3B03, "Tape or electronic vertical forms unit not ready")
-SENSE_CODE(0x3B04, "Slew failure")
-SENSE_CODE(0x3B05, "Paper jam")
-SENSE_CODE(0x3B06, "Failed to sense top-of-form")
-SENSE_CODE(0x3B07, "Failed to sense bottom-of-form")
-SENSE_CODE(0x3B08, "Reposition error")
-SENSE_CODE(0x3B09, "Read past end of medium")
-SENSE_CODE(0x3B0A, "Read past beginning of medium")
-SENSE_CODE(0x3B0B, "Position past end of medium")
-SENSE_CODE(0x3B0C, "Position past beginning of medium")
-SENSE_CODE(0x3B0D, "Medium destination element full")
-SENSE_CODE(0x3B0E, "Medium source element empty")
-SENSE_CODE(0x3B0F, "End of medium reached")
-SENSE_CODE(0x3B11, "Medium magazine not accessible")
-SENSE_CODE(0x3B12, "Medium magazine removed")
-SENSE_CODE(0x3B13, "Medium magazine inserted")
-SENSE_CODE(0x3B14, "Medium magazine locked")
-SENSE_CODE(0x3B15, "Medium magazine unlocked")
-SENSE_CODE(0x3B16, "Mechanical positioning or changer error")
-SENSE_CODE(0x3B17, "Read past end of user object")
-SENSE_CODE(0x3B18, "Element disabled")
-SENSE_CODE(0x3B19, "Element enabled")
-SENSE_CODE(0x3B1A, "Data transfer device removed")
-SENSE_CODE(0x3B1B, "Data transfer device inserted")
-SENSE_CODE(0x3B1C, "Too many logical objects on partition to support operation")
-SENSE_CODE(0x3B20, "Element static information changed")
-
-SENSE_CODE(0x3D00, "Invalid bits in identify message")
-
-SENSE_CODE(0x3E00, "Logical unit has not self-configured yet")
-SENSE_CODE(0x3E01, "Logical unit failure")
-SENSE_CODE(0x3E02, "Timeout on logical unit")
-SENSE_CODE(0x3E03, "Logical unit failed self-test")
-SENSE_CODE(0x3E04, "Logical unit unable to update self-test log")
-
-SENSE_CODE(0x3F00, "Target operating conditions have changed")
-SENSE_CODE(0x3F01, "Microcode has been changed")
-SENSE_CODE(0x3F02, "Changed operating definition")
-SENSE_CODE(0x3F03, "Inquiry data has changed")
-SENSE_CODE(0x3F04, "Component device attached")
-SENSE_CODE(0x3F05, "Device identifier changed")
-SENSE_CODE(0x3F06, "Redundancy group created or modified")
-SENSE_CODE(0x3F07, "Redundancy group deleted")
-SENSE_CODE(0x3F08, "Spare created or modified")
-SENSE_CODE(0x3F09, "Spare deleted")
-SENSE_CODE(0x3F0A, "Volume set created or modified")
-SENSE_CODE(0x3F0B, "Volume set deleted")
-SENSE_CODE(0x3F0C, "Volume set deassigned")
-SENSE_CODE(0x3F0D, "Volume set reassigned")
-SENSE_CODE(0x3F0E, "Reported luns data has changed")
-SENSE_CODE(0x3F0F, "Echo buffer overwritten")
-SENSE_CODE(0x3F10, "Medium loadable")
-SENSE_CODE(0x3F11, "Medium auxiliary memory accessible")
-SENSE_CODE(0x3F12, "iSCSI IP address added")
-SENSE_CODE(0x3F13, "iSCSI IP address removed")
-SENSE_CODE(0x3F14, "iSCSI IP address changed")
-SENSE_CODE(0x3F15, "Inspect referrals sense descriptors")
-SENSE_CODE(0x3F16, "Microcode has been changed without reset")
-SENSE_CODE(0x3F17, "Zone transition to full")
-SENSE_CODE(0x3F18, "Bind completed")
-SENSE_CODE(0x3F19, "Bind redirected")
-SENSE_CODE(0x3F1A, "Subsidiary binding changed")
+SENSE_CODE(NO_ADDITIONAL_SENSE_INFORMATION,
+ "No additional sense information")
+SENSE_CODE(FILEMARK_DETECTED,
+ "Filemark detected")
+SENSE_CODE(END_OF_PARTITION_MEDIUM_DETECTED,
+ "End-of-partition/medium detected")
+SENSE_CODE(SETMARK_DETECTED,
+ "Setmark detected")
+SENSE_CODE(BEGINNING_OF_PARTITION_MEDIUM_DETECTED,
+ "Beginning-of-partition/medium detected")
+SENSE_CODE(END_OF_DATA_DETECTED,
+ "End-of-data detected")
+SENSE_CODE(IO_PROCESS_TERMINATED,
+ "I/O process terminated")
+SENSE_CODE(PROGRAMMABLE_EARLY_WARNING_DETECTED,
+ "Programmable early warning detected")
+SENSE_CODE(AUDIO_PLAY_OP_IN_PROGRESS,
+ "Audio play operation in progress")
+SENSE_CODE(AUDIO_PLAY_OP_PAUSED,
+ "Audio play operation paused")
+SENSE_CODE(AUDIO_PLAY_OP_SUCCESSFULLY_COMPLETED,
+ "Audio play operation successfully completed")
+SENSE_CODE(AUDIO_PLAY_OP_STOPPED_DUE_TO_ERROR,
+ "Audio play operation stopped due to error")
+SENSE_CODE(NO_CURRENT_AUDIO_STATUS_TO_RETURN,
+ "No current audio status to return")
+SENSE_CODE(OP_IN_PROGRESS,
+ "Operation in progress")
+SENSE_CODE(CLEANING_REQUESTED,
+ "Cleaning requested")
+SENSE_CODE(ERASE_OP_IN_PROGRESS,
+ "Erase operation in progress")
+SENSE_CODE(LOCATE_OP_IN_PROGRESS,
+ "Locate operation in progress")
+SENSE_CODE(REWIND_OP_IN_PROGRESS,
+ "Rewind operation in progress")
+SENSE_CODE(SET_CAPACITY_OP_IN_PROGRESS,
+ "Set capacity operation in progress")
+SENSE_CODE(VERIFY_OP_IN_PROGRESS,
+ "Verify operation in progress")
+SENSE_CODE(ATA_PASS_THROUGH_INFORMATION_AVAILABLE,
+ "ATA pass through information available")
+SENSE_CODE(CONFLICTING_SA_CREATION_REQUEST,
+ "Conflicting SA creation request")
+SENSE_CODE(LU_TRANSITIONING_TO_ANOTHER_POWER_CONDITION,
+ "Logical unit transitioning to another power condition")
+SENSE_CODE(EXTENDED_COPY_INFORMATION_AVAILABLE,
+ "Extended copy information available")
+SENSE_CODE(ATOMIC_COMMAND_ABORTED_DUE_TO_ACA,
+ "Atomic command aborted due to ACA")
+SENSE_CODE(DEFERRED_MICROCODE_IS_PENDING,
+ "Deferred microcode is pending")
+SENSE_CODE(OVERLAPPING_ATOMIC_COMMAND_IN_PROGRESS,
+ "Overlapping atomic command in progress")
+
+SENSE_CODE(NO_INDEX_SECTOR_SIGNAL,
+ "No index/sector signal")
+
+SENSE_CODE(NO_SEEK_COMPLETE,
+ "No seek complete")
+
+SENSE_CODE(PERIPHERAL_DEVICE_WRITE_FAULT,
+ "Peripheral device write fault")
+SENSE_CODE(NO_WRITE_CURRENT,
+ "No write current")
+SENSE_CODE(EXCESSIVE_WRITE_ERRORS,
+ "Excessive write errors")
+
+SENSE_CODE(LU_NOT_READY,
+ "Logical unit not ready, cause not reportable")
+SENSE_CODE(LU_IS_IN_PROCESS_OF_BECOMING_READY,
+ "Logical unit is in process of becoming ready")
+SENSE_CODE(LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED,
+ "Logical unit not ready, initializing command required")
+SENSE_CODE(LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED,
+ "Logical unit not ready, manual intervention required")
+SENSE_CODE(LU_NOT_READY_FORMAT_IN_PROGRESS,
+ "Logical unit not ready, format in progress")
+SENSE_CODE(LU_NOT_READY_REBUILD_IN_PROGRESS,
+ "Logical unit not ready, rebuild in progress")
+SENSE_CODE(LU_NOT_READY_RECALCULATION_IN_PROGRESS,
+ "Logical unit not ready, recalculation in progress")
+SENSE_CODE(LU_NOT_READY_OP_IN_PROGRESS,
+ "Logical unit not ready, operation in progress")
+SENSE_CODE(LU_NOT_READY_LONG_WRITE_IN_PROGRESS,
+ "Logical unit not ready, long write in progress")
+SENSE_CODE(LU_NOT_READY_SELFTEST_IN_PROGRESS,
+ "Logical unit not ready, self-test in progress")
+SENSE_CODE(LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION,
+ "Logical unit not accessible, asymmetric access state transition")
+SENSE_CODE(LU_NOT_ACCESSIBLE_TARGET_PORT_IN_STANDBY_STATE,
+ "Logical unit not accessible, target port in standby state")
+SENSE_CODE(LU_NOT_ACCESSIBLE_TARGET_PORT_IN_UNAVAILABLE_STATE,
+ "Logical unit not accessible, target port in unavailable state")
+SENSE_CODE(LU_NOT_READY_STRUCTURE_CHECK_REQUIRED,
+ "Logical unit not ready, structure check required")
+SENSE_CODE(LU_NOT_READY_SECURITY_SESSION_IN_PROGRESS,
+ "Logical unit not ready, security session in progress")
+SENSE_CODE(LU_NOT_READY_AUXILIARY_MEMORY_NOT_ACCESSIBLE,
+ "Logical unit not ready, auxiliary memory not accessible")
+SENSE_CODE(LU_NOT_READY_NOTIFY_REQUIRED,
+ "Logical unit not ready, notify (enable spinup) required")
+SENSE_CODE(LU_NOT_READY_OFFLINE,
+ "Logical unit not ready, offline")
+SENSE_CODE(LU_NOT_READY_SA_CREATION_IN_PROGRESS,
+ "Logical unit not ready, SA creation in progress")
+SENSE_CODE(LU_NOT_READY_SPACE_ALLOCATION_IN_PROGRESS,
+ "Logical unit not ready, space allocation in progress")
+SENSE_CODE(LU_NOT_READY_ROBOTICS_DISABLED,
+ "Logical unit not ready, robotics disabled")
+SENSE_CODE(LU_NOT_READY_CONFIG_REQUIRED,
+ "Logical unit not ready, configuration required")
+SENSE_CODE(LU_NOT_READY_CALIBRATION_REQUIRED,
+ "Logical unit not ready, calibration required")
+SENSE_CODE(LU_NOT_READY_A_DOOR_IS_OPEN,
+ "Logical unit not ready, a door is open")
+SENSE_CODE(LU_NOT_READY_OPERATING_IN_SEQUENTIAL_MODE,
+ "Logical unit not ready, operating in sequential mode")
+SENSE_CODE(LU_NOT_READY_START_STOP_UNIT_COMMAND_IN_PROGRESS,
+ "Logical unit not ready, start stop unit command in progress")
+SENSE_CODE(LU_NOT_READY_SANITIZE_IN_PROGRESS,
+ "Logical unit not ready, sanitize in progress")
+SENSE_CODE(LU_NOT_READY_ADDITIONAL_POWER_USE_NOT_YET_GRANTED,
+ "Logical unit not ready, additional power use not yet granted")
+SENSE_CODE(LU_NOT_READY_CONFIG_IN_PROGRESS,
+ "Logical unit not ready, configuration in progress")
+SENSE_CODE(LU_NOT_READY_MICROCODE_ACTIVATION_REQUIRED,
+ "Logical unit not ready, microcode activation required")
+SENSE_CODE(LU_NOT_READY_MICROCODE_DOWNLOAD_REQUIRED,
+ "Logical unit not ready, microcode download required")
+SENSE_CODE(LU_NOT_READY_LU_RESET_REQUIRED,
+ "Logical unit not ready, logical unit reset required")
+SENSE_CODE(LU_NOT_READY_HARD_RESET_REQUIRED,
+ "Logical unit not ready, hard reset required")
+SENSE_CODE(LU_NOT_READY_POWER_CYCLE_REQUIRED,
+ "Logical unit not ready, power cycle required")
+SENSE_CODE(LU_NOT_READY_AFFILIATION_REQUIRED,
+ "Logical unit not ready, affiliation required")
+SENSE_CODE(DEPOPULATION_IN_PROGRESS,
+ "Depopulation in progress")
+SENSE_CODE(DEPOPULATION_RESTORATION_IN_PROGRESS,
+ "Depopulation restoration in progress")
+
+SENSE_CODE(LU_DOES_NOT_RESPOND_TO_SELECTION,
+ "Logical unit does not respond to selection")
+
+SENSE_CODE(NO_REFERENCE_POSITION_FOUND,
+ "No reference position found")
+
+SENSE_CODE(MULTIPLE_PERIPHERAL_DEVICES_SELECTED,
+ "Multiple peripheral devices selected")
+
+SENSE_CODE(LU_COMMUNICATION_FAILURE,
+ "Logical unit communication failure")
+SENSE_CODE(LU_COMMUNICATION_TIMEOUT,
+ "Logical unit communication time-out")
+SENSE_CODE(LU_COMMUNICATION_PARITY_ERROR,
+ "Logical unit communication parity error")
+SENSE_CODE(LU_COMMUNICATION_CRC_ERROR,
+ "Logical unit communication CRC error (Ultra-DMA/32)")
+SENSE_CODE(UNREACHABLE_COPY_TARGET,
+ "Unreachable copy target")
+
+SENSE_CODE(TRACK_FOLLOWING_ERROR,
+ "Track following error")
+SENSE_CODE(TRACKING_SERVO_FAILURE,
+ "Tracking servo failure")
+SENSE_CODE(FOCUS_SERVO_FAILURE,
+ "Focus servo failure")
+SENSE_CODE(SPINDLE_SERVO_FAILURE,
+ "Spindle servo failure")
+SENSE_CODE(HEAD_SELECT_FAULT,
+ "Head select fault")
+SENSE_CODE(VIBRATION_INDUCED_TRACKING_ERROR,
+ "Vibration induced tracking error")
+
+SENSE_CODE(ERROR_LOG_OVERFLOW,
+ "Error log overflow")
+
+SENSE_CODE(WARNING,
+ "Warning")
+SENSE_CODE(WARNING_SPECIFIED_TEMPERATURE_EXCEEDED,
+ "Warning - specified temperature exceeded")
+SENSE_CODE(WARNING_ENCLOSURE_DEGRADED,
+ "Warning - enclosure degraded")
+SENSE_CODE(WARNING_BACKGROUND_SELFTEST_FAILED,
+ "Warning - background self-test failed")
+SENSE_CODE(WARNING_BACKGROUND_PRESCAN_DETECTED_MEDIUM_ERROR,
+ "Warning - background pre-scan detected medium error")
+SENSE_CODE(WARNING_BACKGROUND_MEDIUM_SCAN_DETECTED_MEDIUM_ERROR,
+ "Warning - background medium scan detected medium error")
+SENSE_CODE(WARNING_NONVOLATILE_CACHE_NOW_VOLATILE,
+ "Warning - non-volatile cache now volatile")
+SENSE_CODE(WARNING_DEGRADED_POWER_TO_NONVOLATILE_CACHE,
+ "Warning - degraded power to non-volatile cache")
+SENSE_CODE(WARNING_POWER_LOSS_EXPECTED,
+ "Warning - power loss expected")
+SENSE_CODE(WARNING_DEVICE_STATISTICS_NOTIFICATION_ACTIVE,
+ "Warning - device statistics notification active")
+SENSE_CODE(WARNING_HIGH_CRITICAL_TEMPERATURE_LIMIT_EXCEEDED,
+ "Warning - high critical temperature limit exceeded")
+SENSE_CODE(WARNING_LOW_CRITICAL_TEMPERATURE_LIMIT_EXCEEDED,
+ "Warning - low critical temperature limit exceeded")
+SENSE_CODE(WARNING_HIGH_OPERATING_TEMPERATURE_LIMIT_EXCEEDED,
+ "Warning - high operating temperature limit exceeded")
+SENSE_CODE(WARNING_LOW_OPERATING_TEMPERATURE_LIMIT_EXCEEDED,
+ "Warning - low operating temperature limit exceeded")
+SENSE_CODE(WARNING_HIGH_CRITICAL_HUMIDITY_LIMIT_EXCEEDED,
+ "Warning - high critical humidity limit exceeded")
+SENSE_CODE(WARNING_LOW_CRITICAL_HUMIDITY_LIMIT_EXCEEDED,
+ "Warning - low critical humidity limit exceeded")
+SENSE_CODE(WARNING_HIGH_OPERATING_HUMIDITY_LIMIT_EXCEEDED,
+ "Warning - high operating humidity limit exceeded")
+SENSE_CODE(WARNING_LOW_OPERATING_HUMIDITY_LIMIT_EXCEEDED,
+ "Warning - low operating humidity limit exceeded")
+SENSE_CODE(WARNING_MICROCODE_SECURITY_AT_RISK,
+ "Warning - microcode security at risk")
+SENSE_CODE(WARNING_MICROCODE_DIGITAL_SIGNATURE_VALIDATION_FAILURE,
+ "Warning - microcode digital signature validation failure")
+SENSE_CODE(WARNING_PHYSICAL_ELEMENT_STATUS_CHANGE,
+ "Warning - physical element status change")
+
+SENSE_CODE(WRITE_ERROR,
+ "Write error")
+SENSE_CODE(WRITE_ERROR_RECOVERED_WITH_AUTO_REALLOCATION,
+ "Write error - recovered with auto reallocation")
+SENSE_CODE(WRITE_ERROR_AUTO_REALLOCATION_FAILED,
+ "Write error - auto reallocation failed")
+SENSE_CODE(WRITE_ERROR_RECOMMEND_REASSIGNMENT,
+ "Write error - recommend reassignment")
+SENSE_CODE(COMPRESSION_CHECK_MISCOMPARE_ERROR,
+ "Compression check miscompare error")
+SENSE_CODE(DATA_EXPANSION_OCCURRED_DURING_COMPRESSION,
+ "Data expansion occurred during compression")
+SENSE_CODE(BLOCK_NOT_COMPRESSIBLE,
+ "Block not compressible")
+SENSE_CODE(WRITE_ERROR_RECOVERY_NEEDED,
+ "Write error - recovery needed")
+SENSE_CODE(WRITE_ERROR_RECOVERY_FAILED,
+ "Write error - recovery failed")
+SENSE_CODE(WRITE_ERROR_LOSS_OF_STREAMING,
+ "Write error - loss of streaming")
+SENSE_CODE(WRITE_ERROR_PADDING_BLOCKS_ADDED,
+ "Write error - padding blocks added")
+SENSE_CODE(AUXILIARY_MEMORY_WRITE_ERROR,
+ "Auxiliary memory write error")
+SENSE_CODE(WRITE_ERROR_UNEXPECTED_UNSOLICITED_DATA,
+ "Write error - unexpected unsolicited data")
+SENSE_CODE(WRITE_ERROR_NOT_ENOUGH_UNSOLICITED_DATA,
+ "Write error - not enough unsolicited data")
+SENSE_CODE(MULTIPLE_WRITE_ERRORS,
+ "Multiple write errors")
+SENSE_CODE(DEFECTS_IN_ERROR_WINDOW,
+ "Defects in error window")
+SENSE_CODE(INCOMPLETE_MULTIPLE_ATOMIC_WRITE_OPERATIONS,
+ "Incomplete multiple atomic write operations")
+SENSE_CODE(WRITE_ERROR_RECOVERY_SCAN_NEEDED,
+ "Write error - recovery scan needed")
+SENSE_CODE(WRITE_ERROR_INSUFFICIENT_ZONE_RESOURCES,
+ "Write error - insufficient zone resources")
+
+SENSE_CODE(ERROR_DETECTED_BY_THIRD_PARTY_TEMPORARY_INITIATOR,
+ "Error detected by third party temporary initiator")
+SENSE_CODE(THIRD_PARTY_DEVICE_FAILURE,
+ "Third party device failure")
+SENSE_CODE(COPY_TARGET_DEVICE_NOT_REACHABLE,
+ "Copy target device not reachable")
+SENSE_CODE(INCORRECT_COPY_TARGET_DEVICE_TYPE,
+ "Incorrect copy target device type")
+SENSE_CODE(COPY_TARGET_DEVICE_DATA_UNDERRUN,
+ "Copy target device data underrun")
+SENSE_CODE(COPY_TARGET_DEVICE_DATA_OVERRUN,
+ "Copy target device data overrun")
+
+SENSE_CODE(INVALID_INFORMATION_UNIT,
+ "Invalid information unit")
+SENSE_CODE(INFORMATION_UNIT_TOO_SHORT,
+ "Information unit too short")
+SENSE_CODE(INFORMATION_UNIT_TOO_LONG,
+ "Information unit too long")
+SENSE_CODE(INVALID_FIELD_IN_COMMAND_INFORMATION_UNIT,
+ "Invalid field in command information unit")
+
+SENSE_CODE(ID_CRC_OR_ECC_ERROR,
+ "Id CRC or ECC error")
+SENSE_CODE(LOGICAL_BLOCK_GUARD_CHECK_FAILED,
+ "Logical block guard check failed")
+SENSE_CODE(LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED,
+ "Logical block application tag check failed")
+SENSE_CODE(LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED,
+ "Logical block reference tag check failed")
+SENSE_CODE(LOGICAL_BLOCK_PROTECTION_ERROR_ON_RECOVER_BUFFERED_DATA,
+ "Logical block protection error on recover buffered data")
+SENSE_CODE(LOGICAL_BLOCK_PROTECTION_METHOD_ERROR,
+ "Logical block protection method error")
+
+SENSE_CODE(UNRECOVERED_READ_ERROR,
+ "Unrecovered read error")
+SENSE_CODE(READ_RETRIES_EXHAUSTED,
+ "Read retries exhausted")
+SENSE_CODE(ERROR_TOO_LONG_TO_CORRECT,
+ "Error too long to correct")
+SENSE_CODE(MULTIPLE_READ_ERRORS,
+ "Multiple read errors")
+SENSE_CODE(UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED,
+ "Unrecovered read error - auto reallocate failed")
+SENSE_CODE(LEC_UNCORRECTABLE_ERROR,
+ "L-EC uncorrectable error")
+SENSE_CODE(CIRC_UNRECOVERED_ERROR,
+ "CIRC unrecovered error")
+SENSE_CODE(DATA_RESYNCHRONIZATION_ERROR,
+ "Data re-synchronization error")
+SENSE_CODE(INCOMPLETE_BLOCK_READ,
+ "Incomplete block read")
+SENSE_CODE(NO_GAP_FOUND,
+ "No gap found")
+SENSE_CODE(MISCORRECTED_ERROR,
+ "Miscorrected error")
+SENSE_CODE(UNRECOVERED_READ_ERROR_RECOMMEND_REASSIGNMENT,
+ "Unrecovered read error - recommend reassignment")
+SENSE_CODE(UNRECOVERED_READ_ERROR_RECOMMEND_REWRITE_THE_DATA,
+ "Unrecovered read error - recommend rewrite the data")
+SENSE_CODE(DECOMPRESSION_CRC_ERROR,
+ "De-compression CRC error")
+SENSE_CODE(CANNOT_DECOMPRESS_USING_DECLARED_ALGORITHM,
+ "Cannot decompress using declared algorithm")
+SENSE_CODE(ERROR_READING_UPC_EAN_NUMBER,
+ "Error reading UPC/EAN number")
+SENSE_CODE(ERROR_READING_ISRC_NUMBER,
+ "Error reading ISRC number")
+SENSE_CODE(READ_ERROR_LOSS_OF_STREAMING,
+ "Read error - loss of streaming")
+SENSE_CODE(AUXILIARY_MEMORY_READ_ERROR,
+ "Auxiliary memory read error")
+SENSE_CODE(READ_ERROR_FAILED_RETRANSMISSION_REQUEST,
+ "Read error - failed retransmission request")
+SENSE_CODE(READ_ERROR_LBA_MARKED_BAD_BY_APPLICATION_CLIENT,
+ "Read error - lba marked bad by application client")
+SENSE_CODE(WRITE_AFTER_SANITIZE_REQUIRED,
+ "Write after sanitize required")
+
+SENSE_CODE(ADDRESS_MARK_NOT_FOUND_FOR_ID_FIELD,
+ "Address mark not found for id field")
+
+SENSE_CODE(ADDRESS_MARK_NOT_FOUND_FOR_DATA_FIELD,
+ "Address mark not found for data field")
+
+SENSE_CODE(RECORDED_ENTITY_NOT_FOUND,
+ "Recorded entity not found")
+SENSE_CODE(RECORD_NOT_FOUND,
+ "Record not found")
+SENSE_CODE(FILEMARK_OR_SETMARK_NOT_FOUND,
+ "Filemark or setmark not found")
+SENSE_CODE(END_OF_DATA_NOT_FOUND,
+ "End-of-data not found")
+SENSE_CODE(BLOCK_SEQUENCE_ERROR,
+ "Block sequence error")
+SENSE_CODE(RECORD_NOT_FOUND_RECOMMEND_REASSIGNMENT,
+ "Record not found - recommend reassignment")
+SENSE_CODE(RECORD_NOT_FOUND_DATA_AUTO_REALLOCATED,
+ "Record not found - data auto-reallocated")
+SENSE_CODE(LOCATE_OPERATION_FAILURE,
+ "Locate operation failure")
+
+SENSE_CODE(RANDOM_POSITIONING_ERROR,
+ "Random positioning error")
+SENSE_CODE(MECHANICAL_POSITIONING_ERROR,
+ "Mechanical positioning error")
+SENSE_CODE(POSITIONING_ERROR_DETECTED_BY_READ_OF_MEDIUM,
+ "Positioning error detected by read of medium")
+
+SENSE_CODE(DATA_SYNCHRONIZATION_MARK_ERROR,
+ "Data synchronization mark error")
+SENSE_CODE(DATA_SYNC_ERROR_DATA_REWRITTEN,
+ "Data sync error - data rewritten")
+SENSE_CODE(DATA_SYNC_ERROR_RECOMMEND_REWRITE,
+ "Data sync error - recommend rewrite")
+SENSE_CODE(DATA_SYNC_ERROR_DATA_AUTO_REALLOCATED,
+ "Data sync error - data auto-reallocated")
+SENSE_CODE(DATA_SYNC_ERROR_RECOMMEND_REASSIGNMENT,
+ "Data sync error - recommend reassignment")
+
+SENSE_CODE(RECOVERED_DATA_WITH_NO_ERROR_CORRECTION_APPLIED,
+ "Recovered data with no error correction applied")
+SENSE_CODE(RECOVERED_DATA_WITH_RETRIES,
+ "Recovered data with retries")
+SENSE_CODE(RECOVERED_DATA_WITH_POSITIVE_HEAD_OFFSET,
+ "Recovered data with positive head offset")
+SENSE_CODE(RECOVERED_DATA_WITH_NEGATIVE_HEAD_OFFSET,
+ "Recovered data with negative head offset")
+SENSE_CODE(RECOVERED_DATA_WITH_RETRIES_AND_OR_CIRC_APPLIED,
+ "Recovered data with retries and/or circ applied")
+SENSE_CODE(RECOVERED_DATA_USING_PREVIOUS_SECTOR_ID,
+ "Recovered data using previous sector id")
+SENSE_CODE(RECOVERED_DATA_WITHOUT_ECC_DATA_AUTO_REALLOCATED,
+ "Recovered data without ECC - data auto-reallocated")
+SENSE_CODE(RECOVERED_DATA_WITHOUT_ECC_RECOMMEND_REASSIGNMENT,
+ "Recovered data without ECC - recommend reassignment")
+SENSE_CODE(RECOVERED_DATA_WITHOUT_ECC_RECOMMEND_REWRITE,
+ "Recovered data without ECC - recommend rewrite")
+SENSE_CODE(RECOVERED_DATA_WITHOUT_ECC_DATA_REWRITTEN,
+ "Recovered data without ECC - data rewritten")
+
+SENSE_CODE(RECOVERED_DATA_WITH_ERROR_CORRECTION_APPLIED,
+ "Recovered data with error correction applied")
+SENSE_CODE(RECOVERED_DATA_WITH_ERROR_CORRECTION_RETRIES_APPLIED,
+ "Recovered data with error corr. & retries applied")
+SENSE_CODE(RECOVERED_DATA_DATA_AUTO_REALLOCATED,
+ "Recovered data - data auto-reallocated")
+SENSE_CODE(RECOVERED_DATA_WITH_CIRC,
+ "Recovered data with CIRC")
+SENSE_CODE(RECOVERED_DATA_WITH_LEC,
+ "Recovered data with L-EC")
+SENSE_CODE(RECOVERED_DATA_RECOMMEND_REASSIGNMENT,
+ "Recovered data - recommend reassignment")
+SENSE_CODE(RECOVERED_DATA_RECOMMEND_REWRITE,
+ "Recovered data - recommend rewrite")
+SENSE_CODE(RECOVERED_DATA_WITH_ECC_DATA_REWRITTEN,
+ "Recovered data with ECC - data rewritten")
+SENSE_CODE(RECOVERED_DATA_WITH_LINKING,
+ "Recovered data with linking")
+
+SENSE_CODE(DEFECT_LIST_ERROR,
+ "Defect list error")
+SENSE_CODE(DEFECT_LIST_NOT_AVAILABLE,
+ "Defect list not available")
+SENSE_CODE(DEFECT_LIST_ERROR_IN_PRIMARY_LIST,
+ "Defect list error in primary list")
+SENSE_CODE(DEFECT_LIST_ERROR_IN_GROWN_LIST,
+ "Defect list error in grown list")
+
+SENSE_CODE(PARAMETER_LIST_LENGTH_ERROR,
+ "Parameter list length error")
+
+SENSE_CODE(SYNCHRONOUS_DATA_TRANSFER_ERROR,
+ "Synchronous data transfer error")
+
+SENSE_CODE(DEFECT_LIST_NOT_FOUND,
+ "Defect list not found")
+SENSE_CODE(PRIMARY_DEFECT_LIST_NOT_FOUND,
+ "Primary defect list not found")
+SENSE_CODE(GROWN_DEFECT_LIST_NOT_FOUND,
+ "Grown defect list not found")
+
+SENSE_CODE(MISCOMPARE_DURING_VERIFY_OPERATION,
+ "Miscompare during verify operation")
+SENSE_CODE(MISCOMPARE_VERIFY_OF_UNMAPPED_LBA,
+ "Miscompare verify of unmapped LBA")
+
+SENSE_CODE(RECOVERED_ID_WITH_ECC_CORRECTION,
+ "Recovered id with ECC correction")
+
+SENSE_CODE(PARTIAL_DEFECT_LIST_TRANSFER,
+ "Partial defect list transfer")
+
+SENSE_CODE(INVALID_COMMAND_OP_CODE,
+ "Invalid command operation code")
+SENSE_CODE(ACCESS_DENIED_INITIATOR_PENDING_ENROLLED,
+ "Access denied - initiator pending-enrolled")
+SENSE_CODE(ACCESS_DENIED_NO_ACCESS_RIGHTS,
+ "Access denied - no access rights")
+SENSE_CODE(ACCESS_DENIED_INVALID_MGMT_ID_KEY,
+ "Access denied - invalid mgmt id key")
+SENSE_CODE(ILLEGAL_COMMAND_WHILE_IN_WRITE_CAPABLE_STATE,
+ "Illegal command while in write capable state")
+SENSE_CODE(0x2005,
+ "Obsolete")
+SENSE_CODE(ILLEGAL_COMMAND_WHILE_IN_EXPLICIT_ADDRESS_MODE,
+ "Illegal command while in explicit address mode")
+SENSE_CODE(ILLEGAL_COMMAND_WHILE_IN_IMPLICIT_ADDRESS_MODE,
+ "Illegal command while in implicit address mode")
+SENSE_CODE(ACCESS_DENIED_ENROLLMENT_CONFLICT,
+ "Access denied - enrollment conflict")
+SENSE_CODE(ACCESS_DENIED_INVALID_LU_IDENTIFIER,
+ "Access denied - invalid LU identifier")
+SENSE_CODE(ACCESS_DENIED_INVALID_PROXY_TOKEN,
+ "Access denied - invalid proxy token")
+SENSE_CODE(ACCESS_DENIED_ACL_LUN_CONFLICT,
+ "Access denied - ACL LUN conflict")
+SENSE_CODE(ILLEGAL_COMMAND_WHEN_NOT_IN_APPEND_ONLY_MODE,
+ "Illegal command when not in append-only mode")
+SENSE_CODE(NOT_AN_ADMINISTRATIVE_LOGICAL_UNIT,
+ "Not an administrative logical unit")
+SENSE_CODE(NOT_A_SUBSIDIARY_LOGICAL_UNIT,
+ "Not a subsidiary logical unit")
+SENSE_CODE(NOT_A_CONGLOMERATE_LOGICAL_UNIT,
+ "Not a conglomerate logical unit")
+
+SENSE_CODE(LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE,
+ "Logical block address out of range")
+SENSE_CODE(INVALID_ELEMENT_ADDRESS,
+ "Invalid element address")
+SENSE_CODE(INVALID_ADDRESS_FOR_WRITE,
+ "Invalid address for write")
+SENSE_CODE(INVALID_WRITE_CROSSING_LAYER_JUMP,
+ "Invalid write crossing layer jump")
+SENSE_CODE(UNALIGNED_WRITE_COMMAND,
+ "Unaligned write command")
+SENSE_CODE(WRITE_BOUNDARY_VIOLATION,
+ "Write boundary violation")
+SENSE_CODE(ATTEMPT_TO_READ_INVALID_DATA,
+ "Attempt to read invalid data")
+SENSE_CODE(READ_BOUNDARY_VIOLATION,
+ "Read boundary violation")
+SENSE_CODE(MISALIGNED_WRITE_COMMAND,
+ "Misaligned write command")
+SENSE_CODE(ATTEMPT_TO_ACCESS_GAP_ZONE,
+ "Attempt to access gap zone")
+
+SENSE_CODE(ILLEGAL_FUNCTION,
+ "Illegal function (use 20 00, 24 00, or 26 00)")
+
+SENSE_CODE(INVALID_TOKEN_OP,
+ "Invalid token operation, cause not reportable")
+SENSE_CODE(INVALID_TOKEN_OP_UNSUPPORTED_TOKEN_TYPE,
+ "Invalid token operation, unsupported token type")
+SENSE_CODE(INVALID_TOKEN_OP_REMOTE_TOKEN_USAGE_NOT_SUPPORTED,
+ "Invalid token operation, remote token usage not supported")
+SENSE_CODE(INVALID_TOKEN_OP_REMOTE_ROD_TOKEN_CREATION_NOT_SUPPORTED,
+ "Invalid token operation, remote rod token creation not supported")
+SENSE_CODE(INVALID_TOKEN_OP_TOKEN_UNKNOWN,
+ "Invalid token operation, token unknown")
+SENSE_CODE(INVALID_TOKEN_OP_TOKEN_CORRUPT,
+ "Invalid token operation, token corrupt")
+SENSE_CODE(INVALID_TOKEN_OP_TOKEN_REVOKED,
+ "Invalid token operation, token revoked")
+SENSE_CODE(INVALID_TOKEN_OP_TOKEN_EXPIRED,
+ "Invalid token operation, token expired")
+SENSE_CODE(INVALID_TOKEN_OP_TOKEN_CANCELLED,
+ "Invalid token operation, token cancelled")
+SENSE_CODE(INVALID_TOKEN_OP_TOKEN_DELETED,
+ "Invalid token operation, token deleted")
+SENSE_CODE(INVALID_TOKEN_OP_INVALID_TOKEN_LENGTH,
+ "Invalid token operation, invalid token length")
+
+SENSE_CODE(INVALID_FIELD_IN_CDB,
+ "Invalid field in cdb")
+SENSE_CODE(CDB_DECRYPTION_ERROR,
+ "CDB decryption error")
+SENSE_CODE(0x2402,
+ "Obsolete")
+SENSE_CODE(0x2403,
+ "Obsolete")
+SENSE_CODE(SECURITY_AUDIT_VALUE_FROZEN,
+ "Security audit value frozen")
+SENSE_CODE(SECURITY_WORKING_KEY_FROZEN,
+ "Security working key frozen")
+SENSE_CODE(NONCE_NOT_UNIQUE,
+ "Nonce not unique")
+SENSE_CODE(NONCE_TIMESTAMP_OUT_OF_RANGE,
+ "Nonce timestamp out of range")
+SENSE_CODE(INVALID_XCDB,
+ "Invalid XCDB")
+SENSE_CODE(INVALID_FAST_FORMAT,
+ "Invalid fast format")
+
+SENSE_CODE(LU_NOT_SUPPORTED,
+ "Logical unit not supported")
+
+SENSE_CODE(INVALID_FIELD_IN_PARAMETER_LIST,
+ "Invalid field in parameter list")
+SENSE_CODE(PARAMETER_NOT_SUPPORTED,
+ "Parameter not supported")
+SENSE_CODE(PARAMETER_VALUE_INVALID,
+ "Parameter value invalid")
+SENSE_CODE(THRESHOLD_PARAMETERS_NOT_SUPPORTED,
+ "Threshold parameters not supported")
+SENSE_CODE(INVALID_RELEASE_OF_PERSISTENT_RESERVATION,
+ "Invalid release of persistent reservation")
+SENSE_CODE(DATA_DECRYPTION_ERROR,
+ "Data decryption error")
+SENSE_CODE(TOO_MANY_TARGET_DESCRIPTORS,
+ "Too many target descriptors")
+SENSE_CODE(UNSUPPORTED_TARGET_DESCRIPTOR_TYPE_CODE,
+ "Unsupported target descriptor type code")
+SENSE_CODE(TOO_MANY_SEGMENT_DESCRIPTORS,
+ "Too many segment descriptors")
+SENSE_CODE(UNSUPPORTED_SEGMENT_DESCRIPTOR_TYPE_CODE,
+ "Unsupported segment descriptor type code")
+SENSE_CODE(UNEXPECTED_INEXACT_SEGMENT,
+ "Unexpected inexact segment")
+SENSE_CODE(INLINE_DATA_LENGTH_EXCEEDED,
+ "Inline data length exceeded")
+SENSE_CODE(INVALID_OP_FOR_COPY_SOURCE_OR_DESTINATION,
+ "Invalid operation for copy source or destination")
+SENSE_CODE(COPY_SEGMENT_GRANULARITY_VIOLATION,
+ "Copy segment granularity violation")
+SENSE_CODE(INVALID_PARAMETER_WHILE_PORT_IS_ENABLED,
+ "Invalid parameter while port is enabled")
+SENSE_CODE(INVALID_DATA_OUT_BUFFER_INTEGRITY_CHECK_VALUE,
+ "Invalid data-out buffer integrity check value")
+SENSE_CODE(DATA_DECRYPTION_KEY_FAIL_LIMIT_REACHED,
+ "Data decryption key fail limit reached")
+SENSE_CODE(INCOMPLETE_KEY_ASSOCIATED_DATA_SET,
+ "Incomplete key-associated data set")
+SENSE_CODE(VENDOR_SPECIFIC_KEY_REFERENCE_NOT_FOUND,
+ "Vendor specific key reference not found")
+SENSE_CODE(APPLICATION_TAG_MODE_PAGE_IS_INVALID,
+ "Application tag mode page is invalid")
+SENSE_CODE(TAPE_STREAM_MIRRORING_PREVENTED,
+ "Tape stream mirroring prevented")
+SENSE_CODE(COPY_SOURCE_OR_COPY_DESTINATION_NOT_AUTHORIZED,
+ "Copy source or copy destination not authorized")
+SENSE_CODE(FAST_COPY_NOT_POSSIBLE,
+ "Fast copy not possible")
+
+SENSE_CODE(WRITE_PROTECTED,
+ "Write protected")
+SENSE_CODE(HW_WRITE_PROTECTED,
+ "Hardware write protected")
+SENSE_CODE(LU_SOFTWARE_WRITE_PROTECTED,
+ "Logical unit software write protected")
+SENSE_CODE(ASSOCIATED_WRITE_PROTECT,
+ "Associated write protect")
+SENSE_CODE(PERSISTENT_WRITE_PROTECT,
+ "Persistent write protect")
+SENSE_CODE(PERMANENT_WRITE_PROTECT,
+ "Permanent write protect")
+SENSE_CODE(CONDITIONAL_WRITE_PROTECT,
+ "Conditional write protect")
+SENSE_CODE(SPACE_ALLOCATION_FAILED_WRITE_PROTECT,
+ "Space allocation failed write protect")
+SENSE_CODE(ZONE_IS_READ_ONLY,
+ "Zone is read only")
+
+SENSE_CODE(NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED,
+ "Not ready to ready change, medium may have changed")
+SENSE_CODE(IMPORT_OR_EXPORT_ELEMENT_ACCESSED,
+ "Import or export element accessed")
+SENSE_CODE(FORMAT_LAYER_MAY_HAVE_CHANGED,
+ "Format-layer may have changed")
+SENSE_CODE(IMPORT_EXPORT_ELEMENT_ACCESSED_MEDIUM_CHANGED,
+ "Import/export element accessed, medium changed")
+
+SENSE_CODE(POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
+ "Power on, reset, or bus device reset occurred")
+SENSE_CODE(POWER_ON_OCCURRED,
+ "Power on occurred")
+SENSE_CODE(SCSI_BUS_RESET_OCCURRED,
+ "Scsi bus reset occurred")
+SENSE_CODE(BUS_DEVICE_RESET_FUNCTION_OCCURRED,
+ "Bus device reset function occurred")
+SENSE_CODE(DEVICE_INTERNAL_RESET,
+ "Device internal reset")
+SENSE_CODE(TRANSCEIVER_MODE_CHANGED_TO_SINGLE_ENDED,
+ "Transceiver mode changed to single-ended")
+SENSE_CODE(TRANSCEIVER_MODE_CHANGED_TO_LVD,
+ "Transceiver mode changed to lvd")
+SENSE_CODE(I_T_NEXUS_LOSS_OCCURRED,
+ "I_T nexus loss occurred")
+
+SENSE_CODE(PARAMETERS_CHANGED,
+ "Parameters changed")
+SENSE_CODE(MODE_PARAMETERS_CHANGED,
+ "Mode parameters changed")
+SENSE_CODE(LOG_PARAMETERS_CHANGED,
+ "Log parameters changed")
+SENSE_CODE(RESERVATIONS_PREEMPTED,
+ "Reservations preempted")
+SENSE_CODE(RESERVATIONS_RELEASED,
+ "Reservations released")
+SENSE_CODE(REGISTRATIONS_PREEMPTED,
+ "Registrations preempted")
+SENSE_CODE(ASYMMETRIC_ACCESS_STATE_CHANGED,
+ "Asymmetric access state changed")
+SENSE_CODE(IMPLICIT_ASYMMETRIC_ACCESS_STATE_TRANSITION_FAILED,
+ "Implicit asymmetric access state transition failed")
+SENSE_CODE(PRIORITY_CHANGED,
+ "Priority changed")
+SENSE_CODE(CAPACITY_DATA_HAS_CHANGED,
+ "Capacity data has changed")
+SENSE_CODE(ERROR_HISTORY_I_T_NEXUS_CLEARED,
+ "Error history I_T nexus cleared")
+SENSE_CODE(ERROR_HISTORY_SNAPSHOT_RELEASED,
+ "Error history snapshot released")
+SENSE_CODE(ERROR_RECOVERY_ATTRIBUTES_HAVE_CHANGED,
+ "Error recovery attributes have changed")
+SENSE_CODE(DATA_ENCRYPTION_CAPABILITIES_CHANGED,
+ "Data encryption capabilities changed")
+SENSE_CODE(TIMESTAMP_CHANGED,
+ "Timestamp changed")
+SENSE_CODE(DATA_ENCRYPTION_PARAMS_CHANGED_BY_ANOTHER_I_T_NEXUS,
+ "Data encryption parameters changed by another i_t nexus")
+SENSE_CODE(DATA_ENCRYPTION_PARAMS_CHANGED_BY_VENDOR_SPECIFIC_EVENT,
+ "Data encryption parameters changed by vendor specific event")
+SENSE_CODE(DATA_ENCRYPTION_KEY_INSTANCE_COUNTER_HAS_CHANGED,
+ "Data encryption key instance counter has changed")
+SENSE_CODE(SA_CREATION_CAPABILITIES_DATA_HAS_CHANGED,
+ "SA creation capabilities data has changed")
+SENSE_CODE(MEDIUM_REMOVAL_PREVENTION_PREEMPTED,
+ "Medium removal prevention preempted")
+SENSE_CODE(ZONE_RESET_WRITE_POINTER_RECOMMENDED,
+ "Zone reset write pointer recommended")
+
+SENSE_CODE(COPY_CANNOT_EXECUTE_SINCE_HOST_CANNOT_DISCONNECT,
+ "Copy cannot execute since host cannot disconnect")
+
+SENSE_CODE(COMMAND_SEQUENCE_ERROR,
+ "Command sequence error")
+SENSE_CODE(TOO_MANY_WINDOWS_SPECIFIED,
+ "Too many windows specified")
+SENSE_CODE(INVALID_COMBINATION_OF_WINDOWS_SPECIFIED,
+ "Invalid combination of windows specified")
+SENSE_CODE(CURRENT_PROGRAM_AREA_IS_NOT_EMPTY,
+ "Current program area is not empty")
+SENSE_CODE(CURRENT_PROGRAM_AREA_IS_EMPTY,
+ "Current program area is empty")
+SENSE_CODE(ILLEGAL_POWER_CONDITION_REQUEST,
+ "Illegal power condition request")
+SENSE_CODE(PERSISTENT_PREVENT_CONFLICT,
+ "Persistent prevent conflict")
+SENSE_CODE(PREVIOUS_BUSY_STATUS,
+ "Previous busy status")
+SENSE_CODE(PREVIOUS_TASK_SET_FULL_STATUS,
+ "Previous task set full status")
+SENSE_CODE(PREVIOUS_RESERVATION_CONFLICT_STATUS,
+ "Previous reservation conflict status")
+SENSE_CODE(PARTITION_OR_COLLECTION_CONTAINS_USER_OBJECTS,
+ "Partition or collection contains user objects")
+SENSE_CODE(NOT_RESERVED,
+ "Not reserved")
+SENSE_CODE(ORWRITE_GENERATION_DOES_NOT_MATCH,
+ "Orwrite generation does not match")
+SENSE_CODE(RESET_WRITE_POINTER_NOT_ALLOWED,
+ "Reset write pointer not allowed")
+SENSE_CODE(ZONE_IS_OFFLINE,
+ "Zone is offline")
+SENSE_CODE(STREAM_NOT_OPEN,
+ "Stream not open")
+SENSE_CODE(UNWRITTEN_DATA_IN_ZONE,
+ "Unwritten data in zone")
+SENSE_CODE(DESCRIPTOR_FORMAT_SENSE_DATA_REQUIRED,
+ "Descriptor format sense data required")
+SENSE_CODE(ZONE_IS_INACTIVE,
+ "Zone is inactive")
+SENSE_CODE(WELL_KNOWN_LU_ACCESS_REQUIRED,
+ "Well known logical unit access required")
+
+SENSE_CODE(OVERWRITE_ERROR_ON_UPDATE_IN_PLACE,
+ "Overwrite error on update in place")
+
+SENSE_CODE(INSUFFICIENT_TIME_FOR_OPERATION,
+ "Insufficient time for operation")
+SENSE_CODE(COMMAND_TIMEOUT_BEFORE_PROCESSING,
+ "Command timeout before processing")
+SENSE_CODE(COMMAND_TIMEOUT_DURING_PROCESSING,
+ "Command timeout during processing")
+SENSE_CODE(COMMAND_TIMEOUT_DURING_PROCESSING_DUE_TO_ERROR_RECOVERY,
+ "Command timeout during processing due to error recovery")
+
+SENSE_CODE(COMMANDS_CLEARED_BY_ANOTHER_INITIATOR,
+ "Commands cleared by another initiator")
+SENSE_CODE(COMMANDS_CLEARED_BY_POWER_LOSS_NOTIFICATION,
+ "Commands cleared by power loss notification")
+SENSE_CODE(COMMANDS_CLEARED_BY_DEVICE_SERVER,
+ "Commands cleared by device server")
+SENSE_CODE(SOME_COMMANDS_CLEARED_BY_QUEUING_LAYER_EVENT,
+ "Some commands cleared by queuing layer event")
+
+SENSE_CODE(INCOMPATIBLE_MEDIUM_INSTALLED,
+ "Incompatible medium installed")
+SENSE_CODE(CANNOT_READ_MEDIUM_UNKNOWN_FORMAT,
+ "Cannot read medium - unknown format")
+SENSE_CODE(CANNOT_READ_MEDIUM_INCOMPATIBLE_FORMAT,
+ "Cannot read medium - incompatible format")
+SENSE_CODE(CLEANING_CARTRIDGE_INSTALLED,
+ "Cleaning cartridge installed")
+SENSE_CODE(CANNOT_WRITE_MEDIUM_UNKNOWN_FORMAT,
+ "Cannot write medium - unknown format")
+SENSE_CODE(CANNOT_WRITE_MEDIUM_INCOMPATIBLE_FORMAT,
+ "Cannot write medium - incompatible format")
+SENSE_CODE(CANNOT_FORMAT_MEDIUM_INCOMPATIBLE_MEDIUM,
+ "Cannot format medium - incompatible medium")
+SENSE_CODE(CLEANING_FAILURE,
+ "Cleaning failure")
+SENSE_CODE(CANNOT_WRITE_APPLICATION_CODE_MISMATCH,
+ "Cannot write - application code mismatch")
+SENSE_CODE(CURRENT_SESSION_NOT_FIXATED_FOR_APPEND,
+ "Current session not fixated for append")
+SENSE_CODE(CLEANING_REQUEST_REJECTED,
+ "Cleaning request rejected")
+SENSE_CODE(WORM_MEDIUM_OVERWRITE_ATTEMPTED,
+ "WORM medium - overwrite attempted")
+SENSE_CODE(WORM_MEDIUM_INTEGRITY_CHECK,
+ "WORM medium - integrity check")
+SENSE_CODE(MEDIUM_NOT_FORMATTED,
+ "Medium not formatted")
+SENSE_CODE(INCOMPATIBLE_VOLUME_TYPE,
+ "Incompatible volume type")
+SENSE_CODE(INCOMPATIBLE_VOLUME_QUALIFIER,
+ "Incompatible volume qualifier")
+SENSE_CODE(CLEANING_VOLUME_EXPIRED,
+ "Cleaning volume expired")
+
+SENSE_CODE(MEDIUM_FORMAT_CORRUPTED,
+ "Medium format corrupted")
+SENSE_CODE(FORMAT_COMMAND_FAILED,
+ "Format command failed")
+SENSE_CODE(ZONED_FORMATTING_FAILED_DUE_TO_SPARE_LINKING,
+ "Zoned formatting failed due to spare linking")
+SENSE_CODE(SANITIZE_COMMAND_FAILED,
+ "Sanitize command failed")
+SENSE_CODE(DEPOPULATION_FAILED,
+ "Depopulation failed")
+SENSE_CODE(DEPOPULATION_RESTORATION_FAILED,
+ "Depopulation restoration failed")
+
+SENSE_CODE(NO_DEFECT_SPARE_LOCATION_AVAILABLE,
+ "No defect spare location available")
+SENSE_CODE(DEFECT_LIST_UPDATE_FAILURE,
+ "Defect list update failure")
+
+SENSE_CODE(TAPE_LENGTH_ERROR,
+ "Tape length error")
+
+SENSE_CODE(ENCLOSURE_FAILURE,
+ "Enclosure failure")
+
+SENSE_CODE(ENCLOSURE_SERVICES_FAILURE,
+ "Enclosure services failure")
+SENSE_CODE(UNSUPPORTED_ENCLOSURE_FUNCTION,
+ "Unsupported enclosure function")
+SENSE_CODE(ENCLOSURE_SERVICES_UNAVAILABLE,
+ "Enclosure services unavailable")
+SENSE_CODE(ENCLOSURE_SERVICES_TRANSFER_FAILURE,
+ "Enclosure services transfer failure")
+SENSE_CODE(ENCLOSURE_SERVICES_TRANSFER_REFUSED,
+ "Enclosure services transfer refused")
+SENSE_CODE(ENCLOSURE_SERVICES_CHECKSUM_ERROR,
+ "Enclosure services checksum error")
+
+SENSE_CODE(RIBBON_INK_OR_TONER_FAILURE,
+ "Ribbon, ink, or toner failure")
+
+SENSE_CODE(ROUNDED_PARAMETER,
+ "Rounded parameter")
+
+SENSE_CODE(EVENT_STATUS_NOTIFICATION,
+ "Event status notification")
+SENSE_CODE(ESN_POWER_MANAGEMENT_CLASS_EVENT,
+ "Esn - power management class event")
+SENSE_CODE(ESN_MEDIA_CLASS_EVENT,
+ "Esn - media class event")
+SENSE_CODE(ESN_DEVICE_BUSY_CLASS_EVENT,
+ "Esn - device busy class event")
+SENSE_CODE(THIN_PROVISIONING_SOFT_THRESHOLD_REACHED,
+ "Thin Provisioning soft threshold reached")
+SENSE_CODE(DEPOPULATION_INTERRUPTED,
+ "Depopulation interrupted")
+SENSE_CODE(DEPOPULATION_RESTORATION_INTERRUPTED,
+ "Depopulation restoration interrupted")
+
+SENSE_CODE(SAVING_PARAMETERS_NOT_SUPPORTED,
+ "Saving parameters not supported")
+
+SENSE_CODE(MEDIUM_NOT_PRESENT,
+ "Medium not present")
+SENSE_CODE(MEDIUM_NOT_PRESENT_TRAY_CLOSED,
+ "Medium not present - tray closed")
+SENSE_CODE(MEDIUM_NOT_PRESENT_TRAY_OPEN,
+ "Medium not present - tray open")
+SENSE_CODE(MEDIUM_NOT_PRESENT_LOADABLE,
+ "Medium not present - loadable")
+SENSE_CODE(MEDIUM_NOT_PRESENT_MEDIUM_AUXILIARY_MEMORY_ACCESSIBLE,
+ "Medium not present - medium auxiliary memory accessible")
+
+SENSE_CODE(SEQUENTIAL_POSITIONING_ERROR,
+ "Sequential positioning error")
+SENSE_CODE(TAPE_POSITION_ERROR_AT_BEGINNING_OF_MEDIUM,
+ "Tape position error at beginning-of-medium")
+SENSE_CODE(TAPE_POSITION_ERROR_AT_END_OF_MEDIUM,
+ "Tape position error at end-of-medium")
+SENSE_CODE(TAPE_OR_ELECTRONIC_VERTICAL_FORMS_UNIT_NOT_READY,
+ "Tape or electronic vertical forms unit not ready")
+SENSE_CODE(SLEW_FAILURE,
+ "Slew failure")
+SENSE_CODE(PAPER_JAM,
+ "Paper jam")
+SENSE_CODE(FAILED_TO_SENSE_TOP_OF_FORM,
+ "Failed to sense top-of-form")
+SENSE_CODE(FAILED_TO_SENSE_BOTTOM_OF_FORM,
+ "Failed to sense bottom-of-form")
+SENSE_CODE(REPOSITION_ERROR,
+ "Reposition error")
+SENSE_CODE(READ_PAST_END_OF_MEDIUM,
+ "Read past end of medium")
+SENSE_CODE(READ_PAST_BEGINNING_OF_MEDIUM,
+ "Read past beginning of medium")
+SENSE_CODE(POSITION_PAST_END_OF_MEDIUM,
+ "Position past end of medium")
+SENSE_CODE(POSITION_PAST_BEGINNING_OF_MEDIUM,
+ "Position past beginning of medium")
+SENSE_CODE(MEDIUM_DESTINATION_ELEMENT_FULL,
+ "Medium destination element full")
+SENSE_CODE(MEDIUM_SOURCE_ELEMENT_EMPTY,
+ "Medium source element empty")
+SENSE_CODE(END_OF_MEDIUM_REACHED,
+ "End of medium reached")
+SENSE_CODE(MEDIUM_MAGAZINE_NOT_ACCESSIBLE,
+ "Medium magazine not accessible")
+SENSE_CODE(MEDIUM_MAGAZINE_REMOVED,
+ "Medium magazine removed")
+SENSE_CODE(MEDIUM_MAGAZINE_INSERTED,
+ "Medium magazine inserted")
+SENSE_CODE(MEDIUM_MAGAZINE_LOCKED,
+ "Medium magazine locked")
+SENSE_CODE(MEDIUM_MAGAZINE_UNLOCKED,
+ "Medium magazine unlocked")
+SENSE_CODE(MECHANICAL_POSITIONING_OR_CHANGER_ERROR,
+ "Mechanical positioning or changer error")
+SENSE_CODE(READ_PAST_END_OF_USER_OBJECT,
+ "Read past end of user object")
+SENSE_CODE(ELEMENT_DISABLED,
+ "Element disabled")
+SENSE_CODE(ELEMENT_ENABLED,
+ "Element enabled")
+SENSE_CODE(DATA_TRANSFER_DEVICE_REMOVED,
+ "Data transfer device removed")
+SENSE_CODE(DATA_TRANSFER_DEVICE_INSERTED,
+ "Data transfer device inserted")
+SENSE_CODE(TOO_MANY_LOGICAL_OBJECTS_ON_PARTITION_TO_SUPPORT_OP,
+ "Too many logical objects on partition to support operation")
+SENSE_CODE(ELEMENT_STATIC_INFORMATION_CHANGED,
+ "Element static information changed")
+
+SENSE_CODE(INVALID_BITS_IN_IDENTIFY_MESSAGE,
+ "Invalid bits in identify message")
+
+SENSE_CODE(LU_HAS_NOT_SELF_CONFIGURED_YET,
+ "Logical unit has not self-configured yet")
+SENSE_CODE(LU_FAILURE,
+ "Logical unit failure")
+SENSE_CODE(TIMEOUT_ON_LOGICAL_UNIT,
+ "Timeout on logical unit")
+SENSE_CODE(LU_FAILED_SELF_TEST,
+ "Logical unit failed self-test")
+SENSE_CODE(LU_UNABLE_TO_UPDATE_SELFTEST_LOG,
+ "Logical unit unable to update self-test log")
+
+SENSE_CODE(TARGET_OPERATING_CONDITIONS_HAVE_CHANGED,
+ "Target operating conditions have changed")
+SENSE_CODE(MICROCODE_HAS_BEEN_CHANGED,
+ "Microcode has been changed")
+SENSE_CODE(CHANGED_OPERATING_DEFINITION,
+ "Changed operating definition")
+SENSE_CODE(INQUIRY_DATA_HAS_CHANGED,
+ "Inquiry data has changed")
+SENSE_CODE(COMPONENT_DEVICE_ATTACHED,
+ "Component device attached")
+SENSE_CODE(DEVICE_IDENTIFIER_CHANGED,
+ "Device identifier changed")
+SENSE_CODE(REDUNDANCY_GROUP_CREATED_OR_MODIFIED,
+ "Redundancy group created or modified")
+SENSE_CODE(REDUNDANCY_GROUP_DELETED,
+ "Redundancy group deleted")
+SENSE_CODE(SPARE_CREATED_OR_MODIFIED,
+ "Spare created or modified")
+SENSE_CODE(SPARE_DELETED,
+ "Spare deleted")
+SENSE_CODE(VOLUME_SET_CREATED_OR_MODIFIED,
+ "Volume set created or modified")
+SENSE_CODE(VOLUME_SET_DELETED,
+ "Volume set deleted")
+SENSE_CODE(VOLUME_SET_DEASSIGNED,
+ "Volume set deassigned")
+SENSE_CODE(VOLUME_SET_REASSIGNED,
+ "Volume set reassigned")
+SENSE_CODE(REPORTED_LUNS_DATA_HAS_CHANGED,
+ "Reported luns data has changed")
+SENSE_CODE(ECHO_BUFFER_OVERWRITTEN,
+ "Echo buffer overwritten")
+SENSE_CODE(MEDIUM_LOADABLE,
+ "Medium loadable")
+SENSE_CODE(MEDIUM_AUXILIARY_MEMORY_ACCESSIBLE,
+ "Medium auxiliary memory accessible")
+SENSE_CODE(iSCSI_IP_ADDRESS_ADDED,
+ "iSCSI IP address added")
+SENSE_CODE(iSCSI_IP_ADDRESS_REMOVED,
+ "iSCSI IP address removed")
+SENSE_CODE(iSCSI_IP_ADDRESS_CHANGED,
+ "iSCSI IP address changed")
+SENSE_CODE(INSPECT_REFERRALS_SENSE_DESCRIPTORS,
+ "Inspect referrals sense descriptors")
+SENSE_CODE(MICROCODE_HAS_BEEN_CHANGED_WITHOUT_RESET,
+ "Microcode has been changed without reset")
+SENSE_CODE(ZONE_TRANSITION_TO_FULL,
+ "Zone transition to full")
+SENSE_CODE(BIND_COMPLETED,
+ "Bind completed")
+SENSE_CODE(BIND_REDIRECTED,
+ "Bind redirected")
+SENSE_CODE(SUBSIDIARY_BINDING_CHANGED,
+ "Subsidiary binding changed")
/*
- * SENSE_CODE(0x40NN, "Ram failure")
- * SENSE_CODE(0x40NN, "Diagnostic failure on component nn")
- * SENSE_CODE(0x41NN, "Data path failure")
- * SENSE_CODE(0x42NN, "Power-on or self-test failure")
+ * SENSE_CODE(0x40NN, "Ram failure")
+ * SENSE_CODE(0x40NN, "Diagnostic failure on component nn")
+ *
+ * SENSE_CODE(0x41NN, "Data path failure")
+ *
+ * SENSE_CODE(0x42NN, "Power-on or self-test failure")
*/
-SENSE_CODE(0x4300, "Message error")
-
-SENSE_CODE(0x4400, "Internal target failure")
-SENSE_CODE(0x4401, "Persistent reservation information lost")
-SENSE_CODE(0x4471, "ATA device failed set features")
-
-SENSE_CODE(0x4500, "Select or reselect failure")
-
-SENSE_CODE(0x4600, "Unsuccessful soft reset")
-
-SENSE_CODE(0x4700, "Scsi parity error")
-SENSE_CODE(0x4701, "Data phase CRC error detected")
-SENSE_CODE(0x4702, "Scsi parity error detected during st data phase")
-SENSE_CODE(0x4703, "Information unit iuCRC error detected")
-SENSE_CODE(0x4704, "Asynchronous information protection error detected")
-SENSE_CODE(0x4705, "Protocol service CRC error")
-SENSE_CODE(0x4706, "Phy test function in progress")
-SENSE_CODE(0x477f, "Some commands cleared by iSCSI Protocol event")
-
-SENSE_CODE(0x4800, "Initiator detected error message received")
-
-SENSE_CODE(0x4900, "Invalid message error")
-
-SENSE_CODE(0x4A00, "Command phase error")
-
-SENSE_CODE(0x4B00, "Data phase error")
-SENSE_CODE(0x4B01, "Invalid target port transfer tag received")
-SENSE_CODE(0x4B02, "Too much write data")
-SENSE_CODE(0x4B03, "Ack/nak timeout")
-SENSE_CODE(0x4B04, "Nak received")
-SENSE_CODE(0x4B05, "Data offset error")
-SENSE_CODE(0x4B06, "Initiator response timeout")
-SENSE_CODE(0x4B07, "Connection lost")
-SENSE_CODE(0x4B08, "Data-in buffer overflow - data buffer size")
-SENSE_CODE(0x4B09, "Data-in buffer overflow - data buffer descriptor area")
-SENSE_CODE(0x4B0A, "Data-in buffer error")
-SENSE_CODE(0x4B0B, "Data-out buffer overflow - data buffer size")
-SENSE_CODE(0x4B0C, "Data-out buffer overflow - data buffer descriptor area")
-SENSE_CODE(0x4B0D, "Data-out buffer error")
-SENSE_CODE(0x4B0E, "PCIe fabric error")
-SENSE_CODE(0x4B0F, "PCIe completion timeout")
-SENSE_CODE(0x4B10, "PCIe completer abort")
-SENSE_CODE(0x4B11, "PCIe poisoned tlp received")
-SENSE_CODE(0x4B12, "PCIe eCRC check failed")
-SENSE_CODE(0x4B13, "PCIe unsupported request")
-SENSE_CODE(0x4B14, "PCIe acs violation")
-SENSE_CODE(0x4B15, "PCIe tlp prefix blocked")
-
-SENSE_CODE(0x4C00, "Logical unit failed self-configuration")
+
+SENSE_CODE(MESSAGE_ERROR,
+ "Message error")
+
+SENSE_CODE(INTERNAL_TARGET_FAILURE,
+ "Internal target failure")
+SENSE_CODE(PERSISTENT_RESERVATION_INFORMATION_LOST,
+ "Persistent reservation information lost")
+SENSE_CODE(ATA_DEVICE_FAILED_SET_FEATURES,
+ "ATA device failed set features")
+
+SENSE_CODE(SELECT_OR_RESELECT_FAILURE,
+ "Select or reselect failure")
+
+SENSE_CODE(UNSUCCESSFUL_SOFT_RESET,
+ "Unsuccessful soft reset")
+
+SENSE_CODE(SCSI_PARITY_ERROR,
+ "Scsi parity error")
+SENSE_CODE(DATA_PHASE_CRC_ERROR_DETECTED,
+ "Data phase CRC error detected")
+SENSE_CODE(SCSI_PARITY_ERROR_DETECTED_DURING_ST_DATA_PHASE,
+ "Scsi parity error detected during st data phase")
+SENSE_CODE(INFORMATION_UNIT_iuCRC_ERROR_DETECTED,
+ "Information unit iuCRC error detected")
+SENSE_CODE(ASYNCHRONOUS_INFORMATION_PROTECTION_ERROR_DETECTED,
+ "Asynchronous information protection error detected")
+SENSE_CODE(PROTOCOL_SERVICE_CRC_ERROR,
+ "Protocol service CRC error")
+SENSE_CODE(PHY_TEST_FUNCTION_IN_PROGRESS,
+ "Phy test function in progress")
+SENSE_CODE(SOME_COMMANDS_CLEARED_BY_ISCSI_PROTOCOL_EVENT,
+ "Some commands cleared by iSCSI Protocol event")
+
+SENSE_CODE(INITIATOR_DETECTED_ERROR_MESSAGE_RECEIVED,
+ "Initiator detected error message received")
+
+SENSE_CODE(INVALID_MESSAGE_ERROR,
+ "Invalid message error")
+
+SENSE_CODE(COMMAND_PHASE_ERROR,
+ "Command phase error")
+
+SENSE_CODE(DATA_PHASE_ERROR,
+ "Data phase error")
+SENSE_CODE(INVALID_TARGET_PORT_TRANSFER_TAG_RECEIVED,
+ "Invalid target port transfer tag received")
+SENSE_CODE(TOO_MUCH_WRITE_DATA,
+ "Too much write data")
+SENSE_CODE(ACK_NAK_TIMEOUT,
+ "Ack/nak timeout")
+SENSE_CODE(NAK_RECEIVED,
+ "Nak received")
+SENSE_CODE(DATA_OFFSET_ERROR,
+ "Data offset error")
+SENSE_CODE(INITIATOR_RESPONSE_TIMEOUT,
+ "Initiator response timeout")
+SENSE_CODE(CONNECTION_LOST,
+ "Connection lost")
+SENSE_CODE(DATA_IN_BUFFER_OVERFLOW_BUFFER_SIZE,
+ "Data-in buffer overflow - data buffer size")
+SENSE_CODE(DATA_IN_BUFFER_OVERFLOW_BUFFER_DESCRIPTOR_AREA,
+ "Data-in buffer overflow - data buffer descriptor area")
+SENSE_CODE(DATA_IN_BUFFER_ERROR,
+ "Data-in buffer error")
+SENSE_CODE(DATA_OUT_BUFFER_OVERFLOW_BUFFER_SIZE,
+ "Data-out buffer overflow - data buffer size")
+SENSE_CODE(DATA_OUT_BUFFER_OVERFLOW_BUFFER_DESCRIPTOR_AREA,
+ "Data-out buffer overflow - data buffer descriptor area")
+SENSE_CODE(DATA_OUT_BUFFER_ERROR,
+ "Data-out buffer error")
+SENSE_CODE(PCIE_FABRIC_ERROR,
+ "PCIe fabric error")
+SENSE_CODE(PCIE_COMPLETION_TIMEOUT,
+ "PCIe completion timeout")
+SENSE_CODE(PCIE_COMPLETER_ABORT,
+ "PCIe completer abort")
+SENSE_CODE(PCIE_POISONED_TLP_RECEIVED,
+ "PCIe poisoned tlp received")
+SENSE_CODE(PCIE_ECRC_CHECK_FAILED,
+ "PCIe eCRC check failed")
+SENSE_CODE(PCIE_UNSUPPORTED_REQUEST,
+ "PCIe unsupported request")
+SENSE_CODE(PCIE_ACS_VIOLATION,
+ "PCIe acs violation")
+SENSE_CODE(PCIE_TLP_PREFIX_BLOCKED,
+ "PCIe tlp prefix blocked")
+
+SENSE_CODE(LU_FAILED_SELF_CONFIGURATION,
+ "Logical unit failed self-configuration")
+
/*
- * SENSE_CODE(0x4DNN, "Tagged overlapped commands (nn = queue tag)")
+ * SENSE_CODE(0x4DNN, "Tagged overlapped commands (nn = queue tag)")
*/
-SENSE_CODE(0x4E00, "Overlapped commands attempted")
-
-SENSE_CODE(0x5000, "Write append error")
-SENSE_CODE(0x5001, "Write append position error")
-SENSE_CODE(0x5002, "Position error related to timing")
-
-SENSE_CODE(0x5100, "Erase failure")
-SENSE_CODE(0x5101, "Erase failure - incomplete erase operation detected")
-
-SENSE_CODE(0x5200, "Cartridge fault")
-
-SENSE_CODE(0x5300, "Media load or eject failed")
-SENSE_CODE(0x5301, "Unload tape failure")
-SENSE_CODE(0x5302, "Medium removal prevented")
-SENSE_CODE(0x5303, "Medium removal prevented by data transfer element")
-SENSE_CODE(0x5304, "Medium thread or unthread failure")
-SENSE_CODE(0x5305, "Volume identifier invalid")
-SENSE_CODE(0x5306, "Volume identifier missing")
-SENSE_CODE(0x5307, "Duplicate volume identifier")
-SENSE_CODE(0x5308, "Element status unknown")
-SENSE_CODE(0x5309, "Data transfer device error - load failed")
-SENSE_CODE(0x530a, "Data transfer device error - unload failed")
-SENSE_CODE(0x530b, "Data transfer device error - unload missing")
-SENSE_CODE(0x530c, "Data transfer device error - eject failed")
-SENSE_CODE(0x530d, "Data transfer device error - library communication failed")
-
-SENSE_CODE(0x5400, "Scsi to host system interface failure")
-
-SENSE_CODE(0x5500, "System resource failure")
-SENSE_CODE(0x5501, "System buffer full")
-SENSE_CODE(0x5502, "Insufficient reservation resources")
-SENSE_CODE(0x5503, "Insufficient resources")
-SENSE_CODE(0x5504, "Insufficient registration resources")
-SENSE_CODE(0x5505, "Insufficient access control resources")
-SENSE_CODE(0x5506, "Auxiliary memory out of space")
-SENSE_CODE(0x5507, "Quota error")
-SENSE_CODE(0x5508, "Maximum number of supplemental decryption keys exceeded")
-SENSE_CODE(0x5509, "Medium auxiliary memory not accessible")
-SENSE_CODE(0x550A, "Data currently unavailable")
-SENSE_CODE(0x550B, "Insufficient power for operation")
-SENSE_CODE(0x550C, "Insufficient resources to create rod")
-SENSE_CODE(0x550D, "Insufficient resources to create rod token")
-SENSE_CODE(0x550E, "Insufficient zone resources")
-SENSE_CODE(0x550F, "Insufficient zone resources to complete write")
-SENSE_CODE(0x5510, "Maximum number of streams open")
-SENSE_CODE(0x5511, "Insufficient resources to bind")
-
-SENSE_CODE(0x5700, "Unable to recover table-of-contents")
-
-SENSE_CODE(0x5800, "Generation does not exist")
-
-SENSE_CODE(0x5900, "Updated block read")
-
-SENSE_CODE(0x5A00, "Operator request or state change input")
-SENSE_CODE(0x5A01, "Operator medium removal request")
-SENSE_CODE(0x5A02, "Operator selected write protect")
-SENSE_CODE(0x5A03, "Operator selected write permit")
-
-SENSE_CODE(0x5B00, "Log exception")
-SENSE_CODE(0x5B01, "Threshold condition met")
-SENSE_CODE(0x5B02, "Log counter at maximum")
-SENSE_CODE(0x5B03, "Log list codes exhausted")
-
-SENSE_CODE(0x5C00, "Rpl status change")
-SENSE_CODE(0x5C01, "Spindles synchronized")
-SENSE_CODE(0x5C02, "Spindles not synchronized")
-
-SENSE_CODE(0x5D00, "Failure prediction threshold exceeded")
-SENSE_CODE(0x5D01, "Media failure prediction threshold exceeded")
-SENSE_CODE(0x5D02, "Logical unit failure prediction threshold exceeded")
-SENSE_CODE(0x5D03, "Spare area exhaustion prediction threshold exceeded")
-SENSE_CODE(0x5D10, "Hardware impending failure general hard drive failure")
-SENSE_CODE(0x5D11, "Hardware impending failure drive error rate too high")
-SENSE_CODE(0x5D12, "Hardware impending failure data error rate too high")
-SENSE_CODE(0x5D13, "Hardware impending failure seek error rate too high")
-SENSE_CODE(0x5D14, "Hardware impending failure too many block reassigns")
-SENSE_CODE(0x5D15, "Hardware impending failure access times too high")
-SENSE_CODE(0x5D16, "Hardware impending failure start unit times too high")
-SENSE_CODE(0x5D17, "Hardware impending failure channel parametrics")
-SENSE_CODE(0x5D18, "Hardware impending failure controller detected")
-SENSE_CODE(0x5D19, "Hardware impending failure throughput performance")
-SENSE_CODE(0x5D1A, "Hardware impending failure seek time performance")
-SENSE_CODE(0x5D1B, "Hardware impending failure spin-up retry count")
-SENSE_CODE(0x5D1C, "Hardware impending failure drive calibration retry count")
-SENSE_CODE(0x5D20, "Controller impending failure general hard drive failure")
-SENSE_CODE(0x5D21, "Controller impending failure drive error rate too high")
-SENSE_CODE(0x5D22, "Controller impending failure data error rate too high")
-SENSE_CODE(0x5D23, "Controller impending failure seek error rate too high")
-SENSE_CODE(0x5D24, "Controller impending failure too many block reassigns")
-SENSE_CODE(0x5D25, "Controller impending failure access times too high")
-SENSE_CODE(0x5D26, "Controller impending failure start unit times too high")
-SENSE_CODE(0x5D27, "Controller impending failure channel parametrics")
-SENSE_CODE(0x5D28, "Controller impending failure controller detected")
-SENSE_CODE(0x5D29, "Controller impending failure throughput performance")
-SENSE_CODE(0x5D2A, "Controller impending failure seek time performance")
-SENSE_CODE(0x5D2B, "Controller impending failure spin-up retry count")
-SENSE_CODE(0x5D2C, "Controller impending failure drive calibration retry count")
-SENSE_CODE(0x5D30, "Data channel impending failure general hard drive failure")
-SENSE_CODE(0x5D31, "Data channel impending failure drive error rate too high")
-SENSE_CODE(0x5D32, "Data channel impending failure data error rate too high")
-SENSE_CODE(0x5D33, "Data channel impending failure seek error rate too high")
-SENSE_CODE(0x5D34, "Data channel impending failure too many block reassigns")
-SENSE_CODE(0x5D35, "Data channel impending failure access times too high")
-SENSE_CODE(0x5D36, "Data channel impending failure start unit times too high")
-SENSE_CODE(0x5D37, "Data channel impending failure channel parametrics")
-SENSE_CODE(0x5D38, "Data channel impending failure controller detected")
-SENSE_CODE(0x5D39, "Data channel impending failure throughput performance")
-SENSE_CODE(0x5D3A, "Data channel impending failure seek time performance")
-SENSE_CODE(0x5D3B, "Data channel impending failure spin-up retry count")
-SENSE_CODE(0x5D3C, "Data channel impending failure drive calibration retry count")
-SENSE_CODE(0x5D40, "Servo impending failure general hard drive failure")
-SENSE_CODE(0x5D41, "Servo impending failure drive error rate too high")
-SENSE_CODE(0x5D42, "Servo impending failure data error rate too high")
-SENSE_CODE(0x5D43, "Servo impending failure seek error rate too high")
-SENSE_CODE(0x5D44, "Servo impending failure too many block reassigns")
-SENSE_CODE(0x5D45, "Servo impending failure access times too high")
-SENSE_CODE(0x5D46, "Servo impending failure start unit times too high")
-SENSE_CODE(0x5D47, "Servo impending failure channel parametrics")
-SENSE_CODE(0x5D48, "Servo impending failure controller detected")
-SENSE_CODE(0x5D49, "Servo impending failure throughput performance")
-SENSE_CODE(0x5D4A, "Servo impending failure seek time performance")
-SENSE_CODE(0x5D4B, "Servo impending failure spin-up retry count")
-SENSE_CODE(0x5D4C, "Servo impending failure drive calibration retry count")
-SENSE_CODE(0x5D50, "Spindle impending failure general hard drive failure")
-SENSE_CODE(0x5D51, "Spindle impending failure drive error rate too high")
-SENSE_CODE(0x5D52, "Spindle impending failure data error rate too high")
-SENSE_CODE(0x5D53, "Spindle impending failure seek error rate too high")
-SENSE_CODE(0x5D54, "Spindle impending failure too many block reassigns")
-SENSE_CODE(0x5D55, "Spindle impending failure access times too high")
-SENSE_CODE(0x5D56, "Spindle impending failure start unit times too high")
-SENSE_CODE(0x5D57, "Spindle impending failure channel parametrics")
-SENSE_CODE(0x5D58, "Spindle impending failure controller detected")
-SENSE_CODE(0x5D59, "Spindle impending failure throughput performance")
-SENSE_CODE(0x5D5A, "Spindle impending failure seek time performance")
-SENSE_CODE(0x5D5B, "Spindle impending failure spin-up retry count")
-SENSE_CODE(0x5D5C, "Spindle impending failure drive calibration retry count")
-SENSE_CODE(0x5D60, "Firmware impending failure general hard drive failure")
-SENSE_CODE(0x5D61, "Firmware impending failure drive error rate too high")
-SENSE_CODE(0x5D62, "Firmware impending failure data error rate too high")
-SENSE_CODE(0x5D63, "Firmware impending failure seek error rate too high")
-SENSE_CODE(0x5D64, "Firmware impending failure too many block reassigns")
-SENSE_CODE(0x5D65, "Firmware impending failure access times too high")
-SENSE_CODE(0x5D66, "Firmware impending failure start unit times too high")
-SENSE_CODE(0x5D67, "Firmware impending failure channel parametrics")
-SENSE_CODE(0x5D68, "Firmware impending failure controller detected")
-SENSE_CODE(0x5D69, "Firmware impending failure throughput performance")
-SENSE_CODE(0x5D6A, "Firmware impending failure seek time performance")
-SENSE_CODE(0x5D6B, "Firmware impending failure spin-up retry count")
-SENSE_CODE(0x5D6C, "Firmware impending failure drive calibration retry count")
-SENSE_CODE(0x5D73, "Media impending failure endurance limit met")
-SENSE_CODE(0x5DFF, "Failure prediction threshold exceeded (false)")
-
-SENSE_CODE(0x5E00, "Low power condition on")
-SENSE_CODE(0x5E01, "Idle condition activated by timer")
-SENSE_CODE(0x5E02, "Standby condition activated by timer")
-SENSE_CODE(0x5E03, "Idle condition activated by command")
-SENSE_CODE(0x5E04, "Standby condition activated by command")
-SENSE_CODE(0x5E05, "Idle_b condition activated by timer")
-SENSE_CODE(0x5E06, "Idle_b condition activated by command")
-SENSE_CODE(0x5E07, "Idle_c condition activated by timer")
-SENSE_CODE(0x5E08, "Idle_c condition activated by command")
-SENSE_CODE(0x5E09, "Standby_y condition activated by timer")
-SENSE_CODE(0x5E0A, "Standby_y condition activated by command")
-SENSE_CODE(0x5E41, "Power state change to active")
-SENSE_CODE(0x5E42, "Power state change to idle")
-SENSE_CODE(0x5E43, "Power state change to standby")
-SENSE_CODE(0x5E45, "Power state change to sleep")
-SENSE_CODE(0x5E47, "Power state change to device control")
-
-SENSE_CODE(0x6000, "Lamp failure")
-
-SENSE_CODE(0x6100, "Video acquisition error")
-SENSE_CODE(0x6101, "Unable to acquire video")
-SENSE_CODE(0x6102, "Out of focus")
-
-SENSE_CODE(0x6200, "Scan head positioning error")
-
-SENSE_CODE(0x6300, "End of user area encountered on this track")
-SENSE_CODE(0x6301, "Packet does not fit in available space")
-
-SENSE_CODE(0x6400, "Illegal mode for this track")
-SENSE_CODE(0x6401, "Invalid packet size")
-
-SENSE_CODE(0x6500, "Voltage fault")
-
-SENSE_CODE(0x6600, "Automatic document feeder cover up")
-SENSE_CODE(0x6601, "Automatic document feeder lift up")
-SENSE_CODE(0x6602, "Document jam in automatic document feeder")
-SENSE_CODE(0x6603, "Document miss feed automatic in document feeder")
-
-SENSE_CODE(0x6700, "Configuration failure")
-SENSE_CODE(0x6701, "Configuration of incapable logical units failed")
-SENSE_CODE(0x6702, "Add logical unit failed")
-SENSE_CODE(0x6703, "Modification of logical unit failed")
-SENSE_CODE(0x6704, "Exchange of logical unit failed")
-SENSE_CODE(0x6705, "Remove of logical unit failed")
-SENSE_CODE(0x6706, "Attachment of logical unit failed")
-SENSE_CODE(0x6707, "Creation of logical unit failed")
-SENSE_CODE(0x6708, "Assign failure occurred")
-SENSE_CODE(0x6709, "Multiply assigned logical unit")
-SENSE_CODE(0x670A, "Set target port groups command failed")
-SENSE_CODE(0x670B, "ATA device feature not enabled")
-SENSE_CODE(0x670C, "Command rejected")
-SENSE_CODE(0x670D, "Explicit bind not allowed")
-
-SENSE_CODE(0x6800, "Logical unit not configured")
-SENSE_CODE(0x6801, "Subsidiary logical unit not configured")
-
-SENSE_CODE(0x6900, "Data loss on logical unit")
-SENSE_CODE(0x6901, "Multiple logical unit failures")
-SENSE_CODE(0x6902, "Parity/data mismatch")
-
-SENSE_CODE(0x6A00, "Informational, refer to log")
-
-SENSE_CODE(0x6B00, "State change has occurred")
-SENSE_CODE(0x6B01, "Redundancy level got better")
-SENSE_CODE(0x6B02, "Redundancy level got worse")
-
-SENSE_CODE(0x6C00, "Rebuild failure occurred")
-
-SENSE_CODE(0x6D00, "Recalculate failure occurred")
-
-SENSE_CODE(0x6E00, "Command to logical unit failed")
-
-SENSE_CODE(0x6F00, "Copy protection key exchange failure - authentication failure")
-SENSE_CODE(0x6F01, "Copy protection key exchange failure - key not present")
-SENSE_CODE(0x6F02, "Copy protection key exchange failure - key not established")
-SENSE_CODE(0x6F03, "Read of scrambled sector without authentication")
-SENSE_CODE(0x6F04, "Media region code is mismatched to logical unit region")
-SENSE_CODE(0x6F05, "Drive region must be permanent/region reset count error")
-SENSE_CODE(0x6F06, "Insufficient block count for binding nonce recording")
-SENSE_CODE(0x6F07, "Conflict in binding nonce recording")
-SENSE_CODE(0x6F08, "Insufficient permission")
-SENSE_CODE(0x6F09, "Invalid drive-host pairing server")
-SENSE_CODE(0x6F0A, "Drive-host pairing suspended")
+
+SENSE_CODE(OVERLAPPED_COMMANDS_ATTEMPTED,
+ "Overlapped commands attempted")
+
+SENSE_CODE(WRITE_APPEND_ERROR,
+ "Write append error")
+SENSE_CODE(WRITE_APPEND_POSITION_ERROR,
+ "Write append position error")
+SENSE_CODE(POSITION_ERROR_RELATED_TO_TIMING,
+ "Position error related to timing")
+
+SENSE_CODE(ERASE_FAILURE,
+ "Erase failure")
+SENSE_CODE(ERASE_FAILURE_INCOMPLETE_ERASE_OP_DETECTED,
+ "Erase failure - incomplete erase operation detected")
+
+SENSE_CODE(CARTRIDGE_FAULT,
+ "Cartridge fault")
+
+SENSE_CODE(MEDIA_LOAD_OR_EJECT_FAILED,
+ "Media load or eject failed")
+SENSE_CODE(UNLOAD_TAPE_FAILURE,
+ "Unload tape failure")
+SENSE_CODE(MEDIUM_REMOVAL_PREVENTED,
+ "Medium removal prevented")
+SENSE_CODE(MEDIUM_REMOVAL_PREVENTED_BY_DATA_TRANSFER_ELEMENT,
+ "Medium removal prevented by data transfer element")
+SENSE_CODE(MEDIUM_THREAD_OR_UNTHREAD_FAILURE,
+ "Medium thread or unthread failure")
+SENSE_CODE(VOLUME_IDENTIFIER_INVALID,
+ "Volume identifier invalid")
+SENSE_CODE(VOLUME_IDENTIFIER_MISSING,
+ "Volume identifier missing")
+SENSE_CODE(DUPLICATE_VOLUME_IDENTIFIER,
+ "Duplicate volume identifier")
+SENSE_CODE(ELEMENT_STATUS_UNKNOWN,
+ "Element status unknown")
+SENSE_CODE(DATA_TRANSFER_DEVICE_ERR_LOAD_FAILED,
+ "Data transfer device error - load failed")
+SENSE_CODE(DATA_TRANSFER_DEVICE_ERR_UNLOAD_FAILED,
+ "Data transfer device error - unload failed")
+SENSE_CODE(DATA_TRANSFER_DEVICE_ERR_UNLOAD_MISSING,
+ "Data transfer device error - unload missing")
+SENSE_CODE(DATA_TRANSFER_DEVICE_ERR_EJECT_FAILED,
+ "Data transfer device error - eject failed")
+SENSE_CODE(DATA_TRANSFER_DEVICE_ERR_LIBRARY_COMMUNICATION_FAILED,
+ "Data transfer device error - library communication failed")
+
+SENSE_CODE(SCSI_TO_HOST_SYSTEM_INTERFACE_FAILURE,
+ "Scsi to host system interface failure")
+
+SENSE_CODE(SYSTEM_RESOURCE_FAILURE,
+ "System resource failure")
+SENSE_CODE(SYSTEM_BUFFER_FULL,
+ "System buffer full")
+SENSE_CODE(INSUFFICIENT_RESERVATION_RESOURCES,
+ "Insufficient reservation resources")
+SENSE_CODE(INSUFFICIENT_RESOURCES,
+ "Insufficient resources")
+SENSE_CODE(INSUFFICIENT_REGISTRATION_RESOURCES,
+ "Insufficient registration resources")
+SENSE_CODE(INSUFFICIENT_ACCESS_CONTROL_RESOURCES,
+ "Insufficient access control resources")
+SENSE_CODE(AUXILIARY_MEMORY_OUT_OF_SPACE,
+ "Auxiliary memory out of space")
+SENSE_CODE(QUOTA_ERROR,
+ "Quota error")
+SENSE_CODE(MAXIMUM_NUMBER_OF_SUPPLEMENTAL_DECRYPTION_KEYS_EXCEEDED,
+ "Maximum number of supplemental decryption keys exceeded")
+SENSE_CODE(MEDIUM_AUXILIARY_MEMORY_NOT_ACCESSIBLE,
+ "Medium auxiliary memory not accessible")
+SENSE_CODE(DATA_CURRENTLY_UNAVAILABLE,
+ "Data currently unavailable")
+SENSE_CODE(INSUFFICIENT_POWER_FOR_OPERATION,
+ "Insufficient power for operation")
+SENSE_CODE(INSUFFICIENT_RESOURCES_TO_CREATE_ROD,
+ "Insufficient resources to create rod")
+SENSE_CODE(INSUFFICIENT_RESOURCES_TO_CREATE_ROD_TOKEN,
+ "Insufficient resources to create rod token")
+SENSE_CODE(INSUFFICIENT_ZONE_RESOURCES,
+ "Insufficient zone resources")
+SENSE_CODE(INSUFFICIENT_ZONE_RESOURCES_TO_COMPLETE_WRITE,
+ "Insufficient zone resources to complete write")
+SENSE_CODE(MAXIMUM_NUMBER_OF_STREAMS_OPEN,
+ "Maximum number of streams open")
+SENSE_CODE(INSUFFICIENT_RESOURCES_TO_BIND,
+ "Insufficient resources to bind")
+
+SENSE_CODE(UNABLE_TO_RECOVER_TABLE_OF_CONTENTS,
+ "Unable to recover table-of-contents")
+
+SENSE_CODE(GENERATION_DOES_NOT_EXIST,
+ "Generation does not exist")
+
+SENSE_CODE(UPDATED_BLOCK_READ,
+ "Updated block read")
+
+SENSE_CODE(OPERATOR_REQUEST_OR_STATE_CHANGE_INPUT,
+ "Operator request or state change input")
+SENSE_CODE(OPERATOR_MEDIUM_REMOVAL_REQUEST,
+ "Operator medium removal request")
+SENSE_CODE(OPERATOR_SELECTED_WRITE_PROTECT,
+ "Operator selected write protect")
+SENSE_CODE(OPERATOR_SELECTED_WRITE_PERMIT,
+ "Operator selected write permit")
+
+SENSE_CODE(LOG_EXCEPTION,
+ "Log exception")
+SENSE_CODE(THRESHOLD_CONDITION_MET,
+ "Threshold condition met")
+SENSE_CODE(LOG_COUNTER_AT_MAXIMUM,
+ "Log counter at maximum")
+SENSE_CODE(LOG_LIST_CODES_EXHAUSTED,
+ "Log list codes exhausted")
+
+SENSE_CODE(RPL_STATUS_CHANGE,
+ "Rpl status change")
+SENSE_CODE(SPINDLES_SYNCHRONIZED,
+ "Spindles synchronized")
+SENSE_CODE(SPINDLES_NOT_SYNCHRONIZED,
+ "Spindles not synchronized")
+
+SENSE_CODE(FAILURE_PREDICTION_THRESHOLD_EXCEEDED,
+ "Failure prediction threshold exceeded")
+SENSE_CODE(MEDIA_FAILURE_PREDICTION_THRESHOLD_EXCEEDED,
+ "Media failure prediction threshold exceeded")
+SENSE_CODE(LU_FAILURE_PREDICTION_THRESHOLD_EXCEEDED,
+ "Logical unit failure prediction threshold exceeded")
+SENSE_CODE(SPARE_AREA_EXHAUSTION_PREDICTION_THRESHOLD_EXCEEDED,
+ "Spare area exhaustion prediction threshold exceeded")
+SENSE_CODE(HW_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE,
+ "Hardware impending failure general hard drive failure")
+SENSE_CODE(HW_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH,
+ "Hardware impending failure drive error rate too high")
+SENSE_CODE(HW_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH,
+ "Hardware impending failure data error rate too high")
+SENSE_CODE(HW_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH,
+ "Hardware impending failure seek error rate too high")
+SENSE_CODE(HW_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS,
+ "Hardware impending failure too many block reassigns")
+SENSE_CODE(HW_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH,
+ "Hardware impending failure access times too high")
+SENSE_CODE(HW_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH,
+ "Hardware impending failure start unit times too high")
+SENSE_CODE(HW_IMPENDING_FAILURE_CHANNEL_PARAMETRICS,
+ "Hardware impending failure channel parametrics")
+SENSE_CODE(HW_IMPENDING_FAILURE_CONTROLLER_DETECTED,
+ "Hardware impending failure controller detected")
+SENSE_CODE(HW_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE,
+ "Hardware impending failure throughput performance")
+SENSE_CODE(HW_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE,
+ "Hardware impending failure seek time performance")
+SENSE_CODE(HW_IMPENDING_FAILURE_SPINUP_RETRY_COUNT,
+ "Hardware impending failure spin-up retry count")
+SENSE_CODE(HW_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT,
+ "Hardware impending failure drive calibration retry count")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE,
+ "Controller impending failure general hard drive failure")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH,
+ "Controller impending failure drive error rate too high")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH,
+ "Controller impending failure data error rate too high")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH,
+ "Controller impending failure seek error rate too high")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS,
+ "Controller impending failure too many block reassigns")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH,
+ "Controller impending failure access times too high")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH,
+ "Controller impending failure start unit times too high")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_CHANNEL_PARAMETRICS,
+ "Controller impending failure channel parametrics")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_CONTROLLER_DETECTED,
+ "Controller impending failure controller detected")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE,
+ "Controller impending failure throughput performance")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE,
+ "Controller impending failure seek time performance")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_SPINUP_RETRY_COUNT,
+ "Controller impending failure spin-up retry count")
+SENSE_CODE(CONTROLLER_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT,
+ "Controller impending failure drive calibration retry count")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE,
+ "Data channel impending failure general hard drive failure")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH,
+ "Data channel impending failure drive error rate too high")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH,
+ "Data channel impending failure data error rate too high")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH,
+ "Data channel impending failure seek error rate too high")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS,
+ "Data channel impending failure too many block reassigns")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH,
+ "Data channel impending failure access times too high")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH,
+ "Data channel impending failure start unit times too high")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_CHANNEL_PARAMETRICS,
+ "Data channel impending failure channel parametrics")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_CONTROLLER_DETECTED,
+ "Data channel impending failure controller detected")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE,
+ "Data channel impending failure throughput performance")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE,
+ "Data channel impending failure seek time performance")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_SPINUP_RETRY_COUNT,
+ "Data channel impending failure spin-up retry count")
+SENSE_CODE(DATA_CHANNEL_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT,
+ "Data channel impending failure drive calibration retry count")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE,
+ "Servo impending failure general hard drive failure")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH,
+ "Servo impending failure drive error rate too high")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH,
+ "Servo impending failure data error rate too high")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH,
+ "Servo impending failure seek error rate too high")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS,
+ "Servo impending failure too many block reassigns")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH,
+ "Servo impending failure access times too high")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH,
+ "Servo impending failure start unit times too high")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_CHANNEL_PARAMETRICS,
+ "Servo impending failure channel parametrics")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_CONTROLLER_DETECTED,
+ "Servo impending failure controller detected")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE,
+ "Servo impending failure throughput performance")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE,
+ "Servo impending failure seek time performance")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_SPINUP_RETRY_COUNT,
+ "Servo impending failure spin-up retry count")
+SENSE_CODE(SERVO_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT,
+ "Servo impending failure drive calibration retry count")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE,
+ "Spindle impending failure general hard drive failure")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH,
+ "Spindle impending failure drive error rate too high")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH,
+ "Spindle impending failure data error rate too high")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH,
+ "Spindle impending failure seek error rate too high")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS,
+ "Spindle impending failure too many block reassigns")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH,
+ "Spindle impending failure access times too high")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH,
+ "Spindle impending failure start unit times too high")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_CHANNEL_PARAMETRICS,
+ "Spindle impending failure channel parametrics")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_CONTROLLER_DETECTED,
+ "Spindle impending failure controller detected")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE,
+ "Spindle impending failure throughput performance")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE,
+ "Spindle impending failure seek time performance")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_SPINUP_RETRY_COUNT,
+ "Spindle impending failure spin-up retry count")
+SENSE_CODE(SPINDLE_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT,
+ "Spindle impending failure drive calibration retry count")
+SENSE_CODE(FW_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE,
+ "Firmware impending failure general hard drive failure")
+SENSE_CODE(FW_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH,
+ "Firmware impending failure drive error rate too high")
+SENSE_CODE(FW_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH,
+ "Firmware impending failure data error rate too high")
+SENSE_CODE(FW_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH,
+ "Firmware impending failure seek error rate too high")
+SENSE_CODE(FW_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS,
+ "Firmware impending failure too many block reassigns")
+SENSE_CODE(FW_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH,
+ "Firmware impending failure access times too high")
+SENSE_CODE(FW_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH,
+ "Firmware impending failure start unit times too high")
+SENSE_CODE(FW_IMPENDING_FAILURE_CHANNEL_PARAMETRICS,
+ "Firmware impending failure channel parametrics")
+SENSE_CODE(FW_IMPENDING_FAILURE_CONTROLLER_DETECTED,
+ "Firmware impending failure controller detected")
+SENSE_CODE(FW_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE,
+ "Firmware impending failure throughput performance")
+SENSE_CODE(FW_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE,
+ "Firmware impending failure seek time performance")
+SENSE_CODE(FW_IMPENDING_FAILURE_SPINUP_RETRY_COUNT,
+ "Firmware impending failure spin-up retry count")
+SENSE_CODE(FW_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT,
+ "Firmware impending failure drive calibration retry count")
+SENSE_CODE(MEDIA_IMPENDING_FAILURE_ENDURANCE_LIMIT_MET,
+ "Media impending failure endurance limit met")
+SENSE_CODE(FAILURE_PREDICTION_THRESHOLD_EXCEEDED_FALSE,
+ "Failure prediction threshold exceeded (false)")
+
+SENSE_CODE(LOW_POWER_CONDITION_ON,
+ "Low power condition on")
+SENSE_CODE(IDLE_CONDITION_ACTIVATED_BY_TIMER,
+ "Idle condition activated by timer")
+SENSE_CODE(STANDBY_CONDITION_ACTIVATED_BY_TIMER,
+ "Standby condition activated by timer")
+SENSE_CODE(IDLE_CONDITION_ACTIVATED_BY_COMMAND,
+ "Idle condition activated by command")
+SENSE_CODE(STANDBY_CONDITION_ACTIVATED_BY_COMMAND,
+ "Standby condition activated by command")
+SENSE_CODE(IDLE_B_CONDITION_ACTIVATED_BY_TIMER,
+ "Idle_b condition activated by timer")
+SENSE_CODE(IDLE_B_CONDITION_ACTIVATED_BY_COMMAND,
+ "Idle_b condition activated by command")
+SENSE_CODE(IDLE_C_CONDITION_ACTIVATED_BY_TIMER,
+ "Idle_c condition activated by timer")
+SENSE_CODE(IDLE_C_CONDITION_ACTIVATED_BY_COMMAND,
+ "Idle_c condition activated by command")
+SENSE_CODE(STANDBY_Y_CONDITION_ACTIVATED_BY_TIMER,
+ "Standby_y condition activated by timer")
+SENSE_CODE(STANDBY_Y_CONDITION_ACTIVATED_BY_COMMAND,
+ "Standby_y condition activated by command")
+SENSE_CODE(POWER_STATE_CHANGE_TO_ACTIVE,
+ "Power state change to active")
+SENSE_CODE(POWER_STATE_CHANGE_TO_IDLE,
+ "Power state change to idle")
+SENSE_CODE(POWER_STATE_CHANGE_TO_STANDBY,
+ "Power state change to standby")
+SENSE_CODE(POWER_STATE_CHANGE_TO_SLEEP,
+ "Power state change to sleep")
+SENSE_CODE(POWER_STATE_CHANGE_TO_DEVICE_CONTROL,
+ "Power state change to device control")
+
+SENSE_CODE(LAMP_FAILURE,
+ "Lamp failure")
+
+SENSE_CODE(VIDEO_ACQUISITION_ERROR,
+ "Video acquisition error")
+SENSE_CODE(UNABLE_TO_ACQUIRE_VIDEO,
+ "Unable to acquire video")
+SENSE_CODE(OUT_OF_FOCUS,
+ "Out of focus")
+
+SENSE_CODE(SCAN_HEAD_POSITIONING_ERROR,
+ "Scan head positioning error")
+
+SENSE_CODE(END_OF_USER_AREA_ENCOUNTERED_ON_THIS_TRACK,
+ "End of user area encountered on this track")
+SENSE_CODE(PACKET_DOES_NOT_FIT_IN_AVAILABLE_SPACE,
+ "Packet does not fit in available space")
+
+SENSE_CODE(ILLEGAL_MODE_FOR_THIS_TRACK,
+ "Illegal mode for this track")
+SENSE_CODE(INVALID_PACKET_SIZE,
+ "Invalid packet size")
+
+SENSE_CODE(VOLTAGE_FAULT,
+ "Voltage fault")
+
+SENSE_CODE(AUTOMATIC_DOCUMENT_FEEDER_COVER_UP,
+ "Automatic document feeder cover up")
+SENSE_CODE(AUTOMATIC_DOCUMENT_FEEDER_LIFT_UP,
+ "Automatic document feeder lift up")
+SENSE_CODE(DOCUMENT_JAM_IN_AUTOMATIC_DOCUMENT_FEEDER,
+ "Document jam in automatic document feeder")
+SENSE_CODE(DOCUMENT_MISS_FEED_AUTOMATIC_IN_DOCUMENT_FEEDER,
+ "Document miss feed automatic in document feeder")
+
+SENSE_CODE(CONFIG_FAILURE,
+ "Configuration failure")
+SENSE_CODE(CONFIG_OF_INCAPABLE_LOGICAL_UNITS_FAILED,
+ "Configuration of incapable logical units failed")
+SENSE_CODE(ADD_LU_FAILED,
+ "Add logical unit failed")
+SENSE_CODE(MODIFICATION_OF_LU_FAILED,
+ "Modification of logical unit failed")
+SENSE_CODE(EXCHANGE_OF_LU_FAILED,
+ "Exchange of logical unit failed")
+SENSE_CODE(REMOVE_OF_LU_FAILED,
+ "Remove of logical unit failed")
+SENSE_CODE(ATTACHMENT_OF_LU_FAILED,
+ "Attachment of logical unit failed")
+SENSE_CODE(CREATION_OF_LU_FAILED,
+ "Creation of logical unit failed")
+SENSE_CODE(ASSIGN_FAILURE_OCCURRED,
+ "Assign failure occurred")
+SENSE_CODE(MULTIPLY_ASSIGNED_LOGICAL_UNIT,
+ "Multiply assigned logical unit")
+SENSE_CODE(SET_TARGET_PORT_GROUPS_COMMAND_FAILED,
+ "Set target port groups command failed")
+SENSE_CODE(ATA_DEVICE_FEATURE_NOT_ENABLED,
+ "ATA device feature not enabled")
+SENSE_CODE(COMMAND_REJECTED,
+ "Command rejected")
+SENSE_CODE(EXPLICIT_BIND_NOT_ALLOWED,
+ "Explicit bind not allowed")
+
+SENSE_CODE(LU_NOT_CONFIGURED,
+ "Logical unit not configured")
+SENSE_CODE(SUBSIDIARY_LU_NOT_CONFIGURED,
+ "Subsidiary logical unit not configured")
+
+SENSE_CODE(DATA_LOSS_ON_LOGICAL_UNIT,
+ "Data loss on logical unit")
+SENSE_CODE(MULTIPLE_LU_FAILURES,
+ "Multiple logical unit failures")
+SENSE_CODE(PARITY_DATA_MISMATCH,
+ "Parity/data mismatch")
+
+SENSE_CODE(INFORMATIONAL_REFER_TO_LOG,
+ "Informational, refer to log")
+
+SENSE_CODE(STATE_CHANGE_HAS_OCCURRED,
+ "State change has occurred")
+SENSE_CODE(REDUNDANCY_LEVEL_GOT_BETTER,
+ "Redundancy level got better")
+SENSE_CODE(REDUNDANCY_LEVEL_GOT_WORSE,
+ "Redundancy level got worse")
+
+SENSE_CODE(REBUILD_FAILURE_OCCURRED,
+ "Rebuild failure occurred")
+
+SENSE_CODE(RECALCULATE_FAILURE_OCCURRED,
+ "Recalculate failure occurred")
+
+SENSE_CODE(COMMAND_TO_LU_FAILED,
+ "Command to logical unit failed")
+
+SENSE_CODE(COPY_PROTECTION_KEY_EXCHANGE_FAILURE_AUTHENTICATION_FAILURE,
+ "Copy protection key exchange failure - authentication failure")
+SENSE_CODE(COPY_PROTECTION_KEY_EXCHANGE_FAILURE_KEY_NOT_PRESENT,
+ "Copy protection key exchange failure - key not present")
+SENSE_CODE(COPY_PROTECTION_KEY_EXCHANGE_FAILURE_KEY_NOT_ESTABLISHED,
+ "Copy protection key exchange failure - key not established")
+SENSE_CODE(READ_OF_SCRAMBLED_SECTOR_WITHOUT_AUTHENTICATION,
+ "Read of scrambled sector without authentication")
+SENSE_CODE(MEDIA_REGION_CODE_IS_MISMATCHED_TO_LU_REGION,
+ "Media region code is mismatched to logical unit region")
+SENSE_CODE(DRIVE_REGION_MUST_BE_PERMANENT_REGION_RESET_COUNT_ERROR,
+ "Drive region must be permanent/region reset count error")
+SENSE_CODE(INSUFFICIENT_BLOCK_COUNT_FOR_BINDING_NONCE_RECORDING,
+ "Insufficient block count for binding nonce recording")
+SENSE_CODE(CONFLICT_IN_BINDING_NONCE_RECORDING,
+ "Conflict in binding nonce recording")
+SENSE_CODE(INSUFFICIENT_PERMISSION,
+ "Insufficient permission")
+SENSE_CODE(INVALID_DRIVE_HOST_PAIRING_SERVER,
+ "Invalid drive-host pairing server")
+SENSE_CODE(DRIVE_HOST_PAIRING_SUSPENDED,
+ "Drive-host pairing suspended")
/*
- * SENSE_CODE(0x70NN, "Decompression exception short algorithm id of nn")
+ * SENSE_CODE(0x70NN, "Decompression exception short algorithm id of nn")
*/
-SENSE_CODE(0x7100, "Decompression exception long algorithm id")
-
-SENSE_CODE(0x7200, "Session fixation error")
-SENSE_CODE(0x7201, "Session fixation error writing lead-in")
-SENSE_CODE(0x7202, "Session fixation error writing lead-out")
-SENSE_CODE(0x7203, "Session fixation error - incomplete track in session")
-SENSE_CODE(0x7204, "Empty or partially written reserved track")
-SENSE_CODE(0x7205, "No more track reservations allowed")
-SENSE_CODE(0x7206, "RMZ extension is not allowed")
-SENSE_CODE(0x7207, "No more test zone extensions are allowed")
-
-SENSE_CODE(0x7300, "Cd control error")
-SENSE_CODE(0x7301, "Power calibration area almost full")
-SENSE_CODE(0x7302, "Power calibration area is full")
-SENSE_CODE(0x7303, "Power calibration area error")
-SENSE_CODE(0x7304, "Program memory area update failure")
-SENSE_CODE(0x7305, "Program memory area is full")
-SENSE_CODE(0x7306, "RMA/PMA is almost full")
-SENSE_CODE(0x7310, "Current power calibration area almost full")
-SENSE_CODE(0x7311, "Current power calibration area is full")
-SENSE_CODE(0x7317, "RDZ is full")
-
-SENSE_CODE(0x7400, "Security error")
-SENSE_CODE(0x7401, "Unable to decrypt data")
-SENSE_CODE(0x7402, "Unencrypted data encountered while decrypting")
-SENSE_CODE(0x7403, "Incorrect data encryption key")
-SENSE_CODE(0x7404, "Cryptographic integrity validation failed")
-SENSE_CODE(0x7405, "Error decrypting data")
-SENSE_CODE(0x7406, "Unknown signature verification key")
-SENSE_CODE(0x7407, "Encryption parameters not useable")
-SENSE_CODE(0x7408, "Digital signature validation failure")
-SENSE_CODE(0x7409, "Encryption mode mismatch on read")
-SENSE_CODE(0x740A, "Encrypted block not raw read enabled")
-SENSE_CODE(0x740B, "Incorrect Encryption parameters")
-SENSE_CODE(0x740C, "Unable to decrypt parameter list")
-SENSE_CODE(0x740D, "Encryption algorithm disabled")
-SENSE_CODE(0x7410, "SA creation parameter value invalid")
-SENSE_CODE(0x7411, "SA creation parameter value rejected")
-SENSE_CODE(0x7412, "Invalid SA usage")
-SENSE_CODE(0x7421, "Data Encryption configuration prevented")
-SENSE_CODE(0x7430, "SA creation parameter not supported")
-SENSE_CODE(0x7440, "Authentication failed")
-SENSE_CODE(0x7461, "External data encryption key manager access error")
-SENSE_CODE(0x7462, "External data encryption key manager error")
-SENSE_CODE(0x7463, "External data encryption key not found")
-SENSE_CODE(0x7464, "External data encryption request not authorized")
-SENSE_CODE(0x746E, "External data encryption control timeout")
-SENSE_CODE(0x746F, "External data encryption control error")
-SENSE_CODE(0x7471, "Logical unit access not authorized")
-SENSE_CODE(0x7479, "Security conflict in translated device")
+
+SENSE_CODE(DECOMPRESSION_EXCEPTION_LONG_ALGORITHM_ID,
+ "Decompression exception long algorithm id")
+
+SENSE_CODE(SESSION_FIXATION_ERROR,
+ "Session fixation error")
+SENSE_CODE(SESSION_FIXATION_ERROR_WRITING_LEAD_IN,
+ "Session fixation error writing lead-in")
+SENSE_CODE(SESSION_FIXATION_ERROR_WRITING_LEAD_OUT,
+ "Session fixation error writing lead-out")
+SENSE_CODE(SESSION_FIXATION_ERROR_INCOMPLETE_TRACK_IN_SESSION,
+ "Session fixation error - incomplete track in session")
+SENSE_CODE(EMPTY_OR_PARTIALLY_WRITTEN_RESERVED_TRACK,
+ "Empty or partially written reserved track")
+SENSE_CODE(NO_MORE_TRACK_RESERVATIONS_ALLOWED,
+ "No more track reservations allowed")
+SENSE_CODE(RMZ_EXTENSION_IS_NOT_ALLOWED,
+ "RMZ extension is not allowed")
+SENSE_CODE(NO_MORE_TEST_ZONE_EXTENSIONS_ARE_ALLOWED,
+ "No more test zone extensions are allowed")
+
+SENSE_CODE(CD_CONTROL_ERROR,
+ "Cd control error")
+SENSE_CODE(POWER_CALIBRATION_AREA_ALMOST_FULL,
+ "Power calibration area almost full")
+SENSE_CODE(POWER_CALIBRATION_AREA_IS_FULL,
+ "Power calibration area is full")
+SENSE_CODE(POWER_CALIBRATION_AREA_ERROR,
+ "Power calibration area error")
+SENSE_CODE(PROGRAM_MEMORY_AREA_UPDATE_FAILURE,
+ "Program memory area update failure")
+SENSE_CODE(PROGRAM_MEMORY_AREA_IS_FULL,
+ "Program memory area is full")
+SENSE_CODE(RMA_PMA_IS_ALMOST_FULL,
+ "RMA/PMA is almost full")
+SENSE_CODE(CURRENT_POWER_CALIBRATION_AREA_ALMOST_FULL,
+ "Current power calibration area almost full")
+SENSE_CODE(CURRENT_POWER_CALIBRATION_AREA_IS_FULL,
+ "Current power calibration area is full")
+SENSE_CODE(RDZ_IS_FULL,
+ "RDZ is full")
+
+SENSE_CODE(SECURITY_ERROR,
+ "Security error")
+SENSE_CODE(UNABLE_TO_DECRYPT_DATA,
+ "Unable to decrypt data")
+SENSE_CODE(UNENCRYPTED_DATA_ENCOUNTERED_WHILE_DECRYPTING,
+ "Unencrypted data encountered while decrypting")
+SENSE_CODE(INCORRECT_DATA_ENCRYPTION_KEY,
+ "Incorrect data encryption key")
+SENSE_CODE(CRYPTOGRAPHIC_INTEGRITY_VALIDATION_FAILED,
+ "Cryptographic integrity validation failed")
+SENSE_CODE(ERROR_DECRYPTING_DATA,
+ "Error decrypting data")
+SENSE_CODE(UNKNOWN_SIGNATURE_VERIFICATION_KEY,
+ "Unknown signature verification key")
+SENSE_CODE(ENCRYPTION_PARAMS_NOT_USEABLE,
+ "Encryption parameters not useable")
+SENSE_CODE(DIGITAL_SIGNATURE_VALIDATION_FAILURE,
+ "Digital signature validation failure")
+SENSE_CODE(ENCRYPTION_MODE_MISMATCH_ON_READ,
+ "Encryption mode mismatch on read")
+SENSE_CODE(ENCRYPTED_BLOCK_NOT_RAW_READ_ENABLED,
+ "Encrypted block not raw read enabled")
+SENSE_CODE(INCORRECT_ENCRYPTION_PARAMS,
+ "Incorrect Encryption parameters")
+SENSE_CODE(UNABLE_TO_DECRYPT_PARAMETER_LIST,
+ "Unable to decrypt parameter list")
+SENSE_CODE(ENCRYPTION_ALGORITHM_DISABLED,
+ "Encryption algorithm disabled")
+SENSE_CODE(SA_CREATION_PARAMETER_VALUE_INVALID,
+ "SA creation parameter value invalid")
+SENSE_CODE(SA_CREATION_PARAMETER_VALUE_REJECTED,
+ "SA creation parameter value rejected")
+SENSE_CODE(INVALID_SA_USAGE,
+ "Invalid SA usage")
+SENSE_CODE(DATA_ENCRYPTION_CONFIG_PREVENTED,
+ "Data Encryption configuration prevented")
+SENSE_CODE(SA_CREATION_PARAMETER_NOT_SUPPORTED,
+ "SA creation parameter not supported")
+SENSE_CODE(AUTHENTICATION_FAILED,
+ "Authentication failed")
+SENSE_CODE(EXTERNAL_DATA_ENCRYPTION_KEY_MANAGER_ACCESS_ERROR,
+ "External data encryption key manager access error")
+SENSE_CODE(EXTERNAL_DATA_ENCRYPTION_KEY_MANAGER_ERROR,
+ "External data encryption key manager error")
+SENSE_CODE(EXTERNAL_DATA_ENCRYPTION_KEY_NOT_FOUND,
+ "External data encryption key not found")
+SENSE_CODE(EXTERNAL_DATA_ENCRYPTION_REQUEST_NOT_AUTHORIZED,
+ "External data encryption request not authorized")
+SENSE_CODE(EXTERNAL_DATA_ENCRYPTION_CONTROL_TIMEOUT,
+ "External data encryption control timeout")
+SENSE_CODE(EXTERNAL_DATA_ENCRYPTION_CONTROL_ERROR,
+ "External data encryption control error")
+SENSE_CODE(LU_ACCESS_NOT_AUTHORIZED,
+ "Logical unit access not authorized")
+SENSE_CODE(SECURITY_CONFLICT_IN_TRANSLATED_DEVICE,
+ "Security conflict in translated device")
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 03/37] scsi: constants: rename internal struct field names
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
2026-08-31 2:04 ` [PATCH 01/37] scsi: define all additional sense codes and their qualifiers Damien Le Moal
2026-08-31 2:04 ` [PATCH 02/37] scsi: constants: use defined sense codes Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 04/37] scsi: rename sense field of struct scsi_failure Damien Le Moal
` (34 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
To make the code more clear, rename the code12 field of struct error_info
to the more natural name "code" and the fields code1, code2_min and
code2_max of struct error_info2 to the more explicit asc, ascq_min and
ascq_max.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/constants.c | 22 ++++++++++++----------
1 file changed, 12 insertions(+), 10 deletions(-)
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index 340785536998..4b97f574fe8c 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -292,7 +292,7 @@ bool scsi_opcode_sa_name(int opcode, int service_action,
}
struct error_info {
- unsigned short code12; /* 0x0302 looks better than 0x03,0x02 */
+ unsigned short code; /* 0x0302 looks better than 0x03,0x02 */
unsigned short size;
};
@@ -318,9 +318,11 @@ static const char *additional_text =
;
struct error_info2 {
- unsigned char code1, code2_min, code2_max;
- const char * str;
- const char * fmt;
+ u8 asc;
+ u8 ascq_min;
+ u8 ascq_max;
+ const char *str;
+ const char *fmt;
};
static const struct error_info2 additional2[] =
@@ -377,20 +379,20 @@ EXPORT_SYMBOL(scsi_sense_key_string);
const char *
scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
{
- int i;
- unsigned short code = ((asc << 8) | ascq);
+ u16 code = scsi_sense_code(asc, ascq);
unsigned offset = 0;
+ int i;
*fmt = NULL;
for (i = 0; i < ARRAY_SIZE(additional); i++) {
- if (additional[i].code12 == code)
+ if (additional[i].code == code)
return additional_text + offset;
offset += additional[i].size;
}
for (i = 0; additional2[i].fmt; i++) {
- if (additional2[i].code1 == asc &&
- ascq >= additional2[i].code2_min &&
- ascq <= additional2[i].code2_max) {
+ if (additional2[i].asc == asc &&
+ ascq >= additional2[i].ascq_min &&
+ ascq <= additional2[i].ascq_max) {
*fmt = additional2[i].fmt;
return additional2[i].str;
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 04/37] scsi: rename sense field of struct scsi_failure
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (2 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 03/37] scsi: constants: rename internal struct field names Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:17 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 05/37] scsi: prepare for using 16-bits defined sense codes Damien Le Moal
` (33 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Rename the sense field of struct scsi_failure to sense_key. This makes
it clear that this field stores the sense key, and also unifies this
structure field names with the names used in struct scsi_sense_hdr.
To be consistent with this change, the macro SCMD_FAILURE_SENSE_ANY is
renamed SCMD_FAILURE_SENSE_KEY_ANY.
Of note is that the definition of the array any_sense_failure_defs in
scsi_lib_test_any_sense() is modified to change the initialization of the
result field to use SCMD_FAILURE_RESULT_ANY and add the .sense_key field
initialization to SCMD_FAILURE_SENSE_KEY_ANY to match the test target
case.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/ch.c | 2 +-
drivers/scsi/device_handler/scsi_dh_hp_sw.c | 4 ++--
drivers/scsi/device_handler/scsi_dh_rdac.c | 10 ++++-----
drivers/scsi/scsi_lib.c | 6 ++---
drivers/scsi/scsi_lib_test.c | 25 +++++++++++----------
drivers/scsi/scsi_scan.c | 8 +++----
drivers/scsi/scsi_transport_spi.c | 2 +-
drivers/scsi/sd.c | 20 ++++++++---------
drivers/scsi/ses.c | 8 +++----
include/scsi/scsi_device.h | 12 +++++-----
10 files changed, 49 insertions(+), 48 deletions(-)
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index 4010fdbf813c..b804291a36ff 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -191,7 +191,7 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
struct scsi_sense_hdr sshdr;
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = 3,
diff --git a/drivers/scsi/device_handler/scsi_dh_hp_sw.c b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
index 6e8849d7f0a3..3431e1ce95fd 100644
--- a/drivers/scsi/device_handler/scsi_dh_hp_sw.c
+++ b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
@@ -84,7 +84,7 @@ static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = SCMD_FAILURE_NO_LIMIT,
@@ -138,7 +138,7 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
*
* Switch-over in progress, retry.
*/
- .sense = NOT_READY,
+ .sense_key = NOT_READY,
.asc = 0x04,
.ascq = 0x03,
.allowed = HP_SW_RETRIES,
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 88c8e36b221e..75c9cc291e38 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -514,33 +514,33 @@ static void send_mode_select(struct work_struct *work)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
- .sense = NO_SENSE,
+ .sense_key = NO_SENSE,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = ABORTED_COMMAND,
+ .sense_key = ABORTED_COMMAND,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* LUN Not Ready and is in the Process of Becoming Ready */
{
- .sense = NOT_READY,
+ .sense_key = NOT_READY,
.asc = 0x04,
.ascq = 0x01,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Command Lock contention */
{
- .sense = ILLEGAL_REQUEST,
+ .sense_key = ILLEGAL_REQUEST,
.asc = 0x91,
.ascq = 0x36,
.allowed = SCMD_FAILURE_NO_LIMIT,
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index af27fd3df8d4..4901b2dff653 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -243,13 +243,13 @@ static int scsi_check_passthrough(struct scsi_cmnd *scmd,
continue;
if (status_byte(failure->result) != SAM_STAT_CHECK_CONDITION ||
- failure->sense == SCMD_FAILURE_SENSE_ANY)
+ failure->sense_key == SCMD_FAILURE_SENSE_KEY_ANY)
goto maybe_retry;
if (!scsi_command_normalize_sense(scmd, &sshdr))
return 0;
- if (failure->sense != sshdr.sense_key)
+ if (failure->sense_key != sshdr.sense_key)
continue;
if (failure->asc == SCMD_FAILURE_ASC_ANY)
@@ -2372,7 +2372,7 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, int subpage,
struct scsi_sense_hdr my_sshdr;
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = retries,
diff --git a/drivers/scsi/scsi_lib_test.c b/drivers/scsi/scsi_lib_test.c
index ae8af0e0047a..4558dc853e26 100644
--- a/drivers/scsi/scsi_lib_test.c
+++ b/drivers/scsi/scsi_lib_test.c
@@ -17,40 +17,40 @@ static void scsi_lib_test_multiple_sense(struct kunit *test)
{
struct scsi_failure multiple_sense_failure_defs[] = {
{
- .sense = DATA_PROTECT,
+ .sense_key = DATA_PROTECT,
.asc = 0x1,
.ascq = 0x1,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x11,
.ascq = 0x0,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = NOT_READY,
+ .sense_key = NOT_READY,
.asc = 0x11,
.ascq = 0x22,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = ABORTED_COMMAND,
+ .sense_key = ABORTED_COMMAND,
.asc = 0x11,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = HARDWARE_ERROR,
+ .sense_key = HARDWARE_ERROR,
.asc = SCMD_FAILURE_ASC_ANY,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = ILLEGAL_REQUEST,
+ .sense_key = ILLEGAL_REQUEST,
.asc = 0x91,
.ascq = 0x36,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
@@ -116,8 +116,9 @@ static void scsi_lib_test_any_sense(struct kunit *test)
{
struct scsi_failure any_sense_failure_defs[] = {
{
- .result = SCMD_FAILURE_SENSE_ANY,
+ .sense_key = SCMD_FAILURE_SENSE_KEY_ANY,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
+ .result = SCMD_FAILURE_RESULT_ANY,
},
{}
};
@@ -129,7 +130,7 @@ static void scsi_lib_test_any_sense(struct kunit *test)
.sense_buffer = sense,
};
- /* Match using SCMD_FAILURE_SENSE_ANY */
+ /* Match using SCMD_FAILURE_SENSE_KEY_ANY */
failures.failure_definitions = any_sense_failure_defs;
scsi_build_sense(&sc, 0, MEDIUM_ERROR, 0x11, 0x22);
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
@@ -215,14 +216,14 @@ static void scsi_lib_test_total_allowed(struct kunit *test)
{
struct scsi_failure total_allowed_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Fail all CCs except the UA above */
{
- .sense = SCMD_FAILURE_SENSE_ANY,
+ .sense_key = SCMD_FAILURE_SENSE_KEY_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Retry any other errors not listed above */
@@ -259,12 +260,12 @@ static void scsi_lib_test_mixed_total(struct kunit *test)
{
struct scsi_failure mixed_total_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x28,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x29,
.result = SAM_STAT_CHECK_CONDITION,
},
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 3b82e80e807a..003ab639e76d 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -658,12 +658,12 @@ static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
* so anyway.
*/
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x28,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x29,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -1457,14 +1457,14 @@ static int scsi_report_lun_scan(struct Scsi_Host *shost,
struct scsi_device *sdev;
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Fail all CCs except the UA above */
{
- .sense = SCMD_FAILURE_SENSE_ANY,
+ .sense_key = SCMD_FAILURE_SENSE_KEY_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Retry any other errors not listed above */
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index 3e3da8c2ff26..ec3884a6657f 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -112,7 +112,7 @@ static int spi_execute(struct scsi_device *sdev, const void *cmd,
REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = DV_RETRIES,
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index a1b21ea14e54..fecb001115ab 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -2033,7 +2033,7 @@ static int sd_pr_in_command(struct block_device *bdev, u8 sa,
u8 cmd[10] = { PERSISTENT_RESERVE_IN, sa };
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = 5,
@@ -2145,7 +2145,7 @@ static int sd_pr_out_command(struct block_device *bdev, u8 sa, u64 key,
struct scsi_sense_hdr sshdr;
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = 5,
@@ -2494,13 +2494,13 @@ sd_spinup_disk(struct scsi_disk *sdkp)
struct scsi_failure failure_defs[] = {
/* Do not retry Medium Not Present */
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x3A,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = NOT_READY,
+ .sense_key = NOT_READY,
.asc = 0x3A,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
@@ -2817,18 +2817,18 @@ static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
struct scsi_failure failure_defs[] = {
/* Do not retry Medium Not Present */
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x3A,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = NOT_READY,
+ .sense_key = NOT_READY,
.asc = 0x3A,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Device reset might occur several times so retry a lot */
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x29,
.allowed = READ_CAPACITY_RETRIES_ON_RESET,
.result = SAM_STAT_CHECK_CONDITION,
@@ -4159,21 +4159,21 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
struct scsi_failure failure_defs[] = {
{
/* Power on, reset, or bus device reset occurred */
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x29,
.ascq = 0,
.result = SAM_STAT_CHECK_CONDITION,
},
{
/* Power on occurred */
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x29,
.ascq = 1,
.result = SAM_STAT_CHECK_CONDITION,
},
{
/* SCSI bus reset */
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x29,
.ascq = 2,
.result = SAM_STAT_CHECK_CONDITION,
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index 4c348645b04e..454886c24570 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -88,14 +88,14 @@ static int ses_recv_diag(struct scsi_device *sdev, int page_code,
unsigned char recv_page_code;
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x29,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = NOT_READY,
+ .sense_key = NOT_READY,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = SES_RETRIES,
@@ -145,14 +145,14 @@ static int ses_send_diag(struct scsi_device *sdev, int page_code,
};
struct scsi_failure failure_defs[] = {
{
- .sense = UNIT_ATTENTION,
+ .sense_key = UNIT_ATTENTION,
.asc = 0x29,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
{
- .sense = NOT_READY,
+ .sense_key = NOT_READY,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.allowed = SES_RETRIES,
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 8694eeadd753..e321471e8ca2 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -514,18 +514,18 @@ extern void scsi_sanitize_inquiry_string(unsigned char *s, int len);
*/
#define SCMD_FAILURE_STAT_ANY 0xff
/*
- * The following can be set to the scsi_failure sense, asc and ascq fields to
- * match on any sense, ASC, or ASCQ value.
+ * The following can be set to the scsi_failure sense key, asc and ascq fields
+ * to match any sense key, ASC, and ASCQ value.
*/
-#define SCMD_FAILURE_SENSE_ANY 0xff
-#define SCMD_FAILURE_ASC_ANY 0xff
-#define SCMD_FAILURE_ASCQ_ANY 0xff
+#define SCMD_FAILURE_SENSE_KEY_ANY 0xff
+#define SCMD_FAILURE_ASC_ANY 0xff
+#define SCMD_FAILURE_ASCQ_ANY 0xff
/* Always retry a matching failure. */
#define SCMD_FAILURE_NO_LIMIT -1
struct scsi_failure {
int result;
- u8 sense;
+ u8 sense_key;
u8 asc;
u8 ascq;
/*
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 04/37] scsi: rename sense field of struct scsi_failure
2026-08-31 2:04 ` [PATCH 04/37] scsi: rename sense field of struct scsi_failure Damien Le Moal
@ 2026-08-31 2:17 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:17 UTC (permalink / raw)
To: Damien Le Moal; +Cc: linux-ide, linux-scsi, cassel, dlemoal
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The unit test `scsi_lib_test_any_sense()` is broken because `.result` is incorrectly initialized to `SCMD_FAILURE_RESULT_ANY`, completely bypassing the sense key check.
--
commit be75fcae059f5a6c0fee14ecc0a6ae4e8a66d23d
Author: Damien Le Moal <dlemoal@kernel.org>
scsi: rename sense field of struct scsi_failure
This commit renames the sense field of struct scsi_failure to sense_key
to make its purpose clearer and align it with struct scsi_sense_hdr. It
also renames the associated SCMD_FAILURE_SENSE_ANY macro and updates
initializations in tests.
> diff --git a/drivers/scsi/scsi_lib_test.c b/drivers/scsi/scsi_lib_test.c
> index ae8af0e0047a8..4558dc853e26e 100644
> --- a/drivers/scsi/scsi_lib_test.c
> +++ b/drivers/scsi/scsi_lib_test.c
[ ... ]
> @@ -116,8 +116,9 @@ static void scsi_lib_test_any_sense(struct kunit *test)
> {
> struct scsi_failure any_sense_failure_defs[] = {
> {
> - .result = SCMD_FAILURE_SENSE_ANY,
> + .sense_key = SCMD_FAILURE_SENSE_KEY_ANY,
> .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
> + .result = SCMD_FAILURE_RESULT_ANY,
> },
> {}
> };
[Severity: Medium]
Does setting .result to SCMD_FAILURE_RESULT_ANY here cause the test to
bypass the sense key checking logic completely?
Looking at scsi_check_passthrough() in drivers/scsi/scsi_lib.c, the check
short-circuits when .result is SCMD_FAILURE_RESULT_ANY:
drivers/scsi/scsi_lib.c:scsi_check_passthrough() {
...
for (failure = failures->failure_definitions; failure->result;
failure++) {
if (failure->result == SCMD_FAILURE_RESULT_ANY)
goto maybe_retry;
...
}
Because of this short-circuit, the sense key check logic is never actually
evaluated. To properly test SCMD_FAILURE_SENSE_KEY_ANY, shouldn't .result be
initialized to SAM_STAT_CHECK_CONDITION instead?
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=4
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 05/37] scsi: prepare for using 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (3 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 04/37] scsi: rename sense field of struct scsi_failure Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 06/37] scsi: use struct scsi_sense_hdr to log sense keys and codes Damien Le Moal
` (32 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
In preparation for handling sense codes and their qualifiers as a single
16-bits sense code field, with the values defined as macros in
include/scsi/scsi_sense.h, modify the definition of the structures
scsi_failure and scsi_sense_hdr to introduce a 16-bits sense_code field
as a union with the existing 8-bits asc and ascq fields.
This temporary modification allows accessing either the asc and ascq
fields individually, or their combination as the 16-bits sense_code field.
The helper functions scsi_sense_asc(), scsi_sense_ascq() are defined to
allow accessing the 8-bits ASC and ASCQ values from the sense_code filed
of struct scsi_sense_hdr. The helper functions scsi_failure_asc() and
scsi_failure_ascq() provide the same for the sense code field of struct
scsi_failure.
The helper functions scsi_set_sense_buffer() and scsi_set_sense() are also
added to wrap calls to scsi_build_sense_buffer() and scsi_build_sense()
using a 16-bits sense code aregument instead of the 8-bits ASC and ASCQ
arguments.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
include/scsi/scsi_cmnd.h | 7 +++++++
include/scsi/scsi_common.h | 31 +++++++++++++++++++++++++++++--
include/scsi/scsi_device.h | 25 +++++++++++++++++++++++--
3 files changed, 59 insertions(+), 4 deletions(-)
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index 8ecfb94049db..bf6d69f0249f 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -394,6 +394,13 @@ static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd)
extern void scsi_build_sense(struct scsi_cmnd *scmd, int desc,
u8 key, u8 asc, u8 ascq);
+static inline void scsi_set_sense(struct scsi_cmnd *scmd, int desc,
+ u8 key, u16 code)
+{
+ scsi_build_sense(scmd, desc, key, scsi_sense_code_asc(code),
+ scsi_sense_code_ascq(code));
+}
+
struct request *scsi_alloc_request(struct request_queue *q, blk_opf_t opf,
blk_mq_req_flags_t flags);
diff --git a/include/scsi/scsi_common.h b/include/scsi/scsi_common.h
index 00c8a16d3cd2..6fb2c290ba33 100644
--- a/include/scsi/scsi_common.h
+++ b/include/scsi/scsi_common.h
@@ -71,8 +71,18 @@ extern u64 scsilun_to_int(struct scsi_lun *);
struct scsi_sense_hdr { /* See SPC-3 section 4.5 */
u8 response_code; /* permit: 0x0, 0x70, 0x71, 0x72, 0x73 */
u8 sense_key;
- u8 asc;
- u8 ascq;
+ union {
+ struct {
+#if defined(__BIG_ENDIAN)
+ u8 asc;
+ u8 ascq;
+#elif defined(__LITTLE_ENDIAN)
+ u8 ascq;
+ u8 asc;
+#endif
+ };
+ u16 sense_code;
+ };
u8 byte4;
u8 byte5;
u8 byte6;
@@ -87,10 +97,27 @@ static inline bool scsi_sense_valid(const struct scsi_sense_hdr *sshdr)
return (sshdr->response_code & 0x70) == 0x70;
}
+static inline u8 scsi_sense_asc(const struct scsi_sense_hdr *sshdr)
+{
+ return scsi_sense_code_asc(sshdr->sense_code);
+}
+
+static inline u8 scsi_sense_ascq(const struct scsi_sense_hdr *sshdr)
+{
+ return scsi_sense_code_ascq(sshdr->sense_code);
+}
+
extern bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
struct scsi_sense_hdr *sshdr);
extern void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq);
+
+static inline void scsi_set_sense_buffer(int desc, u8 *buf, u8 key, u16 code)
+{
+ scsi_build_sense_buffer(desc, buf, key, scsi_sense_code_asc(code),
+ scsi_sense_code_ascq(code));
+}
+
int scsi_set_sense_information(u8 *buf, int buf_len, u64 info);
int scsi_set_sense_field_pointer(u8 *buf, int buf_len, u16 fp, u8 bp, bool cd);
extern const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len,
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index e321471e8ca2..11910142ac50 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -518,6 +518,7 @@ extern void scsi_sanitize_inquiry_string(unsigned char *s, int len);
* to match any sense key, ASC, and ASCQ value.
*/
#define SCMD_FAILURE_SENSE_KEY_ANY 0xff
+#define SCMD_FAILURE_SENSE_CODE_ANY 0xffff
#define SCMD_FAILURE_ASC_ANY 0xff
#define SCMD_FAILURE_ASCQ_ANY 0xff
/* Always retry a matching failure. */
@@ -526,8 +527,18 @@ extern void scsi_sanitize_inquiry_string(unsigned char *s, int len);
struct scsi_failure {
int result;
u8 sense_key;
- u8 asc;
- u8 ascq;
+ union {
+ struct {
+#if defined(__BIG_ENDIAN)
+ u8 asc;
+ u8 ascq;
+#elif defined(__LITTLE_ENDIAN)
+ u8 ascq;
+ u8 asc;
+#endif
+ };
+ u16 sense_code;
+ };
/*
* Number of times scsi_execute_cmd will retry the failure. It does
* not count for the total_allowed.
@@ -537,6 +548,16 @@ struct scsi_failure {
s8 retries;
};
+static inline u8 scsi_failure_asc(const struct scsi_failure *failure)
+{
+ return scsi_sense_code_asc(failure->sense_code);
+}
+
+static inline u8 scsi_failure_ascq(const struct scsi_failure *failure)
+{
+ return scsi_sense_code_ascq(failure->sense_code);
+}
+
struct scsi_failures {
/*
* If a scsi_failure does not have a retry limit setup this limit will
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 06/37] scsi: use struct scsi_sense_hdr to log sense keys and codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (4 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 05/37] scsi: prepare for using 16-bits defined sense codes Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 07/37] scsi: core: use 16-bits defined sense codes Damien Le Moal
` (31 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Instead of passing the sense key, additional sense code and additional
sense code qualifier as separate parameters, change the functions
scsi_extd_sense_format(), scsi_format_extd_sense(), and
usb_stor_show_sense() to take a pointer to a struct scsi_sense_hdr to
access the sense key and sense code with a single argument.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/constants.c | 11 +++++------
drivers/scsi/scsi_logging.c | 22 ++++++++++++----------
drivers/usb/storage/debug.c | 12 +++++-------
drivers/usb/storage/debug.h | 4 ++--
drivers/usb/storage/transport.c | 2 +-
include/scsi/scsi_dbg.h | 6 +++---
6 files changed, 28 insertions(+), 29 deletions(-)
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index 4b97f574fe8c..57b51c4529c3 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -377,22 +377,21 @@ EXPORT_SYMBOL(scsi_sense_key_string);
* This string may contain a "%x" and should be printed with ascq as arg.
*/
const char *
-scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
+scsi_extd_sense_format(const struct scsi_sense_hdr *sshdr, const char **fmt)
{
- u16 code = scsi_sense_code(asc, ascq);
unsigned offset = 0;
int i;
*fmt = NULL;
for (i = 0; i < ARRAY_SIZE(additional); i++) {
- if (additional[i].code == code)
+ if (additional[i].code == sshdr->sense_code)
return additional_text + offset;
offset += additional[i].size;
}
for (i = 0; additional2[i].fmt; i++) {
- if (additional2[i].asc == asc &&
- ascq >= additional2[i].ascq_min &&
- ascq <= additional2[i].ascq_max) {
+ if (additional2[i].asc == scsi_sense_asc(sshdr) &&
+ scsi_sense_ascq(sshdr) >= additional2[i].ascq_min &&
+ scsi_sense_ascq(sshdr) <= additional2[i].ascq_max) {
*fmt = additional2[i].fmt;
return additional2[i].str;
}
diff --git a/drivers/scsi/scsi_logging.c b/drivers/scsi/scsi_logging.c
index 3cd0d3074085..0a9a2f7c1966 100644
--- a/drivers/scsi/scsi_logging.c
+++ b/drivers/scsi/scsi_logging.c
@@ -238,29 +238,32 @@ EXPORT_SYMBOL(scsi_print_command);
static size_t
scsi_format_extd_sense(char *buffer, size_t buf_len,
- unsigned char asc, unsigned char ascq)
+ const struct scsi_sense_hdr *sshdr)
{
size_t off = 0;
const char *extd_sense_fmt = NULL;
- const char *extd_sense_str = scsi_extd_sense_format(asc, ascq,
- &extd_sense_fmt);
+ const char *extd_sense_str =
+ scsi_extd_sense_format(sshdr, &extd_sense_fmt);
if (extd_sense_str) {
off = scnprintf(buffer, buf_len, "Add. Sense: %s",
extd_sense_str);
if (extd_sense_fmt)
off += scnprintf(buffer + off, buf_len - off,
- "(%s%x)", extd_sense_fmt, ascq);
+ "(%s%x)", extd_sense_fmt,
+ scsi_sense_ascq(sshdr));
} else {
- if (asc >= 0x80)
+ if (scsi_sense_asc(sshdr) >= 0x80)
off = scnprintf(buffer, buf_len, "<<vendor>>");
off += scnprintf(buffer + off, buf_len - off,
- "ASC=0x%x ", asc);
- if (ascq >= 0x80)
+ "ASC=0x%x ",
+ scsi_sense_asc(sshdr));
+ if (scsi_sense_ascq(sshdr) >= 0x80)
off += scnprintf(buffer + off, buf_len - off,
"<<vendor>>");
off += scnprintf(buffer + off, buf_len - off,
- "ASCQ=0x%x ", ascq);
+ "ASCQ=0x%x ",
+ scsi_sense_ascq(sshdr));
}
return off;
}
@@ -333,8 +336,7 @@ scsi_log_print_sense_hdr(const struct scsi_device *sdev, const char *name,
if (!logbuf)
return;
off = sdev_format_header(logbuf, logbuf_len, name, tag);
- off += scsi_format_extd_sense(logbuf + off, logbuf_len - off,
- sshdr->asc, sshdr->ascq);
+ off += scsi_format_extd_sense(logbuf + off, logbuf_len - off, sshdr);
dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf);
scsi_log_release_buffer(logbuf);
}
diff --git a/drivers/usb/storage/debug.c b/drivers/usb/storage/debug.c
index dda610f689b7..4cc5a019382a 100644
--- a/drivers/usb/storage/debug.c
+++ b/drivers/usb/storage/debug.c
@@ -140,15 +140,12 @@ void usb_stor_show_command(const struct us_data *us, struct scsi_cmnd *srb)
(const unsigned char *)srb->cmnd);
}
-void usb_stor_show_sense(const struct us_data *us,
- unsigned char key,
- unsigned char asc,
- unsigned char ascq)
+void usb_stor_show_sense(const struct us_data *us, struct scsi_sense_hdr *sshdr)
{
const char *what, *keystr, *fmt;
- keystr = scsi_sense_key_string(key);
- what = scsi_extd_sense_format(asc, ascq, &fmt);
+ keystr = scsi_sense_key_string(sshdr->sense_key);
+ what = scsi_extd_sense_format(sshdr, &fmt);
if (keystr == NULL)
keystr = "(Unknown Key)";
@@ -156,7 +153,8 @@ void usb_stor_show_sense(const struct us_data *us,
what = "(unknown ASC/ASCQ)";
if (fmt)
- usb_stor_dbg(us, "%s: %s (%s%x)\n", keystr, what, fmt, ascq);
+ usb_stor_dbg(us, "%s: %s (%s%x)\n", keystr, what, fmt,
+ scsi_sense_ascq(sshdr));
else
usb_stor_dbg(us, "%s: %s\n", keystr, what);
}
diff --git a/drivers/usb/storage/debug.h b/drivers/usb/storage/debug.h
index a6505ceb6693..616e518eeb21 100644
--- a/drivers/usb/storage/debug.h
+++ b/drivers/usb/storage/debug.h
@@ -31,8 +31,8 @@
#ifdef CONFIG_USB_STORAGE_DEBUG
void usb_stor_show_command(const struct us_data *us, struct scsi_cmnd *srb);
-void usb_stor_show_sense(const struct us_data *us, unsigned char key,
- unsigned char asc, unsigned char ascq);
+void usb_stor_show_sense(const struct us_data *us,
+ struct scsi_sense_hdr *sshdr);
__printf(2, 3) void usb_stor_dbg(const struct us_data *us,
const char *fmt, ...);
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 9a4bf86e7b6a..8e9359501d88 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -805,7 +805,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
sshdr.response_code, sshdr.sense_key,
sshdr.asc, sshdr.ascq);
#ifdef CONFIG_USB_STORAGE_DEBUG
- usb_stor_show_sense(us, sshdr.sense_key, sshdr.asc, sshdr.ascq);
+ usb_stor_show_sense(us, &sshdr);
#endif
/* set the result so the higher layers expect this data */
diff --git a/include/scsi/scsi_dbg.h b/include/scsi/scsi_dbg.h
index efcdc78530d5..f21a5e3caca9 100644
--- a/include/scsi/scsi_dbg.h
+++ b/include/scsi/scsi_dbg.h
@@ -20,8 +20,8 @@ extern void scsi_print_result(struct scsi_cmnd *, const char *, int);
#ifdef CONFIG_SCSI_CONSTANTS
extern bool scsi_opcode_sa_name(int, int, const char **, const char **);
extern const char *scsi_sense_key_string(unsigned char);
-extern const char *scsi_extd_sense_format(unsigned char, unsigned char,
- const char **);
+extern const char *scsi_extd_sense_format(const struct scsi_sense_hdr *sshdr,
+ const char **fmt);
extern const char *scsi_mlreturn_string(int);
extern const char *scsi_hostbyte_string(int);
#else
@@ -57,7 +57,7 @@ scsi_sense_key_string(unsigned char key)
}
static inline const char *
-scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
+scsi_extd_sense_format(const struct scsi_sense_hdr *sshdr, const char **fmt)
{
*fmt = NULL;
return NULL;
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 07/37] scsi: core: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (5 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 06/37] scsi: use struct scsi_sense_hdr to log sense keys and codes Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:18 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 08/37] scsi: sd: " Damien Le Moal
` (30 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the SCSI core code to use the 16-bits sense_code field of
struct scsi_sense_hdr and struct scsi_failure and replace all hard-coded
additional sense codes and additional sense code qualifiers with the enum
values defined in include/scsi/scsi_sense.h. This helps with code clarity
as the sense codes being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/constants.c | 38 ++++++++--
drivers/scsi/scsi.c | 3 +-
drivers/scsi/scsi_common.c | 12 ++--
drivers/scsi/scsi_error.c | 94 ++++++++++++++----------
drivers/scsi/scsi_ioctl.c | 3 +-
drivers/scsi/scsi_lib.c | 116 ++++++++++++++++--------------
drivers/scsi/scsi_lib_test.c | 33 +++++----
drivers/scsi/scsi_scan.c | 14 ++--
drivers/scsi/scsi_transport_spi.c | 10 ++-
include/trace/events/scsi.h | 4 +-
10 files changed, 194 insertions(+), 133 deletions(-)
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index 57b51c4529c3..767631835c81 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -327,13 +327,37 @@ struct error_info2 {
static const struct error_info2 additional2[] =
{
- {0x40, 0x00, 0x7f, "Ram failure", ""},
- {0x40, 0x80, 0xff, "Diagnostic failure on component", ""},
- {0x41, 0x00, 0xff, "Data path failure", ""},
- {0x42, 0x00, 0xff, "Power-on or self-test failure", ""},
- {0x4D, 0x00, 0xff, "Tagged overlapped commands", "task tag "},
- {0x70, 0x00, 0xff, "Decompression exception", "short algorithm id of "},
- {0, 0, 0, NULL, NULL}
+ {
+ ASC_RAM_FAILURE,
+ 0x00, 0x7f,
+ "Ram failure", ""
+ },
+ {
+ ASC_RAM_FAILURE,
+ 0x80, 0xff,
+ "Diagnostic failure on component", ""
+ },
+ {
+ ASC_DATA_PATH_FAILURE,
+ 0x00, 0xff,
+ "Data path failure", ""
+ },
+ {
+ ASC_POWER_ON_OR_SELFTEST_FAILURE,
+ 0x00, 0xff,
+ "Power-on or self-test failure", ""
+ },
+ {
+ ASC_TAGGED_OVERLAPPED_COMMANDS,
+ 0x00, 0xff,
+ "Tagged overlapped commands", "task tag "
+ },
+ {
+ ASC_DECOMPRESSION_EXCEPTION_SHORT_ALGORITHM_ID,
+ 0x00, 0xff,
+ "Decompression exception", "short algorithm id of "
+ },
+ { 0, 0, 0, NULL, NULL }
};
/* description of the sense key values */
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 76cdad063f7b..ff1367aaa3e6 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -606,7 +606,8 @@ int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
return result;
if (result && scsi_sense_valid(&sshdr) &&
sshdr.sense_key == ILLEGAL_REQUEST &&
- (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
+ (sshdr.sense_code == INVALID_COMMAND_OP_CODE ||
+ sshdr.sense_code == INVALID_FIELD_IN_CDB))
return -EINVAL;
if ((buffer[1] & 3) == 3) /* Command supported */
diff --git a/drivers/scsi/scsi_common.c b/drivers/scsi/scsi_common.c
index e1a2a62b6910..2cabc932acd4 100644
--- a/drivers/scsi/scsi_common.c
+++ b/drivers/scsi/scsi_common.c
@@ -191,6 +191,8 @@ EXPORT_SYMBOL(int_to_scsilun);
bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
struct scsi_sense_hdr *sshdr)
{
+ u8 asc = 0, ascq = 0;
+
memset(sshdr, 0, sizeof(struct scsi_sense_hdr));
if (!sense_buffer || !sb_len)
@@ -208,9 +210,9 @@ bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
if (sb_len > 1)
sshdr->sense_key = (sense_buffer[1] & 0xf);
if (sb_len > 2)
- sshdr->asc = sense_buffer[2];
+ asc = sense_buffer[2];
if (sb_len > 3)
- sshdr->ascq = sense_buffer[3];
+ ascq = sense_buffer[3];
if (sb_len > 7)
sshdr->additional_length = sense_buffer[7];
} else {
@@ -222,12 +224,14 @@ bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
if (sb_len > 7) {
sb_len = min(sb_len, sense_buffer[7] + 8);
if (sb_len > 12)
- sshdr->asc = sense_buffer[12];
+ asc = sense_buffer[12];
if (sb_len > 13)
- sshdr->ascq = sense_buffer[13];
+ ascq = sense_buffer[13];
}
}
+ sshdr->sense_code = scsi_sense_code(asc, ascq);
+
return true;
}
EXPORT_SYMBOL(scsi_normalize_sense);
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index b729407348f7..2b1698600660 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -490,24 +490,27 @@ static void scsi_report_sense(struct scsi_device *sdev,
enum scsi_device_event evt_type = SDEV_EVT_MAXBITS; /* i.e. none */
if (sshdr->sense_key == UNIT_ATTENTION) {
- if (sshdr->asc == 0x3f && sshdr->ascq == 0x03) {
+ if (sshdr->sense_code == INQUIRY_DATA_HAS_CHANGED) {
evt_type = SDEV_EVT_INQUIRY_CHANGE_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Inquiry data has changed");
- } else if (sshdr->asc == 0x3f && sshdr->ascq == 0x0e) {
+ } else if (sshdr->sense_code == REPORTED_LUNS_DATA_HAS_CHANGED) {
evt_type = SDEV_EVT_LUN_CHANGE_REPORTED;
scsi_report_lun_change(sdev);
sdev_printk(KERN_WARNING, sdev,
"LUN assignments on this target have "
"changed. The Linux SCSI layer does not "
"automatically remap LUN assignments.\n");
- } else if (sshdr->asc == 0x3f)
+ } else if (scsi_sense_asc(sshdr) ==
+ ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED) {
sdev_printk(KERN_WARNING, sdev,
"Operating parameters on this target have "
"changed. The Linux SCSI layer does not "
"automatically adjust these parameters.\n");
+ }
- if (sshdr->asc == 0x38 && sshdr->ascq == 0x07) {
+ if (sshdr->sense_code ==
+ THIN_PROVISIONING_SOFT_THRESHOLD_REACHED) {
evt_type = SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Warning! Received an indication that the "
@@ -515,7 +518,8 @@ static void scsi_report_sense(struct scsi_device *sdev,
"threshold.\n");
}
- if (sshdr->asc == 0x29) {
+ if (scsi_sense_asc(sshdr) ==
+ ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED) {
evt_type = SDEV_EVT_POWER_ON_RESET_OCCURRED;
/*
* Do not print message if it is an expected side-effect
@@ -526,21 +530,22 @@ static void scsi_report_sense(struct scsi_device *sdev,
"Power-on or device reset occurred\n");
}
- if (sshdr->asc == 0x2a && sshdr->ascq == 0x01) {
+ if (sshdr->sense_code == MODE_PARAMETERS_CHANGED) {
evt_type = SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Mode parameters changed");
- } else if (sshdr->asc == 0x2a && sshdr->ascq == 0x06) {
+ } else if (sshdr->sense_code == ASYMMETRIC_ACCESS_STATE_CHANGED) {
evt_type = SDEV_EVT_ALUA_STATE_CHANGE_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Asymmetric access state changed");
- } else if (sshdr->asc == 0x2a && sshdr->ascq == 0x09) {
+ } else if (sshdr->sense_code == CAPACITY_DATA_HAS_CHANGED) {
evt_type = SDEV_EVT_CAPACITY_CHANGE_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Capacity data has changed");
- } else if (sshdr->asc == 0x2a)
+ } else if (scsi_sense_asc(sshdr) == ASC_PARAMETERS_CHANGED) {
sdev_printk(KERN_WARNING, sdev,
"Parameters changed");
+ }
}
if (evt_type != SDEV_EVT_MAXBITS) {
@@ -582,9 +587,11 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
* that all ULDs interested in these can see that those have
* happened, even if someone else gets the sense data.
*/
- if (sshdr.asc == 0x28)
+ if (scsi_sense_asc(&sshdr) ==
+ ASC_NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED)
atomic_inc(&sdev->ua_new_media_ctr);
- else if (sshdr.asc == 0x29)
+ else if (scsi_sense_asc(&sshdr) ==
+ ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
atomic_inc(&sdev->ua_por_ctr);
}
@@ -636,7 +643,8 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
return /* soft_error */ SUCCESS;
case ABORTED_COMMAND:
- if (sshdr.asc == 0x10) /* DIF */
+ if (scsi_sense_asc(&sshdr) == ASC_ID_CRC_OR_ECC_ERROR)
+ /* DIF */
return SUCCESS;
/*
@@ -647,18 +655,20 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
* COMMAND TIMEOUT DURING PROCESSING DUE TO ERROR RECOVERY
* additional sense code qualifiers.
*/
- if (sshdr.asc == 0x2e &&
- sshdr.ascq >= 0x01 && sshdr.ascq <= 0x03) {
+ if (sshdr.sense_code >= COMMAND_TIMEOUT_BEFORE_PROCESSING &&
+ sshdr.sense_code <=
+ COMMAND_TIMEOUT_DURING_PROCESSING_DUE_TO_ERROR_RECOVERY) {
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 ((sdev->sdev_bflags & BLIST_RETRY_ITF) &&
+ scsi_sense_asc(&sshdr) == ASC_INTERNAL_TARGET_FAILURE)
return ADD_TO_MLQUEUE;
- if (sshdr.asc == 0xc1 && sshdr.ascq == 0x01 &&
- sdev->sdev_bflags & BLIST_RETRY_ASC_C1)
+ if ((sdev->sdev_bflags & BLIST_RETRY_ASC_C1) &&
+ sshdr.sense_code == scsi_sense_code(0xc1, 0x01))
return ADD_TO_MLQUEUE;
return NEEDS_RETRY;
@@ -672,12 +682,13 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
*/
if (scmd->device->expecting_cc_ua) {
/*
- * Because some device does not queue unit
- * attentions correctly, we carefully check
- * additional sense code and qualifier so as
- * not to squash media change unit attention.
+ * Because some devices do not queue unit attentions
+ * correctly, we carefully check additional sense code
+ * and qualifier so as not to squash media change unit
+ * attention.
*/
- if (sshdr.asc != 0x28 || sshdr.ascq != 0x00) {
+ if (sshdr.sense_code !=
+ NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED) {
scmd->device->expecting_cc_ua = 0;
return NEEDS_RETRY;
}
@@ -688,21 +699,23 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
* REPORTED LUNS DATA HAS CHANGED.
*/
if (scmd->device->sdev_target->expecting_lun_change &&
- sshdr.asc == 0x3f && sshdr.ascq == 0x0e)
+ sshdr.sense_code == REPORTED_LUNS_DATA_HAS_CHANGED)
return NEEDS_RETRY;
/*
* if the device is in the process of becoming ready, we
* should retry.
*/
- if ((sshdr.asc == 0x04) &&
- (sshdr.ascq == 0x01 || sshdr.ascq == 0x0a))
+ if (sshdr.sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY ||
+ sshdr.sense_code ==
+ LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION)
return NEEDS_RETRY;
/*
* if the device is not started, we need to wake
* the error handler to start the motor
*/
if (scmd->device->allow_restart &&
- (sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
+ sshdr.sense_code ==
+ LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)
return FAILED;
/*
* Pass the UA upwards for a determination in the completion
@@ -712,7 +725,7 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
/* these are not supported */
case DATA_PROTECT:
- if (sshdr.asc == 0x27 && sshdr.ascq == 0x07) {
+ if (sshdr.sense_code == SPACE_ALLOCATION_FAILED_WRITE_PROTECT) {
/* Thin provisioning hard threshold reached */
set_scsi_ml_byte(scmd, SCSIML_STAT_NOSPC);
return SUCCESS;
@@ -726,11 +739,14 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
return SUCCESS;
case MEDIUM_ERROR:
- if (sshdr.asc == 0x11 || /* UNRECOVERED READ ERR */
- sshdr.asc == 0x13 || /* AMNF DATA FIELD */
- sshdr.asc == 0x14) { /* RECORD NOT FOUND */
+ switch (scsi_sense_asc(&sshdr)) {
+ case ASC_UNRECOVERED_READ_ERROR:
+ case ASC_ADDRESS_MARK_NOT_FOUND_FOR_DATA_FIELD:
+ case ASC_RECORDED_ENTITY_NOT_FOUND:
set_scsi_ml_byte(scmd, SCSIML_STAT_MED_ERROR);
return SUCCESS;
+ default:
+ break;
}
return NEEDS_RETRY;
@@ -742,13 +758,17 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
fallthrough;
case ILLEGAL_REQUEST:
- if (sshdr.asc == 0x20 || /* Invalid command operation code */
- sshdr.asc == 0x21 || /* Logical block address out of range */
- sshdr.asc == 0x22 || /* Invalid function */
- sshdr.asc == 0x24 || /* Invalid field in cdb */
- sshdr.asc == 0x26 || /* Parameter value invalid */
- sshdr.asc == 0x27) { /* Write protected */
+ switch (scsi_sense_asc(&sshdr)) {
+ case ASC_INVALID_COMMAND_OP_CODE:
+ case ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE:
+ case ASC_ILLEGAL_FUNCTION:
+ case ASC_INVALID_FIELD_IN_CDB:
+ case ASC_INVALID_FIELD_IN_PARAMETER_LIST:
+ case ASC_WRITE_PROTECTED:
set_scsi_ml_byte(scmd, SCSIML_STAT_TGT_FAILURE);
+ break;
+ default:
+ break;
}
return SUCCESS;
@@ -760,7 +780,7 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
* that the command was in fact aborted because it exceeded its
* duration limit. Never retry these commands.
*/
- if (sshdr.asc == 0x55 && sshdr.ascq == 0x0a) {
+ if (sshdr.sense_code == DATA_CURRENTLY_UNAVAILABLE) {
set_scsi_ml_byte(scmd, SCSIML_STAT_DL_TIMEOUT);
req->cmd_flags |= REQ_FAILFAST_DEV;
req->rq_flags |= RQF_QUIET;
diff --git a/drivers/scsi/scsi_ioctl.c b/drivers/scsi/scsi_ioctl.c
index c14f81403a09..122403ec3ab8 100644
--- a/drivers/scsi/scsi_ioctl.c
+++ b/drivers/scsi/scsi_ioctl.c
@@ -96,7 +96,8 @@ static int ioctl_internal_command(struct scsi_device *sdev, char *cmd,
"ioctl_internal_command: "
"ILLEGAL REQUEST "
"asc=0x%x ascq=0x%x\n",
- sshdr.asc, sshdr.ascq);
+ scsi_sense_asc(&sshdr),
+ scsi_sense_ascq(&sshdr));
break;
case NOT_READY: /* This happens if there is no disc in drive */
if (sdev->removable)
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 4901b2dff653..b58e028a362e 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -252,14 +252,14 @@ static int scsi_check_passthrough(struct scsi_cmnd *scmd,
if (failure->sense_key != sshdr.sense_key)
continue;
- if (failure->asc == SCMD_FAILURE_ASC_ANY)
+ if (scsi_failure_asc(failure) == SCMD_FAILURE_ASC_ANY)
goto maybe_retry;
- if (failure->asc != sshdr.asc)
+ if (scsi_failure_asc(failure) != scsi_sense_asc(&sshdr))
continue;
- if (failure->ascq == SCMD_FAILURE_ASCQ_ANY ||
- failure->ascq == sshdr.ascq)
+ if (scsi_failure_ascq(failure) == SCMD_FAILURE_ASCQ_ANY ||
+ scsi_failure_ascq(failure) == scsi_sense_ascq(&sshdr))
goto maybe_retry;
}
@@ -839,6 +839,8 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
*/
action = ACTION_RETRY;
} else if (sense_valid && sense_current) {
+ u8 asc = scsi_sense_asc(&sshdr);
+
switch (sshdr.sense_key) {
case UNIT_ATTENTION:
if (cmd->device->removable) {
@@ -865,64 +867,72 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
* where READ CAPACITY failed, we may have
* read past the end of the disk.
*/
- if ((cmd->device->use_10_for_rw &&
- sshdr.asc == 0x20 && sshdr.ascq == 0x00) &&
+ if (cmd->device->use_10_for_rw &&
+ sshdr.sense_code == INVALID_COMMAND_OP_CODE &&
(cmd->cmnd[0] == READ_10 ||
cmd->cmnd[0] == WRITE_10)) {
/* This will issue a new 6-byte command. */
cmd->device->use_10_for_rw = 0;
action = ACTION_REPREP;
- } else if (sshdr.asc == 0x10) /* DIX */ {
+ break;
+ }
+ if (asc == ASC_ID_CRC_OR_ECC_ERROR) {
+ /* DIX */
action = ACTION_FAIL;
blk_stat = BLK_STS_PROTECTION;
- /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
- } else if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
+ break;
+ }
+ if (asc == ASC_INVALID_COMMAND_OP_CODE ||
+ asc == ASC_INVALID_FIELD_IN_CDB) {
action = ACTION_FAIL;
blk_stat = BLK_STS_TARGET;
- } else
- action = ACTION_FAIL;
+ break;
+ }
+ action = ACTION_FAIL;
break;
case ABORTED_COMMAND:
action = ACTION_FAIL;
- if (sshdr.asc == 0x10) /* DIF */
+ if (asc == ASC_ID_CRC_OR_ECC_ERROR) /* DIF */
blk_stat = BLK_STS_PROTECTION;
break;
case NOT_READY:
/* If the device is in the process of becoming
* ready, or has a temporary blockage, retry.
*/
- if (sshdr.asc == 0x04) {
- switch (sshdr.ascq) {
- case 0x01: /* becoming ready */
- case 0x04: /* format in progress */
- case 0x05: /* rebuild in progress */
- case 0x06: /* recalculation in progress */
- case 0x07: /* operation in progress */
- case 0x08: /* Long write in progress */
- case 0x09: /* self test in progress */
- case 0x11: /* notify (enable spinup) required */
- case 0x14: /* space allocation in progress */
- case 0x1a: /* start stop unit in progress */
- case 0x1b: /* sanitize in progress */
- case 0x1d: /* configuration in progress */
- action = ACTION_DELAYED_RETRY;
- break;
- case 0x0a: /* ALUA state transition */
- action = ACTION_DELAYED_REPREP;
- break;
- /*
- * Depopulation might take many hours,
- * thus it is not worthwhile to retry.
- */
- case 0x24: /* depopulation in progress */
- case 0x25: /* depopulation restore in progress */
- fallthrough;
- default:
- action = ACTION_FAIL;
- break;
- }
- } else
+ if (asc != ASC_LU_NOT_READY) {
action = ACTION_FAIL;
+ break;
+ }
+
+ switch (sshdr.sense_code) {
+ case LU_IS_IN_PROCESS_OF_BECOMING_READY:
+ case LU_NOT_READY_FORMAT_IN_PROGRESS:
+ case LU_NOT_READY_REBUILD_IN_PROGRESS:
+ case LU_NOT_READY_RECALCULATION_IN_PROGRESS:
+ case LU_NOT_READY_OP_IN_PROGRESS:
+ case LU_NOT_READY_LONG_WRITE_IN_PROGRESS:
+ case LU_NOT_READY_SELFTEST_IN_PROGRESS:
+ case LU_NOT_READY_NOTIFY_REQUIRED:
+ case LU_NOT_READY_SPACE_ALLOCATION_IN_PROGRESS:
+ case LU_NOT_READY_START_STOP_UNIT_COMMAND_IN_PROGRESS:
+ case LU_NOT_READY_SANITIZE_IN_PROGRESS:
+ case LU_NOT_READY_CONFIG_IN_PROGRESS:
+ action = ACTION_DELAYED_RETRY;
+ break;
+ case LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION:
+ action = ACTION_DELAYED_REPREP;
+ break;
+ /*
+ * Depopulation might take many hours, thus it is not
+ * worthwhile to retry.
+ */
+ case DEPOPULATION_IN_PROGRESS:
+ case DEPOPULATION_RESTORATION_IN_PROGRESS:
+ fallthrough;
+ default:
+ action = ACTION_FAIL;
+ break;
+ }
break;
case VOLUME_OVERFLOW:
/* See SSC3rXX or current. */
@@ -930,11 +940,14 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
break;
case DATA_PROTECT:
action = ACTION_FAIL;
- if ((sshdr.asc == 0x0C && sshdr.ascq == 0x12) ||
- (sshdr.asc == 0x55 &&
- (sshdr.ascq == 0x0E || sshdr.ascq == 0x0F))) {
- /* Insufficient zone resources */
+ switch (sshdr.sense_code) {
+ case WRITE_ERROR_INSUFFICIENT_ZONE_RESOURCES:
+ case INSUFFICIENT_ZONE_RESOURCES:
+ case INSUFFICIENT_ZONE_RESOURCES_TO_COMPLETE_WRITE:
blk_stat = BLK_STS_ZONE_OPEN_RESOURCE;
+ break;
+ default:
+ break;
}
break;
case COMPLETED:
@@ -1041,7 +1054,7 @@ static int scsi_io_completion_nz_result(struct scsi_cmnd *cmd, int result,
* skip print since caller wants ATA registers. Only occurs
* on SCSI ATA PASS_THROUGH commands when CK_COND=1
*/
- if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
+ if (sshdr.sense_code == ATA_PASS_THROUGH_INFORMATION_AVAILABLE)
do_print = false;
else if (req->rq_flags & RQF_QUIET)
do_print = false;
@@ -2373,8 +2386,7 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, int subpage,
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = retries,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -2432,8 +2444,8 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, int subpage,
if (!scsi_status_is_good(result)) {
if (scsi_sense_valid(sshdr)) {
- if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
- (sshdr->asc == 0x20) && (sshdr->ascq == 0)) {
+ if (sshdr->sense_key == ILLEGAL_REQUEST &&
+ sshdr->sense_code == INVALID_COMMAND_OP_CODE) {
/*
* Invalid command operation code: retry using
* MODE SENSE(6) if this was a MODE SENSE(10)
diff --git a/drivers/scsi/scsi_lib_test.c b/drivers/scsi/scsi_lib_test.c
index 4558dc853e26..016ed6ff1ea6 100644
--- a/drivers/scsi/scsi_lib_test.c
+++ b/drivers/scsi/scsi_lib_test.c
@@ -18,41 +18,42 @@ static void scsi_lib_test_multiple_sense(struct kunit *test)
struct scsi_failure multiple_sense_failure_defs[] = {
{
.sense_key = DATA_PROTECT,
- .asc = 0x1,
- .ascq = 0x1,
+ .sense_code =
+ scsi_sense_code(ASC_NO_INDEX_SECTOR_SIGNAL,
+ 0x1),
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x11,
- .ascq = 0x0,
+ .sense_code = UNRECOVERED_READ_ERROR,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = NOT_READY,
- .asc = 0x11,
- .ascq = 0x22,
+ .sense_code =
+ scsi_sense_code(ASC_UNRECOVERED_READ_ERROR,
+ 0x22),
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = ABORTED_COMMAND,
- .asc = 0x11,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code =
+ scsi_sense_code(ASC_UNRECOVERED_READ_ERROR,
+ SCMD_FAILURE_ASCQ_ANY),
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = HARDWARE_ERROR,
- .asc = SCMD_FAILURE_ASC_ANY,
+ .sense_code = scsi_sense_code(SCMD_FAILURE_ASC_ANY, 0),
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = ILLEGAL_REQUEST,
- .asc = 0x91,
- .ascq = 0x36,
+ .sense_code = scsi_sense_code(0x91, 0x36),
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -217,8 +218,8 @@ static void scsi_lib_test_total_allowed(struct kunit *test)
struct scsi_failure total_allowed_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = scsi_sense_code(SCMD_FAILURE_ASC_ANY,
+ SCMD_FAILURE_ASCQ_ANY),
.result = SAM_STAT_CHECK_CONDITION,
},
/* Fail all CCs except the UA above */
@@ -261,12 +262,14 @@ static void scsi_lib_test_mixed_total(struct kunit *test)
struct scsi_failure mixed_total_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x28,
+ .sense_code =
+ NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x29,
+ .sense_code =
+ POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 003ab639e76d..10721f7093ee 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -652,19 +652,18 @@ static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
int pass, count, result, resid;
struct scsi_failure failure_defs[] = {
/*
- * not-ready to ready transition [asc/ascq=0x28/0x0] or
- * power-on, reset [asc/ascq=0x29/0x0], continue. INQUIRY
- * should not yield UNIT_ATTENTION but many buggy devices do
- * so anyway.
+ * not-ready to ready transition or power-on, reset, continue.
+ * INQUIRY should not yield UNIT_ATTENTION but many buggy
+ * devices do so anyway.
*/
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x28,
+ .sense_code = NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x29,
+ .sense_code = POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
@@ -1458,8 +1457,7 @@ static int scsi_report_lun_scan(struct Scsi_Host *shost,
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Fail all CCs except the UA above */
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index ec3884a6657f..bd049d549244 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -113,8 +113,7 @@ static int spi_execute(struct scsi_device *sdev, const void *cmd,
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = DV_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -680,10 +679,9 @@ spi_dv_device_echo_buffer(struct scsi_device *sdev, u8 *buffer,
if (result || !scsi_device_online(sdev)) {
scsi_device_set_state(sdev, SDEV_QUIESCE);
- if (result > 0 && scsi_sense_valid(&sshdr)
- && sshdr.sense_key == ILLEGAL_REQUEST
- /* INVALID FIELD IN CDB */
- && sshdr.asc == 0x24 && sshdr.ascq == 0x00)
+ if (result > 0 && scsi_sense_valid(&sshdr) &&
+ sshdr.sense_key == ILLEGAL_REQUEST &&
+ sshdr.sense_code == INVALID_FIELD_IN_CDB)
/* This would mean that the drive lied
* to us about supporting an echo
* buffer (unfortunately some Western
diff --git a/include/trace/events/scsi.h b/include/trace/events/scsi.h
index c36c72ab7f2b..4d17c9b61e44 100644
--- a/include/trace/events/scsi.h
+++ b/include/trace/events/scsi.h
@@ -303,8 +303,8 @@ DECLARE_EVENT_CLASS(scsi_cmd_done_timeout_template,
if (cmd->sense_buffer && SCSI_SENSE_VALID(cmd) &&
scsi_command_normalize_sense(cmd, &sshdr)) {
__entry->sense_key = sshdr.sense_key;
- __entry->asc = sshdr.asc;
- __entry->ascq = sshdr.ascq;
+ __entry->asc = scsi_sense_asc(&sshdr);
+ __entry->ascq = scsi_sense_asc(&sshdr);
} else {
__entry->sense_key = 0;
__entry->asc = 0;
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 07/37] scsi: core: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 07/37] scsi: core: use 16-bits defined sense codes Damien Le Moal
@ 2026-08-31 2:18 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:18 UTC (permalink / raw)
To: Damien Le Moal; +Cc: cassel, dlemoal, linux-ide, linux-scsi
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The `scsi_cmd_done_timeout_template` trace event incorrectly assigns the ASC value to the ASCQ field, causing a loss of ASCQ trace data.
--
commit 18b8d3cbe68a6be05817a223fa4182ba612faa08
Author: Damien Le Moal <dlemoal@kernel.org>
Subject: scsi: core: use 16-bits defined sense codes
This commit refactors the SCSI core code to use the 16-bit sense_code field
of struct scsi_sense_hdr and struct scsi_failure. Hard-coded additional sense
codes and qualifiers are replaced with enum values from scsi_sense.h to
improve clarity.
> diff --git a/include/trace/events/scsi.h b/include/trace/events/scsi.h
> index c36c72ab7f2bf..4d17c9b61e44a 100644
> --- a/include/trace/events/scsi.h
> +++ b/include/trace/events/scsi.h
> @@ -303,8 +303,8 @@ DECLARE_EVENT_CLASS(scsi_cmd_done_timeout_template,
> if (cmd->sense_buffer && SCSI_SENSE_VALID(cmd) &&
> scsi_command_normalize_sense(cmd, &sshdr)) {
> __entry->sense_key = sshdr.sense_key;
> - __entry->asc = sshdr.asc;
> - __entry->ascq = sshdr.ascq;
> + __entry->asc = scsi_sense_asc(&sshdr);
> + __entry->ascq = scsi_sense_asc(&sshdr);
^^^^^^^^^^^^^^
[Severity: Medium]
Does this code assign the wrong value to the ascq field?
It looks like scsi_sense_asc() is called instead of scsi_sense_ascq(),
which would cause the trace event to duplicate the asc byte and lose
the actual ascq trace data when a SCSI command completes or times out
with valid sense data.
> } else {
> __entry->sense_key = 0;
> __entry->asc = 0;
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=7
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 08/37] scsi: sd: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (6 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 07/37] scsi: core: use 16-bits defined sense codes Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 09/37] scsi: sr: " Damien Le Moal
` (29 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the SCSI disk driver to use as much as possible the 16-bits
sense_code field of struct scsi_sense_hdr and struct scsi_failure and
replace all hard-coded additional sense codes and additional sense code
qualifiers with the enum values defined in include/scsi/scsi_sense.h. This
helps with code clarity as the sense codes being processed are easier to
test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/sd.c | 106 +++++++++++++++++++++---------------------
drivers/scsi/sd_zbc.c | 2 +-
2 files changed, 53 insertions(+), 55 deletions(-)
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index fecb001115ab..b0d2542fd317 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1786,8 +1786,7 @@ static int media_not_present(struct scsi_disk *sdkp,
switch (sshdr->sense_key) {
case UNIT_ATTENTION:
case NOT_READY:
- /* medium not present */
- if (sshdr->asc == 0x3A) {
+ if (scsi_sense_asc(sshdr) == ASC_MEDIUM_NOT_PRESENT) {
set_media_not_present(sdkp);
return 1;
}
@@ -1911,12 +1910,14 @@ static int sd_sync_cache(struct scsi_disk *sdkp)
if (scsi_status_is_check_condition(res) &&
scsi_sense_valid(&sshdr)) {
+ u8 asc = scsi_sense_asc(&sshdr);
+
sd_print_sense_hdr(sdkp, &sshdr);
/* we need to evaluate the error return */
- if (sshdr.asc == 0x3a || /* medium not present */
- sshdr.asc == 0x20 || /* invalid command */
- (sshdr.asc == 0x74 && sshdr.ascq == 0x71)) /* drive is password locked */
+ if (asc == ASC_MEDIUM_NOT_PRESENT ||
+ asc == ASC_INVALID_COMMAND_OP_CODE ||
+ sshdr.sense_code == LU_ACCESS_NOT_AUTHORIZED)
/* this is no error here */
return 0;
@@ -1926,8 +1927,8 @@ static int sd_sync_cache(struct scsi_disk *sdkp)
* this is called during shutdown or suspend so just
* return success so those operations can proceed.
*/
- if ((sshdr.asc == 0x04 && sshdr.ascq == 0x04) ||
- sshdr.sense_key == ILLEGAL_REQUEST)
+ if (sshdr.sense_key == ILLEGAL_REQUEST ||
+ sshdr.sense_code == LU_NOT_READY_FORMAT_IN_PROGRESS)
return 0;
}
@@ -2015,7 +2016,9 @@ static int sd_scsi_to_pr_err(struct scsi_sense_hdr *sshdr, int result)
return PR_STS_IOERR;
if (sshdr->sense_key == ILLEGAL_REQUEST &&
- (sshdr->asc == 0x26 || sshdr->asc == 0x24))
+ (scsi_sense_asc(sshdr) ==
+ ASC_INVALID_FIELD_IN_PARAMETER_LIST ||
+ scsi_sense_asc(sshdr) == ASC_INVALID_FIELD_IN_CDB))
return -EINVAL;
fallthrough;
@@ -2034,8 +2037,7 @@ static int sd_pr_in_command(struct block_device *bdev, u8 sa,
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = 5,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -2146,8 +2148,7 @@ static int sd_pr_out_command(struct block_device *bdev, u8 sa, u64 key,
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = 5,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -2440,16 +2441,17 @@ static int sd_done(struct scsi_cmnd *SCpnt)
memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
break;
case ABORTED_COMMAND:
- if (sshdr.asc == 0x10) /* DIF: Target detected corruption */
+ if (scsi_sense_asc(&sshdr) == ASC_ID_CRC_OR_ECC_ERROR) /* DIF */
good_bytes = sd_completed_bytes(SCpnt);
break;
case ILLEGAL_REQUEST:
- switch (sshdr.asc) {
- case 0x10: /* DIX: Host detected corruption */
+ switch (scsi_sense_asc(&sshdr)) {
+ case ASC_ID_CRC_OR_ECC_ERROR:
+ /* DIX */
good_bytes = sd_completed_bytes(SCpnt);
break;
- case 0x20: /* INVALID COMMAND OPCODE */
- case 0x24: /* INVALID FIELD IN CDB */
+ case ASC_INVALID_COMMAND_OP_CODE:
+ case ASC_INVALID_FIELD_IN_CDB:
switch (SCpnt->cmnd[0]) {
case UNMAP:
sd_disable_discard(sdkp);
@@ -2495,14 +2497,14 @@ sd_spinup_disk(struct scsi_disk *sdkp)
/* Do not retry Medium Not Present */
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x3A,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code =
+ MEDIUM_NOT_PRESENT | SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = NOT_READY,
- .asc = 0x3A,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code =
+ MEDIUM_NOT_PRESENT | SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Retry when scsi_status_is_good would return false 3 times */
@@ -2566,18 +2568,18 @@ sd_spinup_disk(struct scsi_disk *sdkp)
break;
if (sense_valid && sshdr.sense_key == NOT_READY) {
- if (sshdr.asc == 4 && sshdr.ascq == 3)
- break; /* manual intervention required */
- if (sshdr.asc == 4 && sshdr.ascq == 0xb)
- break; /* standby */
- if (sshdr.asc == 4 && sshdr.ascq == 0xc)
- break; /* unavailable */
- if (sshdr.asc == 4 && sshdr.ascq == 0x1b)
- break; /* sanitize in progress */
- if (sshdr.asc == 4 && sshdr.ascq == 0x24)
- break; /* depopulation in progress */
- if (sshdr.asc == 4 && sshdr.ascq == 0x25)
- break; /* depopulation restoration in progress */
+ switch (sshdr.sense_code) {
+ case LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED:
+ case LU_NOT_ACCESSIBLE_TARGET_PORT_IN_STANDBY_STATE:
+ case LU_NOT_ACCESSIBLE_TARGET_PORT_IN_UNAVAILABLE_STATE:
+ case LU_NOT_READY_SANITIZE_IN_PROGRESS:
+ case DEPOPULATION_IN_PROGRESS:
+ case DEPOPULATION_RESTORATION_IN_PROGRESS:
+ goto out;
+ default:
+ break;
+ }
+
/*
* Issue command to spin up drive when not ready
*/
@@ -2608,8 +2610,9 @@ sd_spinup_disk(struct scsi_disk *sdkp)
* occur here. It's characteristic of these devices.
*/
} else if (sense_valid &&
- sshdr.sense_key == UNIT_ATTENTION &&
- sshdr.asc == 0x28) {
+ sshdr.sense_key == UNIT_ATTENTION &&
+ scsi_sense_asc(&sshdr) ==
+ ASC_NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED) {
if (!spintime) {
spintime_expire = jiffies + 5 * HZ;
spintime = 1;
@@ -2628,6 +2631,7 @@ sd_spinup_disk(struct scsi_disk *sdkp)
} while (spintime && time_before_eq(jiffies, spintime_expire));
+out:
if (spintime) {
if (scsi_status_is_good(the_result))
printk(KERN_CONT "ready\n");
@@ -2753,15 +2757,14 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
sense_valid = scsi_sense_valid(&sshdr);
if (sense_valid &&
sshdr.sense_key == ILLEGAL_REQUEST &&
- (sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
- sshdr.ascq == 0x00)
- /* Invalid Command Operation Code or
- * Invalid Field in CDB, just retry
- * silently with RC10 */
+ (sshdr.sense_code == INVALID_COMMAND_OP_CODE ||
+ sshdr.sense_code == INVALID_FIELD_IN_CDB))
+ /* Just retry silently with RC10 */
return -EINVAL;
if (sense_valid &&
sshdr.sense_key == UNIT_ATTENTION &&
- sshdr.asc == 0x29 && sshdr.ascq == 0x00)
+ sshdr.sense_code ==
+ POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
/* Device reset might occur several times,
* give it one more chance */
if (--reset_retries > 0)
@@ -2818,18 +2821,18 @@ static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
/* Do not retry Medium Not Present */
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x3A,
+ .sense_code = MEDIUM_NOT_PRESENT,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = NOT_READY,
- .asc = 0x3A,
+ .sense_code = MEDIUM_NOT_PRESENT,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Device reset might occur several times so retry a lot */
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x29,
+ .sense_code = POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.allowed = READ_CAPACITY_RETRIES_ON_RESET,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -3258,8 +3261,7 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
bad_sense:
if (res == -EIO && scsi_sense_valid(&sshdr) &&
sshdr.sense_key == ILLEGAL_REQUEST &&
- sshdr.asc == 0x24 && sshdr.ascq == 0x0)
- /* Invalid field in CDB */
+ sshdr.sense_code == INVALID_FIELD_IN_CDB)
sd_first_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
else
sd_first_printk(KERN_ERR, sdkp,
@@ -4160,22 +4162,19 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
{
/* Power on, reset, or bus device reset occurred */
.sense_key = UNIT_ATTENTION,
- .asc = 0x29,
- .ascq = 0,
+ .sense_code = POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
/* Power on occurred */
.sense_key = UNIT_ATTENTION,
- .asc = 0x29,
- .ascq = 1,
+ .sense_code = POWER_ON_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
/* SCSI bus reset */
.sense_key = UNIT_ATTENTION,
- .asc = 0x29,
- .ascq = 2,
+ .sense_code = SCSI_BUS_RESET_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{}
@@ -4207,8 +4206,7 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
sd_print_result(sdkp, "Start/Stop Unit failed", res);
if (res > 0 && scsi_sense_valid(&sshdr)) {
sd_print_sense_hdr(sdkp, &sshdr);
- /* 0x3a is medium not present */
- if (sshdr.asc == 0x3a)
+ if (scsi_sense_asc(&sshdr) == ASC_MEDIUM_NOT_PRESENT)
res = 0;
}
}
diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c
index 56e455fb5add..98f1b9864a79 100644
--- a/drivers/scsi/sd_zbc.c
+++ b/drivers/scsi/sd_zbc.c
@@ -369,7 +369,7 @@ unsigned int sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
if (op_is_zone_mgmt(req_op(rq)) &&
result &&
sshdr->sense_key == ILLEGAL_REQUEST &&
- sshdr->asc == 0x24) {
+ sshdr->sense_code == INVALID_FIELD_IN_CDB) {
/*
* INVALID FIELD IN CDB error: a zone management command was
* attempted on a conventional zone. Nothing to worry about,
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 09/37] scsi: sr: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (7 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 08/37] scsi: sd: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 10/37] scsi: ses: " Damien Le Moal
` (28 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the SCSI CDROM driver to use the 16-bits sense_code field of
struct scsi_sense_hdr and replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/sr.c | 3 ++-
drivers/scsi/sr_ioctl.c | 29 +++++++++++------------------
2 files changed, 13 insertions(+), 19 deletions(-)
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index c36c54ecd354..4f2e8d1be6da 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -253,7 +253,8 @@ static unsigned int sr_check_events(struct cdrom_device_info *cdi,
* (ASC 0x3a).
*/
cd->media_present = scsi_status_is_good(ret) ||
- (scsi_sense_valid(&sshdr) && sshdr.asc != 0x3a);
+ (scsi_sense_valid(&sshdr) &&
+ scsi_sense_asc(&sshdr) != ASC_MEDIUM_NOT_PRESENT);
if (last_present != cd->media_present)
cd->device->changed = 1;
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index 089653018d32..e4ec0f63cdcc 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -226,9 +226,8 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
err = -ENOMEDIUM;
break;
case NOT_READY: /* This happens if there is no disc in drive */
- if (sshdr->asc == 0x04 &&
- sshdr->ascq == 0x01) {
- /* sense: Logical unit is in process of becoming ready */
+ if (sshdr->sense_code ==
+ LU_IS_IN_PROCESS_OF_BECOMING_READY) {
if (!cgc->quiet)
sr_printk(KERN_INFO, cd,
"CDROM not ready yet.\n");
@@ -250,9 +249,7 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
break;
case ILLEGAL_REQUEST:
err = -EIO;
- if (sshdr->asc == 0x20 &&
- sshdr->ascq == 0x00)
- /* sense: Invalid command operation code */
+ if (sshdr->sense_code == INVALID_COMMAND_OP_CODE)
err = -EDRIVE_CANT_DO_THIS;
break;
default:
@@ -303,9 +300,8 @@ int sr_drive_status(struct cdrom_device_info *cdi, int slot)
if (!scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr))
return CDS_DISC_OK;
- /* SK/ASC/ASCQ of 2/4/1 means "unit is becoming ready" */
- if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY
- && sshdr.asc == 0x04 && sshdr.ascq == 0x01)
+ if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY &&
+ sshdr.sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY)
return CDS_DRIVE_NOT_READY;
if (!cdrom_get_media_event(cdi, &med)) {
@@ -318,18 +314,18 @@ int sr_drive_status(struct cdrom_device_info *cdi, int slot)
}
/*
- * SK/ASC/ASCQ of 2/4/2 means "initialization required"
* Using CD_TRAY_OPEN results in an START_STOP_UNIT to close
* the tray, which resolves the initialization requirement.
*/
- if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY
- && sshdr.asc == 0x04 && sshdr.ascq == 0x02)
+ if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY &&
+ sshdr.sense_code == LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)
return CDS_TRAY_OPEN;
/*
* 0x04 is format in progress .. but there must be a disc present!
*/
- if (sshdr.sense_key == NOT_READY && sshdr.asc == 0x04)
+ if (sshdr.sense_key == NOT_READY &&
+ scsi_sense_asc(&sshdr) == ASC_LU_NOT_READY)
return CDS_DISC_OK;
/*
@@ -338,13 +334,10 @@ int sr_drive_status(struct cdrom_device_info *cdi, int slot)
* any other way to detect this...
*/
if (scsi_sense_valid(&sshdr) &&
- /* 0x3a is medium not present */
- sshdr.asc == 0x3a)
+ scsi_sense_asc(&sshdr) == ASC_MEDIUM_NOT_PRESENT)
return CDS_NO_DISC;
- else
- return CDS_TRAY_OPEN;
- return CDS_DRIVE_NOT_READY;
+ return CDS_TRAY_OPEN;
}
int sr_disk_status(struct cdrom_device_info *cdi)
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 10/37] scsi: ses: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (8 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 09/37] scsi: sr: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 11/37] scsi: ch: " Damien Le Moal
` (27 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the SCSI stroage enclosure driver to use the 16-bits sense_code
field of struct scsi_failure and replace all hard-coded additional sense
codes and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/ses.c | 15 +++++++--------
1 file changed, 7 insertions(+), 8 deletions(-)
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index 454886c24570..eefeb8b9a75c 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -72,6 +72,9 @@ static void init_device_slot_control(unsigned char *dest_desc,
dest_desc[3] &= 0x3c;
}
+#define POWER_ON_RESET_ANY \
+ scsi_sense_code(ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED, \
+ SCMD_FAILURE_ASCQ_ANY)
static int ses_recv_diag(struct scsi_device *sdev, int page_code,
void *buf, int bufflen)
@@ -89,15 +92,13 @@ static int ses_recv_diag(struct scsi_device *sdev, int page_code,
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x29,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = POWER_ON_RESET_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = NOT_READY,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -146,15 +147,13 @@ static int ses_send_diag(struct scsi_device *sdev, int page_code,
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = 0x29,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = POWER_ON_RESET_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = NOT_READY,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 11/37] scsi: ch: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (9 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 10/37] scsi: ses: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 12/37] scsi: st: " Damien Le Moal
` (26 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the SCSI media changer driver to use the 16-bits sense_code field
of struct scsi_sense_hdr and struct scsi_failure and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/ch.c | 53 ++++++++++++++++++++---------------------------
1 file changed, 22 insertions(+), 31 deletions(-)
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index b804291a36ff..87e51e50a741 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -123,38 +123,32 @@ static DEFINE_IDR(ch_index_idr);
static DEFINE_SPINLOCK(ch_index_lock);
static const struct {
- unsigned char sense;
- unsigned char asc;
- unsigned char ascq;
- int errno;
+ u8 sense_key;
+ u16 sense_code;
+ int errno;
} ch_err[] = {
/* Just filled in what looks right. Hav'nt checked any standard paper for
these errno assignments, so they may be wrong... */
{
- .sense = ILLEGAL_REQUEST,
- .asc = 0x21,
- .ascq = 0x01,
- .errno = EBADSLT, /* Invalid element address */
+ .sense_key = ILLEGAL_REQUEST,
+ .sense_code = INVALID_ELEMENT_ADDRESS,
+ .errno = EBADSLT,
},{
- .sense = ILLEGAL_REQUEST,
- .asc = 0x28,
- .ascq = 0x01,
- .errno = EBADE, /* Import or export element accessed */
+ .sense_key = ILLEGAL_REQUEST,
+ .sense_code = IMPORT_OR_EXPORT_ELEMENT_ACCESSED,
+ .errno = EBADE,
},{
- .sense = ILLEGAL_REQUEST,
- .asc = 0x3B,
- .ascq = 0x0D,
- .errno = EXFULL, /* Medium destination element full */
+ .sense_key = ILLEGAL_REQUEST,
+ .sense_code = MEDIUM_DESTINATION_ELEMENT_FULL,
+ .errno = EXFULL,
},{
- .sense = ILLEGAL_REQUEST,
- .asc = 0x3B,
- .ascq = 0x0E,
- .errno = EBADE, /* Medium source element empty */
+ .sense_key = ILLEGAL_REQUEST,
+ .sense_code = MEDIUM_SOURCE_ELEMENT_EMPTY,
+ .errno = EBADE,
},{
- .sense = ILLEGAL_REQUEST,
- .asc = 0x20,
- .ascq = 0x00,
- .errno = EBADRQC, /* Invalid command operation code */
+ .sense_key = ILLEGAL_REQUEST,
+ .sense_code = INVALID_COMMAND_OP_CODE,
+ .errno = EBADRQC,
},{
/* end of list */
}
@@ -167,12 +161,10 @@ static int ch_find_errno(struct scsi_sense_hdr *sshdr)
int i,errno = 0;
/* Check to see if additional sense information is available */
- if (scsi_sense_valid(sshdr) &&
- sshdr->asc != 0) {
+ if (scsi_sense_valid(sshdr) && scsi_sense_asc(sshdr) != 0) {
for (i = 0; ch_err[i].errno != 0; i++) {
- if (ch_err[i].sense == sshdr->sense_key &&
- ch_err[i].asc == sshdr->asc &&
- ch_err[i].ascq == sshdr->ascq) {
+ if (ch_err[i].sense_key == sshdr->sense_key &&
+ ch_err[i].sense_code == sshdr->sense_code) {
errno = -ch_err[i].errno;
break;
}
@@ -192,8 +184,7 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = 3,
.result = SAM_STAT_CHECK_CONDITION,
},
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 12/37] scsi: st: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (10 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 11/37] scsi: ch: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:19 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 13/37] scsi: device_handlers: hp_sw: " Damien Le Moal
` (25 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the SCSI tape driver to use the 16-bits sense_code field of
struct scsi_sense_hdr and replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/st.c | 35 +++++++++++++++++++----------------
1 file changed, 19 insertions(+), 16 deletions(-)
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index f1c3c4946637..1ca9753cb734 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -421,11 +421,13 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
STp->cln_sense_mask) != 0);
}
if (cmdstatp->have_sense &&
- cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
- STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
+ cmdstatp->sense_hdr.sense_code == CLEANING_REQUESTED)
+ STp->cleaning_req = 1;
if (cmdstatp->have_sense && scode == UNIT_ATTENTION &&
- cmdstatp->sense_hdr.asc == 0x29 && !STp->pos_unknown) {
- STp->pos_unknown = 1; /* ASC => power on / reset */
+ scsi_sense_asc(&cmdstatp->sense_hdr) ==
+ ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED &&
+ !STp->pos_unknown) {
+ STp->pos_unknown = 1;
st_printk(KERN_WARNING, STp, "Power on/reset recognized.");
}
@@ -1003,7 +1005,8 @@ static int test_ready(struct scsi_tape *STp, int do_wait)
scode = cmdstatp->sense_hdr.sense_key;
if (scode == UNIT_ATTENTION) { /* New media? */
- if (cmdstatp->sense_hdr.asc == 0x28) { /* New media */
+ if (scsi_sense_asc(&cmdstatp->sense_hdr) ==
+ ASC_NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED) {
new_session = 1;
DEBC_printk(STp, "New tape session.");
}
@@ -1026,14 +1029,13 @@ static int test_ready(struct scsi_tape *STp, int do_wait)
waits++;
continue;
}
- else {
- if ((STp->device)->scsi_level >= SCSI_2 &&
- cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
- retval = CHKRES_NO_TAPE;
- else
- retval = CHKRES_NOT_READY;
- break;
- }
+ if ((STp->device)->scsi_level >= SCSI_2 &&
+ scsi_sense_asc(&cmdstatp->sense_hdr) ==
+ ASC_MEDIUM_NOT_PRESENT)
+ retval = CHKRES_NO_TAPE;
+ else
+ retval = CHKRES_NOT_READY;
+ break;
}
}
@@ -3105,9 +3107,10 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon
cmd_in == MTSETDRVBUFFER ||
cmd_in == SET_DENS_AND_BLK) {
if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
- cmdstatp->sense_hdr.asc == 0x24 &&
- (STp->device)->scsi_level <= SCSI_2 &&
- !(STp->use_pf & PF_TESTED)) {
+ scsi_sense_asc(&cmdstatp->sense_hdr) ==
+ ASC_INVALID_FIELD_IN_CDB &&
+ (STp->device)->scsi_level <= SCSI_2 &&
+ !(STp->use_pf & PF_TESTED)) {
/* Try the other possible state of Page Format if not
already tried */
STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 12/37] scsi: st: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 12/37] scsi: st: " Damien Le Moal
@ 2026-08-31 2:19 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:19 UTC (permalink / raw)
To: Damien Le Moal; +Cc: linux-ide, linux-scsi, dlemoal, cassel
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Incorrectly assigning ASC value to ASCQ in SCSI tracepoint.
--
commit c1f7c0aa9501c3562bd45de8a85431d940fa338b
Author: Damien Le Moal <dlemoal@kernel.org>
Subject: scsi: st: use 16-bits defined sense codes
This commit refactors the SCSI tape driver to use the 16-bit sense_code
field of struct scsi_sense_hdr. It replaces hard-coded additional sense
codes and qualifiers with enum values defined in include/scsi/scsi_sense.h
to improve code clarity.
While reviewing this patch series, I noticed an issue introduced in the
related change to include/trace/events/scsi.h:
> diff --git a/include/trace/events/scsi.h b/include/trace/events/scsi.h
> --- a/include/trace/events/scsi.h
> +++ b/include/trace/events/scsi.h
> @@ -303,8 +303,8 @@ DECLARE_EVENT_CLASS(scsi_cmd_done_timeout_template,
> if (cmd->sense_buffer && SCSI_SENSE_VALID(cmd) &&
> scsi_command_normalize_sense(cmd, &sshdr)) {
> __entry->sense_key = sshdr.sense_key;
> - __entry->asc = sshdr.asc;
> - __entry->ascq = sshdr.ascq;
> + __entry->asc = scsi_sense_asc(&sshdr);
> + __entry->ascq = scsi_sense_asc(&sshdr);
^^^^^^^^^^^^^^
[Severity: Medium]
Is there a typo in this assignment?
In the scsi_cmd_done_timeout_template tracepoint, __entry->ascq is being
assigned scsi_sense_asc(&sshdr) instead of the ASCQ value. This appears to
log the Additional Sense Code for both the asc and ascq fields, which will
result in lost diagnostic data when userspace tools analyze SCSI errors via
tracepoints.
Should this use scsi_sense_ascq(&sshdr) for the ascq field instead?
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=12
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 13/37] scsi: device_handlers: hp_sw: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (11 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 12/37] scsi: st: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 14/37] scsi: device_handlers: rdac: " Damien Le Moal
` (24 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the HP sw device handler driver to use the 16-bits sense_code
field of struct scsi_sense_hdr and struct scsi_failure and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/device_handler/scsi_dh_hp_sw.c | 27 +++++++++------------
1 file changed, 11 insertions(+), 16 deletions(-)
diff --git a/drivers/scsi/device_handler/scsi_dh_hp_sw.c b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
index 3431e1ce95fd..e400a317d9f3 100644
--- a/drivers/scsi/device_handler/scsi_dh_hp_sw.c
+++ b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
@@ -47,7 +47,8 @@ static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
switch (sshdr->sense_key) {
case NOT_READY:
- if (sshdr->asc == 0x04 && sshdr->ascq == 2) {
+ if (sshdr->sense_code ==
+ LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED) {
/*
* LUN not ready - Initialization command required
*
@@ -60,9 +61,8 @@ static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
fallthrough;
default:
sdev_printk(KERN_WARNING, sdev,
- "%s: sending tur failed, sense %x/%x/%x\n",
- HP_SW_NAME, sshdr->sense_key, sshdr->asc,
- sshdr->ascq);
+ "%s: sending tur failed, sense 0x%02x/0x%04x\n",
+ HP_SW_NAME, sshdr->sense_key, sshdr->sense_code);
break;
}
return ret;
@@ -85,8 +85,7 @@ static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
struct scsi_failure failure_defs[] = {
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = SCMD_FAILURE_NO_LIMIT,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -133,14 +132,9 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
- /*
- * LUN not ready - manual intervention required
- *
- * Switch-over in progress, retry.
- */
+ /* Switch-over in progress, retry. */
.sense_key = NOT_READY,
- .asc = 0x04,
- .ascq = 0x03,
+ .sense_code = LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED,
.allowed = HP_SW_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -167,7 +161,8 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
switch (sshdr.sense_key) {
case NOT_READY:
- if (sshdr.asc == 0x04 && sshdr.ascq == 3) {
+ if (sshdr.sense_code ==
+ LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED) {
rc = SCSI_DH_RETRY;
break;
}
@@ -175,8 +170,8 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
default:
sdev_printk(KERN_WARNING, sdev,
"%s: sending start_stop_unit failed, "
- "sense %x/%x/%x\n", HP_SW_NAME,
- sshdr.sense_key, sshdr.asc, sshdr.ascq);
+ "sense %x/%04x\n", HP_SW_NAME,
+ sshdr.sense_key, sshdr.sense_code);
rc = SCSI_DH_IO;
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 14/37] scsi: device_handlers: rdac: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (12 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 13/37] scsi: device_handlers: hp_sw: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 15/37] scsi: device_handlers: emc: " Damien Le Moal
` (23 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the NetApp E-Series RDAC SCSI device handler driver to use the
16-bits sense_code field of struct scsi_sense_hdr and struct scsi_failure
and replace all hard-coded additional sense codes and additional sense
code qualifiers with the enum values defined in include/scsi/scsi_sense.h.
This helps with code clarity as the sense codes being processed are easier
to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/device_handler/scsi_dh_rdac.c | 41 ++++++++++------------
1 file changed, 18 insertions(+), 23 deletions(-)
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 75c9cc291e38..1ca1aaf7cb40 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -491,9 +491,9 @@ static int mode_select_handle_sense(struct scsi_device *sdev,
return SCSI_DH_IO;
RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
- "MODE_SELECT returned with sense %02x/%02x/%02x",
+ "MODE_SELECT returned with sense 0x%02x/0x%04x",
(char *) h->ctlr->array_name, h->ctlr->index,
- sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
+ sense_hdr->sense_key, sense_hdr->sense_code);
return SCSI_DH_IO;
}
@@ -515,34 +515,28 @@ static void send_mode_select(struct work_struct *work)
struct scsi_failure failure_defs[] = {
{
.sense_key = NO_SENSE,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = ABORTED_COMMAND,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense_key = UNIT_ATTENTION,
- .asc = SCMD_FAILURE_ASC_ANY,
- .ascq = SCMD_FAILURE_ASCQ_ANY,
+ .sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
- /* LUN Not Ready and is in the Process of Becoming Ready */
{
.sense_key = NOT_READY,
- .asc = 0x04,
- .ascq = 0x01,
+ .sense_code = LU_IS_IN_PROCESS_OF_BECOMING_READY,
.result = SAM_STAT_CHECK_CONDITION,
},
- /* Command Lock contention */
+ /* Command Lock contention (not a standard sense code) */
{
.sense_key = ILLEGAL_REQUEST,
- .asc = 0x91,
- .ascq = 0x36,
+ .sense_code = scsi_sense_code(0x91, 0x36),
.allowed = SCMD_FAILURE_NO_LIMIT,
.result = SAM_STAT_CHECK_CONDITION,
},
@@ -675,32 +669,32 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
struct rdac_dh_data *h = sdev->handler_data;
RDAC_LOG(RDAC_LOG_SENSE, sdev, "array %s, ctlr %d, "
- "I/O returned with sense %02x/%02x/%02x",
+ "I/O returned with sense 0x%02x/0x%04x",
(char *) h->ctlr->array_name, h->ctlr->index,
- sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
+ sense_hdr->sense_key, sense_hdr->sense_code);
switch (sense_hdr->sense_key) {
case NOT_READY:
- if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x01)
+ if (sense_hdr->sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY)
/* LUN Not Ready - Logical Unit Not Ready and is in
* the process of becoming ready
* Just retry.
*/
return ADD_TO_MLQUEUE;
- if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x81)
+ if (sense_hdr->sense_code == scsi_sense_code(0x04, 0x81))
/* LUN Not Ready - Storage firmware incompatible
* Manual code synchonisation required.
*
* Nothing we can do here. Try to bypass the path.
*/
return SUCCESS;
- if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0xA1)
+ if (sense_hdr->sense_code == scsi_sense_code(0x04, 0xA1))
/* LUN Not Ready - Quiescense in progress
*
* Just retry and wait.
*/
return ADD_TO_MLQUEUE;
- if (sense_hdr->asc == 0xA1 && sense_hdr->ascq == 0x02)
+ if (sense_hdr->sense_code == scsi_sense_code(0xA1, 0x02))
/* LUN Not Ready - Quiescense in progress
* or has been achieved
* Just retry.
@@ -708,7 +702,7 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
return ADD_TO_MLQUEUE;
break;
case ILLEGAL_REQUEST:
- if (sense_hdr->asc == 0x94 && sense_hdr->ascq == 0x01) {
+ if (sense_hdr->sense_code == scsi_sense_code(0x94, 0x01)) {
/* Invalid Request - Current Logical Unit Ownership.
* Controller is not the current owner of the LUN,
* Fail the path, so that the other path be used.
@@ -718,12 +712,13 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
}
break;
case UNIT_ATTENTION:
- if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
+ if (sense_hdr->sense_code ==
+ POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
/*
* Power On, Reset, or Bus Device Reset, just retry.
*/
return ADD_TO_MLQUEUE;
- if (sense_hdr->asc == 0x8b && sense_hdr->ascq == 0x02)
+ if (sense_hdr->sense_code == scsi_sense_code(0x8b, 0x02))
/*
* Quiescence in progress , just retry.
*/
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 15/37] scsi: device_handlers: emc: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (13 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 14/37] scsi: device_handlers: rdac: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 16/37] scsi: device_handlers: alua: " Damien Le Moal
` (22 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the EMC SCSI device handler driver to use the 16-bits sense_code
field of struct scsi_sense_hdr and replace all hard-coded additional sense
codes and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/device_handler/scsi_dh_emc.c | 30 ++++++++++++-----------
1 file changed, 16 insertions(+), 14 deletions(-)
diff --git a/drivers/scsi/device_handler/scsi_dh_emc.c b/drivers/scsi/device_handler/scsi_dh_emc.c
index ff41b51ef462..ee97570cb110 100644
--- a/drivers/scsi/device_handler/scsi_dh_emc.c
+++ b/drivers/scsi/device_handler/scsi_dh_emc.c
@@ -103,12 +103,12 @@ static int trespass_endio(struct scsi_device *sdev,
int err = SCSI_DH_IO;
sdev_printk(KERN_ERR, sdev, "%s: Found valid sense data 0x%2x, "
- "0x%2x, 0x%2x while sending CLARiiON trespass "
+ "0x%04x while sending CLARiiON trespass "
"command.\n", CLARIION_NAME, sshdr->sense_key,
- sshdr->asc, sshdr->ascq);
+ sshdr->sense_code);
- if (sshdr->sense_key == 0x05 && sshdr->asc == 0x04 &&
- sshdr->ascq == 0x00) {
+ if (sshdr->sense_key == ILLEGAL_REQUEST &&
+ sshdr->sense_code == LU_NOT_READY) {
/*
* Array based copy in progress -- do not send
* mode_select or copy will be aborted mid-stream.
@@ -117,18 +117,18 @@ static int trespass_endio(struct scsi_device *sdev,
"progress while sending CLARiiON trespass "
"command.\n", CLARIION_NAME);
err = SCSI_DH_DEV_TEMP_BUSY;
- } else if (sshdr->sense_key == 0x02 && sshdr->asc == 0x04 &&
- sshdr->ascq == 0x03) {
- /*
- * LUN Not Ready - Manual Intervention Required
- * indicates in-progress ucode upgrade (NDU).
- */
+ } else if (sshdr->sense_key == NOT_READY &&
+ sshdr->sense_code ==
+ LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED) {
+ /* Indicates in-progress ucode upgrade (NDU). */
sdev_printk(KERN_INFO, sdev, "%s: Detected in-progress "
"ucode upgrade NDU operation while sending "
"CLARiiON trespass command.\n", CLARIION_NAME);
err = SCSI_DH_DEV_TEMP_BUSY;
- } else
+ } else {
err = SCSI_DH_DEV_FAILED;
+ }
+
return err;
}
@@ -288,7 +288,8 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
{
switch (sense_hdr->sense_key) {
case NOT_READY:
- if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x03)
+ if (sense_hdr->sense_code ==
+ LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED)
/*
* LUN Not Ready - Manual Intervention Required
* indicates this is a passive path.
@@ -305,7 +306,7 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
return SUCCESS;
break;
case ILLEGAL_REQUEST:
- if (sense_hdr->asc == 0x25 && sense_hdr->ascq == 0x01)
+ if (sense_hdr->sense_code == scsi_sense_code(0x25, 0x01))
/*
* An array based copy is in progress. Do not
* fail the path, do not bypass to another PG,
@@ -319,7 +320,8 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
return SUCCESS;
break;
case UNIT_ATTENTION:
- if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
+ if (sense_hdr->sense_code ==
+ POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
/*
* Unit Attention Code. This is the first IO
* to the new path, so just retry.
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 16/37] scsi: device_handlers: alua: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (14 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 15/37] scsi: device_handlers: emc: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 17/37] scsi: mpt3sas: " Damien Le Moal
` (21 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the SCSI ALUA devie handler driver to use the 16-bits sense_code
field of struct scsi_sense_hdr and replace all hard-coded additional sense
codes and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/device_handler/scsi_dh_alua.c | 55 ++++++++--------------
1 file changed, 19 insertions(+), 36 deletions(-)
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index d81ec47a7140..87ac0a6d63e5 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -433,61 +433,43 @@ static enum scsi_disposition alua_check_sense(struct scsi_device *sdev,
{
switch (sense_hdr->sense_key) {
case NOT_READY:
- if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
- /*
- * LUN Not Accessible - ALUA state transition
- */
+ if (sense_hdr->sense_code ==
+ LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
alua_handle_state_transition(sdev);
return NEEDS_RETRY;
}
break;
case UNIT_ATTENTION:
- if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
- /*
- * LUN Not Accessible - ALUA state transition
- */
+ if (sense_hdr->sense_code ==
+ LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
alua_handle_state_transition(sdev);
return NEEDS_RETRY;
}
- if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00) {
+ if (sense_hdr->sense_code ==
+ POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED) {
/*
- * Power On, Reset, or Bus Device Reset.
* Might have obscured a state transition,
* so schedule a recheck.
*/
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
- if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x04)
- /*
- * Device internal reset
- */
+ if (sense_hdr->sense_code == DEVICE_INTERNAL_RESET)
return ADD_TO_MLQUEUE;
- if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x01)
- /*
- * Mode Parameters Changed
- */
+ if (sense_hdr->sense_code == MODE_PARAMETERS_CHANGED)
return ADD_TO_MLQUEUE;
- if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) {
- /*
- * ALUA state changed
- */
+ if (sense_hdr->sense_code == ASYMMETRIC_ACCESS_STATE_CHANGED) {
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
- if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) {
- /*
- * Implicit ALUA state transition failed
- */
+ if (sense_hdr->sense_code ==
+ IMPLICIT_ASYMMETRIC_ACCESS_STATE_TRANSITION_FAILED) {
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
- if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x03)
- /*
- * Inquiry data has changed
- */
+ if (sense_hdr->sense_code == INQUIRY_DATA_HAS_CHANGED)
return ADD_TO_MLQUEUE;
- if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e)
+ if (sense_hdr->sense_code == REPORTED_LUNS_DATA_HAS_CHANGED)
/*
* REPORTED_LUNS_DATA_HAS_CHANGED is reported
* when switching controllers on targets like
@@ -517,12 +499,12 @@ static int alua_tur(struct scsi_device *sdev)
ALUA_FAILOVER_RETRIES, &sense_hdr);
if ((sense_hdr.sense_key == NOT_READY ||
sense_hdr.sense_key == UNIT_ATTENTION) &&
- sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a)
+ sense_hdr.sense_code ==
+ LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION)
return SCSI_DH_RETRY;
- else if (retval)
+ if (retval)
return SCSI_DH_IO;
- else
- return SCSI_DH_OK;
+ return SCSI_DH_OK;
}
/*
@@ -619,7 +601,8 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg)
* transition. So set the state to 'transitioning' directly.
*/
if (sense_hdr.sense_key == NOT_READY &&
- sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a) {
+ sense_hdr.sense_code ==
+ LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
transitioning_sense = true;
goto skip_rtpg;
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 17/37] scsi: mpt3sas: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (15 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 16/37] scsi: device_handlers: alua: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:19 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 18/37] scsi: mpi3mr: " Damien Le Moal
` (20 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the mpt3sas driver to replace all hard-coded additional sense
codes and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/mpt3sas/mpt3sas_scsih.c | 69 +++++++++++++++-------------
1 file changed, 36 insertions(+), 33 deletions(-)
diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
index 0e12009a87f6..085d4672db85 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
@@ -5401,23 +5401,23 @@ _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
static void
_scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
{
- u8 ascq;
+ u16 sense_code;
switch (ioc_status) {
case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
- ascq = 0x01;
+ sense_code = LOGICAL_BLOCK_GUARD_CHECK_FAILED;
break;
case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
- ascq = 0x02;
+ sense_code = LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED;
break;
case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
- ascq = 0x03;
+ sense_code = LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED;
break;
default:
- ascq = 0x00;
+ sense_code = ID_CRC_OR_ECC_ERROR;
break;
}
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x10, ascq);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST, sense_code);
set_host_byte(scmd, DID_ABORT);
}
@@ -5474,7 +5474,8 @@ static enum scsi_qc_status scsih_qcmd(struct Scsi_Host *shost,
if (handle == MPT3SAS_INVALID_DEVICE_HANDLE || sas_device_priv_data->block) {
if (scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY) {
- scsi_build_sense(scmd, 0, UNIT_ATTENTION, 0x29, 0x07);
+ scsi_set_sense(scmd, 0, UNIT_ATTENTION,
+ I_T_NEXUS_LOSS_OCCURRED);
scsi_done(scmd);
return 0;
}
@@ -5986,7 +5987,7 @@ _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
event_reply->EventData;
event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
- event_data->ASC = 0x5D;
+ event_data->ASC = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
event_data->DevHandle = cpu_to_le16(handle);
event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
mpt3sas_ctl_add_to_event_log(ioc, event_reply);
@@ -6109,8 +6110,7 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
le32_to_cpu(mpi_reply->SenseCount));
memcpy(scmd->sense_buffer, sense_data, sz);
_scsih_normalize_sense(scmd->sense_buffer, &data);
- /* failure prediction threshold exceeded */
- if (data.asc == 0x5D)
+ if (data.asc == ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED)
_scsih_smart_predicted_fault(ioc,
le16_to_cpu(mpi_reply->DevHandle));
mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
@@ -6199,8 +6199,8 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST,
- 0x20, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
}
break;
@@ -7691,38 +7691,41 @@ _scsih_determine_disposition(struct MPT3SAS_ADAPTER *ioc,
if (check_sense) {
_scsih_normalize_sense(transfer_packet->sense, &sense_info);
- if (sense_info.skey == UNIT_ATTENTION)
+ if (sense_info.skey == UNIT_ATTENTION) {
rc = DEVICE_RETRY_UA;
- else if (sense_info.skey == NOT_READY) {
- /* medium isn't present */
- if (sense_info.asc == 0x3a)
+ } else if (sense_info.skey == NOT_READY) {
+ if (sense_info.asc == ASC_MEDIUM_NOT_PRESENT) {
rc = DEVICE_READY;
- /* LOGICAL UNIT NOT READY */
- else if (sense_info.asc == 0x04) {
- if (sense_info.ascq == 0x03 ||
- sense_info.ascq == 0x0b ||
- sense_info.ascq == 0x0c) {
+ } else if (sense_info.asc == ASC_LU_NOT_READY) {
+ u16 scode = scsi_sense_code(sense_info.asc,
+ sense_info.ascq);
+
+ if (scode ==
+ LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED ||
+ scode ==
+ LU_NOT_ACCESSIBLE_TARGET_PORT_IN_STANDBY_STATE ||
+ scode ==
+ LU_NOT_ACCESSIBLE_TARGET_PORT_IN_UNAVAILABLE_STATE)
rc = DEVICE_ERROR;
- } else
+ else
rc = DEVICE_START_UNIT;
- }
- /* LOGICAL UNIT HAS NOT SELF-CONFIGURED YET */
- else if (sense_info.asc == 0x3e && !sense_info.ascq)
+ } else if (sense_info.asc ==
+ ASC_LU_HAS_NOT_SELF_CONFIGURED_YET &&
+ !sense_info.ascq) {
rc = DEVICE_START_UNIT;
+ }
} else if (sense_info.skey == ILLEGAL_REQUEST &&
- transfer_packet->cdb[0] == REPORT_LUNS) {
+ transfer_packet->cdb[0] == REPORT_LUNS) {
rc = DEVICE_READY;
} else if (sense_info.skey == MEDIUM_ERROR) {
-
- /* medium is corrupt, lets add the device so
- * users can collect some info as needed
+ /*
+ * medium is corrupt, lets add the device so users can
+ * collect some info as needed
*/
-
- if (sense_info.asc == 0x31)
+ if (sense_info.asc == ASC_MEDIUM_FORMAT_CORRUPTED)
rc = DEVICE_READY;
} else if (sense_info.skey == HARDWARE_ERROR) {
- /* Defect List Error, still add the device */
- if (sense_info.asc == 0x19)
+ if (sense_info.asc == ASC_DEFECT_LIST_ERROR)
rc = DEVICE_READY;
}
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 17/37] scsi: mpt3sas: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 17/37] scsi: mpt3sas: " Damien Le Moal
@ 2026-08-31 2:19 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:19 UTC (permalink / raw)
To: Damien Le Moal; +Cc: dlemoal, linux-ide, cassel, linux-scsi
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Data race on static local variable 'rc' in _scsih_determine_disposition causing erratic device discovery states.
--
commit 494f343d73ff2ef15d8e6f7b1ea653d86adb0fd3
Author: Damien Le Moal <dlemoal@kernel.org>
scsi: mpt3sas: use 16-bits defined sense codes
This commit refactors the mpt3sas driver to replace hard-coded sense codes
with the enum values defined in include/scsi/scsi_sense.h. This improves
code clarity and self-documentation.
> diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
> index 0e12009a87f62..085d4672db854 100644
> --- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
> +++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
[ ... ]
> @@ -7691,38 +7691,41 @@ _scsih_determine_disposition(struct MPT3SAS_ADAPTER *ioc,
>
> if (check_sense) {
> _scsih_normalize_sense(transfer_packet->sense, &sense_info);
> - if (sense_info.skey == UNIT_ATTENTION)
> + if (sense_info.skey == UNIT_ATTENTION) {
> rc = DEVICE_RETRY_UA;
[Severity: High]
This is a pre-existing issue, but I noticed a potential data race involving
the variable rc in this function. At the beginning of
_scsih_determine_disposition(), it is declared as a static local variable:
static enum device_responsive_state rc;
Because this variable is static, it is shared across all concurrent executions
of the function. If multiple threads (such as from asynchronous SCSI scanning
or event handlers) execute this concurrently, could one thread overwrite the
disposition state calculated by another?
If this overwrite occurs, would it cause devices to be incorrectly marked
offline, skipped, or subjected to invalid retry loops? Does this variable
need to be static, or can it be changed to a standard local variable?
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=17
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 18/37] scsi: mpi3mr: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (16 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 17/37] scsi: mpt3sas: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 19/37] scsi: 3w-xxxx: " Damien Le Moal
` (19 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the mpi3mr driver to use the 16-bits sense_code field of struct
scsi_sense_hdr and replace all hard-coded additional sense codes and
additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/mpi3mr/mpi3mr_fw.c | 3 +-
drivers/scsi/mpi3mr/mpi3mr_os.c | 50 +++++++++++++++++----------------
2 files changed, 28 insertions(+), 25 deletions(-)
diff --git a/drivers/scsi/mpi3mr/mpi3mr_fw.c b/drivers/scsi/mpi3mr/mpi3mr_fw.c
index 681868716ebd..ae4b531f3e37 100644
--- a/drivers/scsi/mpi3mr/mpi3mr_fw.c
+++ b/drivers/scsi/mpi3mr/mpi3mr_fw.c
@@ -404,7 +404,8 @@ static void mpi3mr_process_admin_reply_desc(struct mpi3mr_ioc *mrioc,
scsi_normalize_sense(sense_buf, sense_count,
&sshdr);
mpi3mr_scsisense_trigger(mrioc, sshdr.sense_key,
- sshdr.asc, sshdr.ascq);
+ scsi_sense_asc(&sshdr),
+ scsi_sense_ascq(&sshdr));
}
}
mpi3mr_reply_trigger(mrioc, masked_ioc_status, ioc_loginfo);
diff --git a/drivers/scsi/mpi3mr/mpi3mr_os.c b/drivers/scsi/mpi3mr/mpi3mr_os.c
index f80a21ec161b..274af456b9c0 100644
--- a/drivers/scsi/mpi3mr/mpi3mr_os.c
+++ b/drivers/scsi/mpi3mr/mpi3mr_os.c
@@ -3304,8 +3304,7 @@ static void mpi3mr_setup_eedp(struct mpi3mr_ioc *mrioc,
* @desc: Sense type
* @buf: Sense buffer to populate
* @key: Sense key
- * @asc: Additional sense code
- * @ascq: Additional sense code qualifier
+ * @code: Additional sense code and its qualifier
*
* Maps the given sense information into either descriptor or
* fixed format sense data.
@@ -3313,20 +3312,20 @@ static void mpi3mr_setup_eedp(struct mpi3mr_ioc *mrioc,
* Return: Nothing
*/
static inline void mpi3mr_build_sense_buffer(int desc, u8 *buf, u8 key,
- u8 asc, u8 ascq)
+ u16 code)
{
if (desc) {
buf[0] = 0x72; /* descriptor, current */
buf[1] = key;
- buf[2] = asc;
- buf[3] = ascq;
+ buf[2] = scsi_sense_code_asc(code);
+ buf[3] = scsi_sense_code_ascq(code);
buf[7] = 0;
} else {
buf[0] = 0x70; /* fixed, current */
buf[2] = key;
buf[7] = 0xa;
- buf[12] = asc;
- buf[13] = ascq;
+ buf[12] = scsi_sense_code_asc(code);
+ buf[13] = scsi_sense_code_ascq(code);
}
}
@@ -3343,25 +3342,25 @@ static inline void mpi3mr_build_sense_buffer(int desc, u8 *buf, u8 key,
static void mpi3mr_map_eedp_error(struct scsi_cmnd *scmd,
u16 ioc_status)
{
- u8 ascq = 0;
+ u16 sense_code;
switch (ioc_status) {
case MPI3_IOCSTATUS_EEDP_GUARD_ERROR:
- ascq = 0x01;
+ sense_code = LOGICAL_BLOCK_GUARD_CHECK_FAILED;
break;
case MPI3_IOCSTATUS_EEDP_APP_TAG_ERROR:
- ascq = 0x02;
+ sense_code = LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED;
break;
case MPI3_IOCSTATUS_EEDP_REF_TAG_ERROR:
- ascq = 0x03;
+ sense_code = LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED;
break;
default:
- ascq = 0x00;
+ sense_code = ID_CRC_OR_ECC_ERROR;
break;
}
mpi3mr_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
- 0x10, ascq);
+ sense_code);
scmd->result = (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
}
@@ -3446,7 +3445,8 @@ void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc,
if (sense_buf) {
scsi_normalize_sense(sense_buf, sense_count, &sshdr);
mpi3mr_scsisense_trigger(mrioc, sshdr.sense_key,
- sshdr.asc, sshdr.ascq);
+ scsi_sense_asc(&sshdr),
+ scsi_sense_ascq(&sshdr));
}
mpi3mr_reply_trigger(mrioc, ioc_status, ioc_loginfo);
break;
@@ -3633,7 +3633,8 @@ void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc,
ioc_info(mrioc,
"%s :sense_count 0x%x, sense_key 0x%x ASC 0x%x, ASCQ 0x%x\n",
__func__, sense_count, sshdr.sense_key,
- sshdr.asc, sshdr.ascq);
+ scsi_sense_asc(&sshdr),
+ scsi_sense_ascq(&sshdr));
}
}
out_success:
@@ -5040,8 +5041,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, param_len);
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
- scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
- 0x1A, 0);
+ scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
+ PARAMETER_LIST_LENGTH_ERROR);
scsi_done(scmd);
return true;
}
@@ -5051,8 +5052,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, param_len, scsi_bufflen(scmd));
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
- scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
- 0x1A, 0);
+ scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
+ PARAMETER_LIST_LENGTH_ERROR);
scsi_done(scmd);
return true;
}
@@ -5060,8 +5061,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
if (!buf) {
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
- scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
- 0x55, 0x03);
+ scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
+ INSUFFICIENT_RESOURCES);
scsi_done(scmd);
return true;
}
@@ -5074,8 +5075,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, desc_len);
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
- scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
- 0x26, 0);
+ scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_PARAMETER_LIST);
scsi_done(scmd);
kfree(buf);
return true;
@@ -5175,7 +5176,8 @@ static enum scsi_qc_status mpi3mr_qcmd(struct Scsi_Host *shost,
if (scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY &&
(stgt_priv_data->dev_removed || (dev_handle == MPI3MR_INVALID_DEV_HANDLE))) {
- scsi_build_sense(scmd, 0, UNIT_ATTENTION, 0x29, 0x07);
+ scsi_set_sense(scmd, 0, UNIT_ATTENTION,
+ I_T_NEXUS_LOSS_OCCURRED);
scsi_done(scmd);
goto out;
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 19/37] scsi: 3w-xxxx: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (17 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 18/37] scsi: mpi3mr: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 20/37] scsi: leapraid: " Damien Le Moal
` (18 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Modify the function tw_scsi_queue_lck() of the 3w-xxxx driver to use
scsi_set_sense() and replace the hard-coded additional sense codes and
additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/3w-xxxx.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c
index c68678fa72c1..1e1692f776d3 100644
--- a/drivers/scsi/3w-xxxx.c
+++ b/drivers/scsi/3w-xxxx.c
@@ -1977,7 +1977,8 @@ static enum scsi_qc_status tw_scsi_queue_lck(struct scsi_cmnd *SCpnt)
printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
tw_dev->state[request_id] = TW_S_COMPLETED;
tw_state_request_finish(tw_dev, request_id);
- scsi_build_sense(SCpnt, 1, ILLEGAL_REQUEST, 0x20, 0);
+ scsi_set_sense(SCpnt, 1, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
done(SCpnt);
retval = 0;
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 20/37] scsi: leapraid: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (18 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 19/37] scsi: 3w-xxxx: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:18 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 21/37] scsi: megaraid: " Damien Le Moal
` (17 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the leapraid driver to use the 16-bits sense_code field of
struct scsi_sense_hdr and replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
With this change, the locally defined macros for ASC and ASCQ values are
deleted.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/leapraid/leapraid_func.h | 7 -------
drivers/scsi/leapraid/leapraid_os.c | 15 +++++++--------
2 files changed, 7 insertions(+), 15 deletions(-)
diff --git a/drivers/scsi/leapraid/leapraid_func.h b/drivers/scsi/leapraid/leapraid_func.h
index 4c0b9ca728d8..879d8cd5ec03 100644
--- a/drivers/scsi/leapraid/leapraid_func.h
+++ b/drivers/scsi/leapraid/leapraid_func.h
@@ -113,7 +113,6 @@
#define DESC_FORMAT_THRESHOLD 0x72
#define SENSE_KEY_MASK 0x0F
#define SCSI_SENSE_RESPONSE_CODE_MASK 0x7F
-#define ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED 0x5D
#define LEAPRAID_LARGE_DISK_THRESHOLD 0x200000UL
#define LEAPRAID_LARGE_DISK_HEADS 255
#define LEAPRAID_LARGE_DISK_SECTORS 63
@@ -126,12 +125,6 @@
#define LEAPRAID_SCSI_HOST_SHIFT 16
#define LEAPRAID_SCSI_DRIVER_SHIFT 24
-/* SCSI ASC/ASCQ definitions. */
-#define LEAPRAID_SCSI_ASCQ_DEFAULT 0x00
-#define LEAPRAID_SCSI_ASC_POWER_ON_RESET 0x29
-#define LEAPRAID_SCSI_ASC_INVALID_CMD_CODE 0x20
-#define LEAPRAID_SCSI_ASCQ_POWER_ON_RESET 0x07
-
/* VPD Page 0x89 (ATA Information). */
#define LEAPRAID_VPD_PAGE_ATA_INFO 0x89
#define LEAPRAID_VPD_PG89_MAX_LEN 255
diff --git a/drivers/scsi/leapraid/leapraid_os.c b/drivers/scsi/leapraid/leapraid_os.c
index ee3242779dfd..eb8b11439923 100644
--- a/drivers/scsi/leapraid/leapraid_os.c
+++ b/drivers/scsi/leapraid/leapraid_os.c
@@ -382,9 +382,8 @@ static void leapraid_handle_data_underrun(
} else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
scsiio_rep->scsi_state = LEAPRAID_SCSI_STATE_AUTOSENSE_VALID;
scsiio_rep->scsi_status = SAM_STAT_CHECK_CONDITION;
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST,
- LEAPRAID_SCSI_ASC_INVALID_CMD_CODE,
- LEAPRAID_SCSI_ASCQ_DEFAULT);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
}
}
@@ -515,8 +514,9 @@ static void leapraid_scsiio_done_dispatch(
&sshdr))
dev_warn(&adapter->pdev->dev,
"Sense: key=0x%x asc=0x%x ascq=0x%x\n",
- sshdr.sense_key, sshdr.asc,
- sshdr.ascq);
+ sshdr.sense_key,
+ scsi_sense_asc(&sshdr),
+ scsi_sense_ascq(&sshdr));
else
dev_warn(&adapter->pdev->dev,
"Sense: Invalid sense data\n");
@@ -810,9 +810,8 @@ static bool leapraid_should_queuecommand(struct leapraid_adapter *adapter,
if (sdev_priv->block &&
scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY) {
- scsi_build_sense(scmd, 0, UNIT_ATTENTION,
- LEAPRAID_SCSI_ASC_POWER_ON_RESET,
- LEAPRAID_SCSI_ASCQ_POWER_ON_RESET);
+ scsi_set_sense(scmd, 0, UNIT_ATTENTION,
+ I_T_NEXUS_LOSS_OCCURRED);
goto scsiio_done;
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 20/37] scsi: leapraid: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 20/37] scsi: leapraid: " Damien Le Moal
@ 2026-08-31 2:18 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:18 UTC (permalink / raw)
To: Damien Le Moal; +Cc: linux-scsi, cassel, linux-ide, dlemoal
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] The driver synthesizes a CHECK_CONDITION for REPORT_LUNS when a data underrun occurs but fails to update `scmd->result`.
--
commit 909befd157ab89fe2f70728b01ba29158ee9d0b5
Author: Damien Le Moal <dlemoal@kernel.org>
scsi: leapraid: use 16-bits defined sense codes
This refactors the leapraid driver to use the 16-bit sense_code field
of struct scsi_sense_hdr and replaces all hard-coded additional sense
codes with enum values. It deletes the locally defined macros for ASC
and ASCQ values in favor of standard definitions.
> diff --git a/drivers/scsi/leapraid/leapraid_os.c b/drivers/scsi/leapraid/leapraid_os.c
> index ee3242779dfdf..eb8b114399231 100644
> --- a/drivers/scsi/leapraid/leapraid_os.c
> +++ b/drivers/scsi/leapraid/leapraid_os.c
[ ... ]
> @@ -382,9 +382,8 @@ static void leapraid_handle_data_underrun(
> } else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
> scsiio_rep->scsi_state = LEAPRAID_SCSI_STATE_AUTOSENSE_VALID;
> scsiio_rep->scsi_status = SAM_STAT_CHECK_CONDITION;
> - scsi_build_sense(scmd, 0, ILLEGAL_REQUEST,
> - LEAPRAID_SCSI_ASC_INVALID_CMD_CODE,
> - LEAPRAID_SCSI_ASCQ_DEFAULT);
> + scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
> + INVALID_COMMAND_OP_CODE);
[Severity: High]
This is a pre-existing issue, but should this code also update scmd->result
with the new status?
Because scmd->result is not updated with SAM_STAT_CHECK_CONDITION in
leapraid_handle_data_underrun(), it retains the initial DID_OK | scsi_status
(which is typically 0 here).
Doesn't this cause leapraid_scsiio_done_dispatch() to return early, hiding
the synthesized ILLEGAL_REQUEST sense data from the SCSI midlayer and
breaking LUN discovery when a data underrun occurs?
> }
> }
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=20
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 21/37] scsi: megaraid: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (19 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 20/37] scsi: leapraid: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 22/37] scsi: myrX: " Damien Le Moal
` (16 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the megaraid driver to use the scsi_set_sense() function and
replace all hard-coded additional sense codes and additional sense code
qualifiers with the enum values defined in include/scsi/scsi_sense.h. This
helps with code clarity as the sense codes being processed are easier to
test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/megaraid.c | 8 +++++---
drivers/scsi/megaraid/mega_common.h | 2 --
drivers/scsi/megaraid/megaraid_mbox.c | 12 +++++++-----
3 files changed, 12 insertions(+), 10 deletions(-)
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 9476a0d2c72d..a4079866f747 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -1592,9 +1592,11 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
epthru->reqsensearea, 14);
cmd->result = SAM_STAT_CHECK_CONDITION;
- } else
- scsi_build_sense(cmd, 0,
- ABORTED_COMMAND, 0, 0);
+ } else {
+ scsi_set_sense(cmd, 0,
+ ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION);
+ }
}
break;
diff --git a/drivers/scsi/megaraid/mega_common.h b/drivers/scsi/megaraid/mega_common.h
index 2ad0aa2f837d..8e58599d5685 100644
--- a/drivers/scsi/megaraid/mega_common.h
+++ b/drivers/scsi/megaraid/mega_common.h
@@ -37,8 +37,6 @@
#define PCI_CONF_AMISIG64 0xa4
#define MEGA_SCSI_INQ_EVPD 1
-#define MEGA_INVALID_FIELD_IN_CDB 0x24
-
/**
* scb_t - scsi command control block
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index ce89032a5a74..b7319282e3c5 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -1577,8 +1577,8 @@ megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp,
}
if (scp->cmnd[1] & MEGA_SCSI_INQ_EVPD) {
- scsi_build_sense(scp, 0, ILLEGAL_REQUEST,
- MEGA_INVALID_FIELD_IN_CDB, 0);
+ scsi_set_sense(scp, 0, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB);
return NULL;
}
@@ -2311,9 +2311,11 @@ megaraid_mbox_dpc(unsigned long devp)
epthru->reqsensearea, 14);
scp->result = SAM_STAT_CHECK_CONDITION;
- } else
- scsi_build_sense(scp, 0,
- ABORTED_COMMAND, 0, 0);
+ } else {
+ scsi_set_sense(scp, 0,
+ ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION);
+ }
}
break;
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 22/37] scsi: myrX: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (20 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 21/37] scsi: megaraid: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:30 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 23/37] scsi: smartpqi: " Damien Le Moal
` (15 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the Mylex RAID controller driver to use scsi_set_sense() and the
16-bits sense_code field of struct scsi_sense_hdr and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/myrb.c | 67 +++++++++++++++++++++++----------------------
drivers/scsi/myrs.c | 23 ++++++++++------
2 files changed, 48 insertions(+), 42 deletions(-)
diff --git a/drivers/scsi/myrb.c b/drivers/scsi/myrb.c
index 3678b66310ed..e7d796add986 100644
--- a/drivers/scsi/myrb.c
+++ b/drivers/scsi/myrb.c
@@ -314,17 +314,19 @@ static void myrb_get_event(struct myrb_hba *cb, unsigned int event)
scsi_normalize_sense(ev_buf->sense, 32, &sshdr);
if (sshdr.sense_key == VENDOR_SPECIFIC &&
- sshdr.asc == 0x80 &&
- sshdr.ascq < ARRAY_SIZE(myrb_event_msg))
+ scsi_sense_asc(&sshdr) == 0x80 &&
+ scsi_sense_ascq(&sshdr) < ARRAY_SIZE(myrb_event_msg))
shost_printk(KERN_CRIT, cb->host,
"Physical drive %d:%d: %s\n",
ev_buf->channel, ev_buf->target,
- myrb_event_msg[sshdr.ascq]);
+ myrb_event_msg[scsi_sense_ascq(&sshdr)]);
else
shost_printk(KERN_CRIT, cb->host,
"Physical drive %d:%d: Sense: %X/%02X/%02X\n",
ev_buf->channel, ev_buf->target,
- sshdr.sense_key, sshdr.asc, sshdr.ascq);
+ sshdr.sense_key,
+ scsi_sense_asc(&sshdr),
+ scsi_sense_ascq(&sshdr));
}
dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_log_entry),
@@ -1398,7 +1400,7 @@ myrb_mode_sense(struct myrb_hba *cb, struct scsi_cmnd *scmd,
static void myrb_request_sense(struct myrb_hba *cb,
struct scsi_cmnd *scmd)
{
- scsi_build_sense(scmd, 0, NO_SENSE, 0, 0);
+ scsi_set_sense(scmd, 0, NO_SENSE, NO_ADDITIONAL_SENSE_INFORMATION);
scsi_sg_copy_from_buffer(scmd, scmd->sense_buffer,
SCSI_SENSE_BUFFERSIZE);
}
@@ -1446,8 +1448,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case INQUIRY:
if (scmd->cmnd[1] & 1) {
- /* Illegal request, invalid field in CDB */
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB);
} else {
myrb_inquiry(cb, scmd);
scmd->result = (DID_OK << 16);
@@ -1461,8 +1463,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
case MODE_SENSE:
if ((scmd->cmnd[2] & 0x3F) != 0x3F &&
(scmd->cmnd[2] & 0x3F) != 0x08) {
- /* Illegal request, invalid field in CDB */
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB);
} else {
myrb_mode_sense(cb, scmd, ldev_info);
scmd->result = (DID_OK << 16);
@@ -1472,15 +1474,15 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
case READ_CAPACITY:
if ((scmd->cmnd[1] & 1) ||
(scmd->cmnd[8] & 1)) {
- /* Illegal request, invalid field in CDB */
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB);
scsi_done(scmd);
return 0;
}
lba = get_unaligned_be32(&scmd->cmnd[2]);
if (lba) {
- /* Illegal request, invalid field in CDB */
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB);
scsi_done(scmd);
return 0;
}
@@ -1493,8 +1495,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case SEND_DIAGNOSTIC:
if (scmd->cmnd[1] != 0x04) {
- /* Illegal request, invalid field in CDB */
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB);
} else {
/* Assume good status */
scmd->result = (DID_OK << 16);
@@ -1503,8 +1505,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case READ_6:
if (ldev_info->state == MYRB_DEVICE_WO) {
- /* Data protect, attempt to read invalid data */
- scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
+ scsi_set_sense(scmd, 0, DATA_PROTECT,
+ ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@@ -1517,8 +1519,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
break;
case READ_10:
if (ldev_info->state == MYRB_DEVICE_WO) {
- /* Data protect, attempt to read invalid data */
- scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
+ scsi_set_sense(scmd, 0, DATA_PROTECT,
+ ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@@ -1531,8 +1533,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
break;
case READ_12:
if (ldev_info->state == MYRB_DEVICE_WO) {
- /* Data protect, attempt to read invalid data */
- scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
+ scsi_set_sense(scmd, 0, DATA_PROTECT,
+ ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@@ -1544,8 +1546,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
block_cnt = get_unaligned_be32(&scmd->cmnd[6]);
break;
default:
- /* Illegal request, invalid opcode */
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x20, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
scsi_done(scmd);
return 0;
}
@@ -2328,20 +2330,19 @@ static void myrb_handle_scsi(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk,
dev_dbg(&scmd->device->sdev_gendev,
"Bad Data Encountered\n");
if (scmd->sc_data_direction == DMA_FROM_DEVICE)
- /* Unrecovered read error */
- scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x11, 0);
+ scsi_set_sense(scmd, 0, MEDIUM_ERROR,
+ UNRECOVERED_READ_ERROR);
else
- /* Write error */
- scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x0C, 0);
+ scsi_set_sense(scmd, 0, MEDIUM_ERROR, WRITE_ERROR);
break;
case MYRB_STATUS_IRRECOVERABLE_DATA_ERROR:
scmd_printk(KERN_ERR, scmd, "Irrecoverable Data Error\n");
if (scmd->sc_data_direction == DMA_FROM_DEVICE)
- /* Unrecovered read error, auto-reallocation failed */
- scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x11, 0x04);
+ scsi_set_sense(scmd, 0, MEDIUM_ERROR,
+ UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED);
else
- /* Write error, auto-reallocation failed */
- scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x0C, 0x02);
+ scsi_set_sense(scmd, 0, MEDIUM_ERROR,
+ WRITE_ERROR_AUTO_REALLOCATION_FAILED);
break;
case MYRB_STATUS_LDRV_NONEXISTENT_OR_OFFLINE:
dev_dbg(&scmd->device->sdev_gendev,
@@ -2351,8 +2352,8 @@ static void myrb_handle_scsi(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk,
case MYRB_STATUS_ACCESS_BEYOND_END_OF_LDRV:
dev_dbg(&scmd->device->sdev_gendev,
"Attempt to Access Beyond End of Logical Drive");
- /* Logical block address out of range */
- scsi_build_sense(scmd, 0, NOT_READY, 0x21, 0);
+ scsi_set_sense(scmd, 0, NOT_READY,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
break;
case MYRB_STATUS_DEVICE_NONRESPONSIVE:
dev_dbg(&scmd->device->sdev_gendev, "Device nonresponsive\n");
diff --git a/drivers/scsi/myrs.c b/drivers/scsi/myrs.c
index afd68225221a..1192b01fab8e 100644
--- a/drivers/scsi/myrs.c
+++ b/drivers/scsi/myrs.c
@@ -816,7 +816,7 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
struct Scsi_Host *shost = cs->host;
struct scsi_device *sdev;
struct scsi_sense_hdr sshdr = {0};
- unsigned char sense_info[4];
+ unsigned char asc, sense_info[4];
unsigned char cmd_specific[4];
if (ev->ev_code == 0x1C) {
@@ -829,9 +829,11 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
memcpy(cmd_specific, &ev->sense_data[7], 4);
}
}
+ asc = scsi_sense_asc(&sshdr);
if (sshdr.sense_key == VENDOR_SPECIFIC &&
- (sshdr.asc == 0x80 || sshdr.asc == 0x81))
- ev->ev_code = ((sshdr.asc - 0x80) << 8 | sshdr.ascq);
+ (asc == 0x80 || asc == 0x81))
+ ev->ev_code = scsi_sense_code(asc - 0x80,
+ scsi_sense_ascq(&sshdr));
while (true) {
ev_code = myrs_ev_list[ev_idx].ev_code;
if (ev_code == ev->ev_code || ev_code == 0)
@@ -891,8 +893,9 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
case 'S':
if (sshdr.sense_key == NO_SENSE ||
(sshdr.sense_key == NOT_READY &&
- sshdr.asc == 0x04 && (sshdr.ascq == 0x01 ||
- sshdr.ascq == 0x02)))
+ (sshdr.sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY ||
+ sshdr.sense_code ==
+ LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)))
break;
shost_printk(KERN_INFO, shost,
"event %d: Physical Device %d:%d %s\n",
@@ -900,7 +903,8 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
shost_printk(KERN_INFO, shost,
"Physical Device %d:%d Sense Key = %X, ASC = %02X, ASCQ = %02X\n",
ev->channel, ev->target,
- sshdr.sense_key, sshdr.asc, sshdr.ascq);
+ sshdr.sense_key, scsi_sense_asc(&sshdr),
+ scsi_sense_ascq(&sshdr));
shost_printk(KERN_INFO, shost,
"Physical Device %d:%d Sense Information = %02X%02X%02X%02X %02X%02X%02X%02X\n",
ev->channel, ev->target,
@@ -1603,7 +1607,8 @@ static enum scsi_qc_status myrs_queuecommand(struct Scsi_Host *shost,
switch (scmd->cmnd[0]) {
case REPORT_LUNS:
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x20, 0x0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
scsi_done(scmd);
return 0;
case MODE_SENSE:
@@ -1612,8 +1617,8 @@ static enum scsi_qc_status myrs_queuecommand(struct Scsi_Host *shost,
if ((scmd->cmnd[2] & 0x3F) != 0x3F &&
(scmd->cmnd[2] & 0x3F) != 0x08) {
- /* Illegal request, invalid field in CDB */
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB);
} else {
myrs_mode_sense(cs, scmd, ldev_info);
scmd->result = (DID_OK << 16);
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 22/37] scsi: myrX: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 22/37] scsi: myrX: " Damien Le Moal
@ 2026-08-31 2:30 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:30 UTC (permalink / raw)
To: Damien Le Moal; +Cc: linux-scsi, cassel, dlemoal, linux-ide
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Pre-existing issues:
- [High] Missing check for scsi_dma_map() returning an error (-ENOMEM), leading to out-of-bounds DMA, uninitialized DMA memory usage, or memory corruption.
- [High] Missing scsi_done() call on REQUEST_SENSE command completion.
--
commit 3566a2a2b43f8a90937be5314f52e6262a307f13
Author: Damien Le Moal <dlemoal@kernel.org>
scsi: myrX: use 16-bits defined sense codes
Refactor the Mylex RAID controller driver to use scsi_set_sense() and the
16-bits sense_code field of struct scsi_sense_hdr and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
> diff --git a/drivers/scsi/myrb.c b/drivers/scsi/myrb.c
> index 3678b66310ed0..e7d796add9864 100644
> --- a/drivers/scsi/myrb.c
> +++ b/drivers/scsi/myrb.c
[ ... ]
> @@ -1493,8 +1495,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
> return 0;
[Severity: High]
This isn't a bug introduced by this patch, but does this code miss a call to
scsi_done() on REQUEST_SENSE command completion?
A SCSI command completes but its completion callback is never invoked. The block
layer and SCSI midlayer are left waiting indefinitely for the command to finish,
leading to an I/O hang followed by SCSI timeout and error recovery:
drivers/scsi/myrb.c:myrb_ldev_queuecommand() {
...
case REQUEST_SENSE:
myrb_request_sense(cb, scmd);
scmd->result = (DID_OK << 16);
return 0;
...
}
> case SEND_DIAGNOSTIC:
> if (scmd->cmnd[1] != 0x04) {
> - /* Illegal request, invalid field in CDB */
> - scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
> + scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
> + INVALID_FIELD_IN_CDB);
> } else {
[ ... ]
> @@ -1544,8 +1546,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
> block_cnt = get_unaligned_be32(&scmd->cmnd[6]);
> break;
> default:
> - /* Illegal request, invalid opcode */
> - scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x20, 0);
> + scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
> + INVALID_COMMAND_OP_CODE);
> scsi_done(scmd);
> return 0;
> }
[Severity: High]
This is a pre-existing issue, but does this code proceed without checking if
scsi_dma_map() returned a negative error code (like -ENOMEM)?
If scsi_dma_map() fails, the driver does not check for < 0 and assigns the
negative value to mbox->type5.sg_count (which is cast to an unsigned 8-bit
integer, e.g. -12 becomes 244):
drivers/scsi/myrb.c:myrb_ldev_queuecommand() {
...
nsge = scsi_dma_map(scmd);
if (nsge == 1) {
...
} else {
...
mbox->type5.sg_count = nsge;
...
}
This would cause the hardware to execute a scatter-gather DMA reading hundreds
of uninitialized SGEs from memory, leading to wild out-of-bounds DMA
reads/writes, memory corruption, or IOMMU faults.
A similar issue exists in drivers/scsi/myrs.c where the result is only checked
against 1:
drivers/scsi/myrs.c:myrs_queuecommand() {
...
nsge = scsi_dma_map(scmd);
if (nsge == 1) {
...
} else {
...
if (nsge > 2) {
...
}
Are these missing failure checks for scsi_dma_map() intentional?
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=22
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 23/37] scsi: smartpqi: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (21 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 22/37] scsi: myrX: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 24/37] scsi: qla2xxx: " Damien Le Moal
` (14 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the smartpqi driver to use the 16-bits sense_code field of
struct scsi_sense_hdr and replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/smartpqi/smartpqi_init.c | 31 ++++++++++++++++-----------
1 file changed, 18 insertions(+), 13 deletions(-)
diff --git a/drivers/scsi/smartpqi/smartpqi_init.c b/drivers/scsi/smartpqi/smartpqi_init.c
index 140e8a6addbe..d8d0fe915805 100644
--- a/drivers/scsi/smartpqi/smartpqi_init.c
+++ b/drivers/scsi/smartpqi/smartpqi_init.c
@@ -3249,15 +3249,15 @@ static void pqi_process_raid_io_error(struct pqi_io_request *io_request)
sense_data_length = sizeof(error_info->data);
if (scsi_status == SAM_STAT_CHECK_CONDITION &&
- scsi_normalize_sense(error_info->data,
- sense_data_length, &sshdr) &&
- sshdr.sense_key == HARDWARE_ERROR &&
- sshdr.asc == 0x3e) {
+ scsi_normalize_sense(error_info->data,
+ sense_data_length, &sshdr) &&
+ sshdr.sense_key == HARDWARE_ERROR &&
+ scsi_sense_asc(&sshdr) == ASC_LU_HAS_NOT_SELF_CONFIGURED_YET) {
struct pqi_ctrl_info *ctrl_info = shost_to_hba(scmd->device->host);
struct pqi_scsi_dev *device = scmd->device->hostdata;
- switch (sshdr.ascq) {
- case 0x1: /* LOGICAL UNIT FAILURE */
+ switch (sshdr.sense_code) {
+ case LU_FAILURE:
if (printk_ratelimit())
scmd_printk(KERN_ERR, scmd, "received 'logical unit failure' from controller for scsi %d:%d:%d:%d\n",
ctrl_info->scsi_host->host_no, device->bus, device->target, device->lun);
@@ -3265,10 +3265,15 @@ static void pqi_process_raid_io_error(struct pqi_io_request *io_request)
host_byte = DID_NO_CONNECT;
break;
- default: /* See http://www.t10.org/lists/asc-num.htm#ASC_3E */
+ default:
+ /* include/scsi/scsi_sense.h */
if (printk_ratelimit())
- scmd_printk(KERN_ERR, scmd, "received unhandled error %d from controller for scsi %d:%d:%d:%d\n",
- sshdr.ascq, ctrl_info->scsi_host->host_no, device->bus, device->target, device->lun);
+ scmd_printk(KERN_ERR, scmd,
+ "received unhandled error %d from controller for scsi %d:%d:%d:%d\n",
+ scsi_sense_ascq(&sshdr),
+ ctrl_info->scsi_host->host_no,
+ device->bus, device->target,
+ device->lun);
break;
}
}
@@ -3286,11 +3291,11 @@ static void pqi_process_raid_io_error(struct pqi_io_request *io_request)
sense_data_length &&
scsi_normalize_sense(error_info->data, sense_data_length, &sshdr) &&
sshdr.sense_key == ILLEGAL_REQUEST &&
- sshdr.asc == 0x26 &&
- sshdr.ascq == 0x0) {
+ sshdr.sense_code == INVALID_FIELD_IN_PARAMETER_LIST) {
host_byte = DID_NO_CONNECT;
pqi_take_device_offline(scmd->device, "AIO");
- scsi_build_sense_buffer(0, scmd->sense_buffer, HARDWARE_ERROR, 0x3e, 0x1);
+ scsi_set_sense_buffer(0, scmd->sense_buffer, HARDWARE_ERROR,
+ LU_FAILURE);
}
scmd->result = scsi_status;
@@ -3380,7 +3385,7 @@ static void pqi_process_aio_io_error(struct pqi_io_request *io_request)
}
if (device_offline && sense_data_length == 0)
- scsi_build_sense(scmd, 0, HARDWARE_ERROR, 0x3e, 0x1);
+ scsi_set_sense(scmd, 0, HARDWARE_ERROR, LU_FAILURE);
scmd->result = scsi_status;
set_host_byte(scmd, host_byte);
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 24/37] scsi: qla2xxx: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (22 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 23/37] scsi: smartpqi: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 25/37] scsi: ps3rom: " Damien Le Moal
` (13 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the qla2xxx driver to use scsi_set_sense() and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/qla2xxx/qla_isr.c | 9 ++++++---
1 file changed, 6 insertions(+), 3 deletions(-)
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 63b70d4abbf0..89c2af3fee4f 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -3263,21 +3263,24 @@ qla2x00_handle_dif_error(srb_t *sp, void *pkt)
/* check guard */
if (e_guard != a_guard) {
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}
/* check ref tag */
if (e_ref_tag != a_ref_tag) {
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}
/* check appl tag */
if (e_app_tag != a_app_tag) {
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 25/37] scsi: ps3rom: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (23 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 24/37] scsi: qla2xxx: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 26/37] scsi: lpfc: " Damien Le Moal
` (12 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the PS3 DVD driver to use scsi_set_sense() and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/ps3rom.c | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/drivers/scsi/ps3rom.c b/drivers/scsi/ps3rom.c
index a9c727d22931..c63c581b493c 100644
--- a/drivers/scsi/ps3rom.c
+++ b/drivers/scsi/ps3rom.c
@@ -233,7 +233,8 @@ static enum scsi_qc_status ps3rom_queuecommand_lck(struct scsi_cmnd *cmd)
}
if (res) {
- scsi_build_sense(cmd, 0, ILLEGAL_REQUEST, 0, 0);
+ scsi_set_sense(cmd, 0, ILLEGAL_REQUEST,
+ NO_ADDITIONAL_SENSE_INFORMATION);
cmd->result = res;
priv->curr_cmd = NULL;
scsi_done(cmd);
@@ -316,7 +317,7 @@ static irqreturn_t ps3rom_interrupt(int irq, void *data)
goto done;
}
- scsi_build_sense(cmd, 0, sense_key, asc, ascq);
+ scsi_set_sense(cmd, 0, sense_key, scsi_sense_code(asc, ascq));
done:
priv->curr_cmd = NULL;
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 26/37] scsi: lpfc: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (24 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 25/37] scsi: ps3rom: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 27/37] scsi: stex: " Damien Le Moal
` (11 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the lpfc driver to use scsi_set_sense() and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/lpfc/lpfc_scsi.c | 18 ++++++++++++------
1 file changed, 12 insertions(+), 6 deletions(-)
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 8a795c65e3c3..849d4de91b38 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -2848,7 +2848,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
}
out:
if (err_type == BGS_GUARD_ERR_MASK) {
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_guard_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@@ -2857,7 +2858,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
sum, guard_tag);
} else if (err_type == BGS_REFTAG_ERR_MASK) {
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_reftag_err_cnt++;
@@ -2867,7 +2869,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
ref_tag, start_ref_tag);
} else if (err_type == BGS_APPTAG_ERR_MASK) {
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_apptag_err_cnt++;
@@ -2970,7 +2973,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_guard_err(bgstat)) {
ret = 1;
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_guard_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@@ -2983,7 +2987,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_reftag_err(bgstat)) {
ret = 1;
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_reftag_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@@ -2996,7 +3001,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_apptag_err(bgstat)) {
ret = 1;
- scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
+ scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_apptag_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 27/37] scsi: stex: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (25 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 26/37] scsi: lpfc: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 28/37] scsi: mvumi: " Damien Le Moal
` (10 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the stex driver to use scsi_set_sense() and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/stex.c | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/drivers/scsi/stex.c b/drivers/scsi/stex.c
index 6aeeb338633d..056ff0eb5455 100644
--- a/drivers/scsi/stex.c
+++ b/drivers/scsi/stex.c
@@ -401,8 +401,7 @@ static struct status_msg *stex_get_status(struct st_hba *hba)
static void stex_invalid_field(struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *))
{
- /* "Invalid field in cdb" */
- scsi_build_sense(cmd, 0, ILLEGAL_REQUEST, 0x24, 0x0);
+ scsi_set_sense(cmd, 0, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
done(cmd);
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 28/37] scsi: mvumi: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (26 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 27/37] scsi: stex: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:24 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 29/37] scsi: libiscsi: " Damien Le Moal
` (9 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the Marvell UMI driver to use scsi_set_sense() and replace all
hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h. This helps with
code clarity as the sense codes being processed are easier to test and
self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/mvumi.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/scsi/mvumi.c b/drivers/scsi/mvumi.c
index e70d336b4ab3..a5bd3258a399 100644
--- a/drivers/scsi/mvumi.c
+++ b/drivers/scsi/mvumi.c
@@ -2067,7 +2067,7 @@ static unsigned char mvumi_build_frame(struct mvumi_hba *mhba,
return 0;
error:
- scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
+ scsi_set_sense(scmd, 0, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return -1;
}
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 28/37] scsi: mvumi: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 28/37] scsi: mvumi: " Damien Le Moal
@ 2026-08-31 2:24 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:24 UTC (permalink / raw)
To: Damien Le Moal; +Cc: dlemoal, cassel, linux-scsi, linux-ide
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Unhandled dma_map_sg failure in mvumi_make_sgl
--
commit 741665dea239f5c02068d60c93684dd2fc4d00e6
Author: Damien Le Moal <dlemoal@kernel.org>
scsi: mvumi: use 16-bits defined sense codes
This refactors the Marvell UMI driver to use scsi_set_sense() and replaces
all hard-coded additional sense codes and additional sense code qualifiers
with the enum values defined in include/scsi/scsi_sense.h to improve code
clarity.
> diff --git a/drivers/scsi/mvumi.c b/drivers/scsi/mvumi.c
> index e70d336b4ab39..a5bd3258a3994 100644
> --- a/drivers/scsi/mvumi.c
> +++ b/drivers/scsi/mvumi.c
> @@ -2067,7 +2067,7 @@ static unsigned char mvumi_build_frame(struct mvumi_hba *mhba,
> return 0;
>
> error:
> - scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
> + scsi_set_sense(scmd, 0, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
[Severity: High]
This isn't a bug introduced by this patch, but there is a pre-existing issue
in the error handling path leading here.
In mvumi_make_sgl(), which is called just before the error label, if
dma_map_sg() fails it returns 0. However, mvumi_make_sgl() incorrectly
checks for failure by checking if the returned count is greater than max_sge:
drivers/scsi/mvumi.c:mvumi_make_sgl() {
...
*sg_count = dma_map_sg(&mhba->pdev->dev, scsi_sglist(scmd), sgnum,
scmd->sc_data_direction);
if (*sg_count > mhba->max_sge) {
...
}
Since 0 is not greater than max_sge, the check is bypassed. mvumi_make_sgl()
then skips the scatterlist loop and incorrectly returns 0 (success).
mvumi_build_frame() proceeds to pass the command to the firmware with a
non-zero data_transfer_length (from scsi_bufflen) but 0 scatter-gather
entries.
Could this crash or wedge the Marvell UMI firmware by sending a malformed
command?
> return -1;
> }
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=28
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 29/37] scsi: libiscsi: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (27 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 28/37] scsi: mvumi: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 30/37] scsi: ibmvscsi_tgt: " Damien Le Moal
` (8 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor libiscsi to use scsi_set_sense() and replace all hard-coded
additional sense codes and additional sense code qualifiers with the enum
values defined in include/scsi/scsi_sense.h. This helps with code clarity
as the sense codes being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/libiscsi.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index 5cbc51899de0..7637aacd6037 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -892,7 +892,8 @@ static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
ascq = session->tt->check_protection(task, §or);
if (ascq) {
- scsi_build_sense(sc, 1, ILLEGAL_REQUEST, 0x10, ascq);
+ scsi_set_sense(sc, 1, ILLEGAL_REQUEST,
+ scsi_sense_code(ASC_ID_CRC_OR_ECC_ERROR, ascq));
scsi_set_sense_information(sc->sense_buffer,
SCSI_SENSE_BUFFERSIZE,
sector);
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 30/37] scsi: ibmvscsi_tgt: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (28 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 29/37] scsi: libiscsi: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:27 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 31/37] scsi: scsi_debug: " Damien Le Moal
` (7 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the IBM virtual SCSI target driver to use scsi_set_sense_buffer()
and replace all hard-coded additional sense codes and additional sense
code qualifiers with the enum values defined in include/scsi/scsi_sense.h.
This helps with code clarity as the sense codes being processed are easier
to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c b/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c
index 61f682800765..e2af90b6da39 100644
--- a/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c
+++ b/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c
@@ -3757,9 +3757,8 @@ static int ibmvscsis_queue_data_in(struct se_cmd *se_cmd)
dev_err(&vscsi->dev, "srp_transfer_data failed: %d\n", rc);
se_cmd->scsi_sense_length = 18;
memset(se_cmd->sense_buffer, 0, se_cmd->scsi_sense_length);
- /* Logical Unit Communication Time-out asc/ascq = 0x0801 */
- scsi_build_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
- 0x08, 0x01);
+ scsi_set_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
+ LU_COMMUNICATION_TIMEOUT);
}
srp_build_response(vscsi, cmd, &len);
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 30/37] scsi: ibmvscsi_tgt: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 30/37] scsi: ibmvscsi_tgt: " Damien Le Moal
@ 2026-08-31 2:27 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:27 UTC (permalink / raw)
To: Damien Le Moal; +Cc: dlemoal, linux-ide, cassel, linux-scsi
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [Critical] Missing `SAM_STAT_CHECK_CONDITION` assignment causes sense data to be ignored on DMA failure, resulting in silent data corruption.
--
commit 9055c36d0afa69c58f35f6c4cc3a76397be71645
Author: Damien Le Moal <dlemoal@kernel.org>
scsi: ibmvscsi_tgt: use 16-bits defined sense codes
This commit refactors the IBM virtual SCSI target driver to use
scsi_set_sense_buffer() and defined sense code enums instead of
hard-coded values. This improves code clarity and self-documentation
without intending any functional changes.
> diff --git a/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c b/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c
> index 61f6828007654..e2af90b6da39b 100644
> --- a/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c
> +++ b/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c
> @@ -3757,9 +3757,8 @@ static int ibmvscsis_queue_data_in(struct se_cmd *se_cmd)
> dev_err(&vscsi->dev, "srp_transfer_data failed: %d\n", rc);
> se_cmd->scsi_sense_length = 18;
> memset(se_cmd->sense_buffer, 0, se_cmd->scsi_sense_length);
> - /* Logical Unit Communication Time-out asc/ascq = 0x0801 */
> - scsi_build_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
> - 0x08, 0x01);
> + scsi_set_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
> + LU_COMMUNICATION_TIMEOUT);
> }
>
> srp_build_response(vscsi, cmd, &len);
[Severity: Critical]
This is a pre-existing issue, but does this error path properly notify the
initiator of the failure?
When srp_transfer_data() fails in ibmvscsis_queue_data_in(), the sense
buffer is built, but it appears se_cmd->scsi_status is never set to
SAM_STAT_CHECK_CONDITION.
Because the status remains 0 (SAM_STAT_GOOD), when srp_build_response()
is subsequently called, the check for rsp->status evaluates to false:
srp_build_response()
...
rsp->status = ibmvscsis_fast_fail(vscsi, cmd);
if (rsp->status) {
...
if (se_cmd->scsi_sense_length && se_cmd->sense_buffer) {
rsp->sense_data_len = cpu_to_be32(se_cmd->scsi_sense_length);
...
This causes the built sense data to be skipped, returning a success
response to the initiator despite the DMA transfer failing. Can this lead
to silent data corruption where the initiator incorrectly assumes the read
was successful?
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=30
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 31/37] scsi: scsi_debug: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (29 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 30/37] scsi: ibmvscsi_tgt: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 32/37] scsi: hpsa: " Damien Le Moal
` (6 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the scsi_debug driver to replace hard-coded additional sense
codes and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
The functions mk_sense_buffer() and mk_sense_info_tape() are modified to
take a 16-bits sense code as argument.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/scsi_debug.c | 332 ++++++++++++++++++++------------------
1 file changed, 171 insertions(+), 161 deletions(-)
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 3346562275f8..b723f0334b42 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -67,9 +67,6 @@ static const char *sdebug_version_date = "20210520";
#define MY_NAME "scsi_debug"
-/* Additional Sense Code Qualifier (ASCQ) */
-#define ACK_NAK_TO 0x3
-
/* Default values for driver parameters */
#define DEF_NUM_HOST 1
#define DEF_NUM_TGTS 1
@@ -1320,9 +1317,13 @@ static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
sdev_printk(KERN_ERR, scp->device, "sense_buffer is NULL\n");
return;
}
- asc = c_d ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST;
+ if (c_d)
+ asc = ASC_INVALID_FIELD_IN_CDB;
+ else
+ asc = ASC_INVALID_FIELD_IN_PARAMETER_LIST;
memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
- scsi_build_sense(scp, sdebug_dsense, ILLEGAL_REQUEST, asc, 0);
+ scsi_set_sense(scp, sdebug_dsense, ILLEGAL_REQUEST,
+ scsi_sense_code(asc, 0));
memset(sks, 0, sizeof(sks));
sks[0] = 0x80;
if (c_d)
@@ -1346,7 +1347,7 @@ static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
my_name, asc, c_d ? 'C' : 'D', in_byte, in_bit);
}
-static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
+static void mk_sense_buffer(struct scsi_cmnd *scp, u8 key, u16 code)
{
if (!scp->sense_buffer) {
sdev_printk(KERN_ERR, scp->device, "sense_buffer is NULL\n");
@@ -1354,16 +1355,16 @@ static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
}
memset(scp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
- scsi_build_sense(scp, sdebug_dsense, key, asc, asq);
+ scsi_set_sense(scp, sdebug_dsense, key, code);
if (sdebug_verbose)
sdev_printk(KERN_INFO, scp->device,
- "%s: [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
- my_name, key, asc, asq);
+ "%s: [sense_key,sense_code]: [0x%02x,0x%04x]\n",
+ my_name, key, code);
}
/* Sense data that has information fields for tapes */
-static void mk_sense_info_tape(struct scsi_cmnd *scp, int key, int asc, int asq,
+static void mk_sense_info_tape(struct scsi_cmnd *scp, u8 key, u16 code,
unsigned int information, unsigned char tape_flags)
{
if (!scp->sense_buffer) {
@@ -1372,7 +1373,7 @@ static void mk_sense_info_tape(struct scsi_cmnd *scp, int key, int asc, int asq,
}
memset(scp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
- scsi_build_sense(scp, /* sdebug_dsense */ 0, key, asc, asq);
+ scsi_set_sense(scp, /* sdebug_dsense */ 0, key, code);
/* only fixed format so far */
scp->sense_buffer[0] |= 0x80; /* valid */
@@ -1381,13 +1382,13 @@ static void mk_sense_info_tape(struct scsi_cmnd *scp, int key, int asc, int asq,
if (sdebug_verbose)
sdev_printk(KERN_INFO, scp->device,
- "%s: [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
- my_name, key, asc, asq);
+ "%s: [sense_key,sense_code]: [0x%02x,0x%04x]\n",
+ my_name, key, code);
}
static void mk_sense_invalid_opcode(struct scsi_cmnd *scp)
{
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_COMMAND_OP_CODE);
}
static int scsi_debug_ioctl(struct scsi_device *dev, unsigned int cmd,
@@ -1484,46 +1485,43 @@ static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
switch (k) {
case SDEBUG_UA_POR:
- mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
- POWER_ON_RESET_ASCQ);
+ mk_sense_buffer(scp, UNIT_ATTENTION,
+ POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED);
if (sdebug_verbose)
cp = "power on reset";
break;
case SDEBUG_UA_POOCCUR:
- mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
- POWER_ON_OCCURRED_ASCQ);
+ mk_sense_buffer(scp, UNIT_ATTENTION, POWER_ON_OCCURRED);
if (sdebug_verbose)
cp = "power on occurred";
break;
case SDEBUG_UA_BUS_RESET:
- mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
- BUS_RESET_ASCQ);
+ mk_sense_buffer(scp, UNIT_ATTENTION,
+ SCSI_BUS_RESET_OCCURRED);
if (sdebug_verbose)
cp = "bus reset";
break;
case SDEBUG_UA_MODE_CHANGED:
- mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
- MODE_CHANGED_ASCQ);
+ mk_sense_buffer(scp, UNIT_ATTENTION,
+ MODE_PARAMETERS_CHANGED);
if (sdebug_verbose)
cp = "mode parameters changed";
break;
case SDEBUG_UA_CAPACITY_CHANGED:
- mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
- CAPACITY_CHANGED_ASCQ);
+ mk_sense_buffer(scp, UNIT_ATTENTION,
+ CAPACITY_DATA_HAS_CHANGED);
if (sdebug_verbose)
cp = "capacity data changed";
break;
case SDEBUG_UA_MICROCODE_CHANGED:
mk_sense_buffer(scp, UNIT_ATTENTION,
- TARGET_CHANGED_ASC,
- MICROCODE_CHANGED_ASCQ);
+ MICROCODE_HAS_BEEN_CHANGED);
if (sdebug_verbose)
cp = "microcode has been changed";
break;
case SDEBUG_UA_MICROCODE_CHANGED_WO_RESET:
mk_sense_buffer(scp, UNIT_ATTENTION,
- TARGET_CHANGED_ASC,
- MICROCODE_CHANGED_WO_RESET_ASCQ);
+ MICROCODE_HAS_BEEN_CHANGED_WITHOUT_RESET);
if (sdebug_verbose)
cp = "microcode has been changed without reset";
break;
@@ -1539,14 +1537,13 @@ static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (sdebug_scsi_level >= 6) /* SPC-4 and above */
clear_luns_changed_on_target(devip);
mk_sense_buffer(scp, UNIT_ATTENTION,
- TARGET_CHANGED_ASC,
- LUNS_CHANGED_ASCQ);
+ REPORTED_LUNS_DATA_HAS_CHANGED);
if (sdebug_verbose)
cp = "reported luns data has changed";
break;
case SDEBUG_UA_NOT_READY_TO_READY:
- mk_sense_buffer(scp, UNIT_ATTENTION, UA_READY_ASC,
- 0);
+ mk_sense_buffer(scp, UNIT_ATTENTION,
+ NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED);
if (sdebug_verbose)
cp = "not ready to ready transition/media change";
break;
@@ -2184,14 +2181,14 @@ static int resp_requests(struct scsi_cmnd *scp,
if (dsense) {
arr[0] = 0x72;
arr[1] = NOT_READY;
- arr[2] = LOGICAL_UNIT_NOT_READY;
+ arr[2] = ASC_LU_NOT_READY;
arr[3] = (stopped_state == 2) ? 0x1 : 0x2;
len = 8;
} else {
arr[0] = 0x70;
arr[2] = NOT_READY; /* NO_SENSE in sense_key */
arr[7] = 0xa; /* 18 byte sense buffer */
- arr[12] = LOGICAL_UNIT_NOT_READY;
+ arr[12] = ASC_LU_NOT_READY;
arr[13] = (stopped_state == 2) ? 0x1 : 0x2;
}
} else if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
@@ -2199,14 +2196,14 @@ static int resp_requests(struct scsi_cmnd *scp,
if (dsense) {
arr[0] = 0x72;
arr[1] = 0x0; /* NO_SENSE in sense_key */
- arr[2] = THRESHOLD_EXCEEDED;
+ arr[2] = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
arr[3] = 0xff; /* Failure prediction(false) */
len = 8;
} else {
arr[0] = 0x70;
arr[2] = 0x0; /* NO_SENSE in sense_key */
arr[7] = 0xa; /* 18 byte sense buffer */
- arr[12] = THRESHOLD_EXCEEDED;
+ arr[12] = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
arr[13] = 0xff; /* Failure prediction(false) */
}
} else { /* nothing to report */
@@ -2457,8 +2454,7 @@ static int resp_rsup_opcodes(struct scsi_cmnd *scp,
a_len = alloc_len;
arr = kzalloc((a_len < 256) ? 320 : a_len + 64, GFP_ATOMIC);
if (NULL == arr) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
- INSUFF_RES_ASCQ);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFFICIENT_RESOURCES);
return check_condition_result;
}
switch (reporting_opts) {
@@ -2924,8 +2920,9 @@ static int resp_mode_sense(struct scsi_cmnd *scp,
else
bd_len = 0;
alloc_len = msense_6 ? cmd[4] : get_unaligned_be16(cmd + 7);
- if (0x3 == pcontrol) { /* Saving values not supported */
- mk_sense_buffer(scp, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP, 0);
+ if (0x3 == pcontrol) {
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ SAVING_PARAMETERS_NOT_SUPPORTED);
return check_condition_result;
}
target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
@@ -3174,7 +3171,7 @@ static int resp_mode_select(struct scsi_cmnd *scp,
(arr[off + 1] + 2);
if ((pg_len + off) > param_len) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
- PARAMETER_LIST_LENGTH_ERR, 0);
+ PARAMETER_LIST_LENGTH_ERROR);
return check_condition_result;
}
switch (mpage) {
@@ -3256,7 +3253,7 @@ static int resp_ie_l_pg(unsigned char *arr)
memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
if (iec_m_pg[2] & 0x4) { /* TEST bit set */
- arr[4] = THRESHOLD_EXCEEDED;
+ arr[4] = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
arr[5] = 0xff;
}
return sizeof(ie_l_pg);
@@ -3413,7 +3410,8 @@ static int resp_locate(struct scsi_cmnd *scp,
break;
if (i < pos) {
devip->tape_location[partition] = i;
- mk_sense_buffer(scp, BLANK_CHECK, 0x05, 0);
+ mk_sense_buffer(scp, BLANK_CHECK,
+ LU_DOES_NOT_RESPOND_TO_SELECTION);
return check_condition_result;
}
devip->tape_location[partition] = pos;
@@ -3438,8 +3436,9 @@ static int resp_write_filemarks(struct scsi_cmnd *scp,
for (i = 0, pos = devip->tape_location[partition]; i < count; i++, pos++) {
if (pos >= devip->tape_eop[partition] - 1) { /* don't overwrite EOD */
devip->tape_location[partition] = devip->tape_eop[partition] - 1;
- mk_sense_info_tape(scp, VOLUME_OVERFLOW, NO_ADDITIONAL_SENSE,
- EOP_EOM_DETECTED_ASCQ, count, SENSE_FLAG_EOM);
+ mk_sense_info_tape(scp, VOLUME_OVERFLOW,
+ END_OF_PARTITION_MEDIUM_DETECTED,
+ count, SENSE_FLAG_EOM);
return check_condition_result;
}
(devip->tape_blocks[partition] + pos)->fl_size = data;
@@ -3540,31 +3539,28 @@ static int resp_space(struct scsi_cmnd *scp,
is_fm:
devip->tape_location[partition] = pos;
- mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
- FILEMARK_DETECTED_ASCQ, count - i,
- SENSE_FLAG_FILEMARK);
+ mk_sense_info_tape(scp, NO_SENSE, FILEMARK_DETECTED,
+ count - i, SENSE_FLAG_FILEMARK);
return check_condition_result;
is_eod:
devip->tape_location[partition] = pos;
- mk_sense_info_tape(scp, BLANK_CHECK, NO_ADDITIONAL_SENSE,
- EOD_DETECTED_ASCQ, count - i,
- 0);
+ mk_sense_info_tape(scp, BLANK_CHECK, END_OF_DATA_DETECTED,
+ count - i, 0);
return check_condition_result;
is_bop:
devip->tape_location[partition] = 0;
- mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
- BEGINNING_OF_P_M_DETECTED_ASCQ, count - i,
- SENSE_FLAG_EOM);
+ mk_sense_info_tape(scp, NO_SENSE,
+ BEGINNING_OF_PARTITION_MEDIUM_DETECTED,
+ count - i, SENSE_FLAG_EOM);
devip->tape_location[partition] = 0;
return check_condition_result;
is_eop:
devip->tape_location[partition] = devip->tape_eop[partition] - 1;
- mk_sense_info_tape(scp, MEDIUM_ERROR, NO_ADDITIONAL_SENSE,
- EOP_EOM_DETECTED_ASCQ, (unsigned int)i,
- SENSE_FLAG_EOM);
+ mk_sense_info_tape(scp, MEDIUM_ERROR, END_OF_PARTITION_MEDIUM_DETECTED,
+ (unsigned int)i, SENSE_FLAG_EOM);
return check_condition_result;
}
@@ -3852,8 +3848,7 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
/* For host-managed, reads cannot cross zone types boundaries */
if (zsp->z_type != zsp_end->z_type) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
- LBA_OUT_OF_RANGE,
- READ_INVDATA_ASCQ);
+ ATTEMPT_TO_READ_INVALID_DATA);
return check_condition_result;
}
return 0;
@@ -3861,8 +3856,8 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
/* Writing into a gap zone is not allowed */
if (zbc_zone_is_gap(zsp)) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE,
- ATTEMPT_ACCESS_GAP);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ ATTEMPT_TO_ACCESS_GAP_ZONE);
return check_condition_result;
}
@@ -3870,8 +3865,7 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
if (zbc_zone_is_conv(zsp)) {
if (!zbc_zone_is_conv(zsp_end)) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
- LBA_OUT_OF_RANGE,
- WRITE_BOUNDARY_ASCQ);
+ WRITE_BOUNDARY_VIOLATION);
return check_condition_result;
}
return 0;
@@ -3881,21 +3875,19 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
/* Writes cannot cross sequential zone boundaries */
if (zsp_end != zsp) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
- LBA_OUT_OF_RANGE,
- WRITE_BOUNDARY_ASCQ);
+ WRITE_BOUNDARY_VIOLATION);
return check_condition_result;
}
/* Cannot write full zones */
if (zsp->z_cond == ZC5_FULL) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
- INVALID_FIELD_IN_CDB, 0);
+ INVALID_FIELD_IN_CDB);
return check_condition_result;
}
/* Writes must be aligned to the zone WP */
if (lba != zsp->z_wp) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
- LBA_OUT_OF_RANGE,
- UNALIGNED_WRITE_ASCQ);
+ UNALIGNED_WRITE_COMMAND);
return check_condition_result;
}
}
@@ -3905,8 +3897,7 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
if (devip->max_open &&
devip->nr_exp_open >= devip->max_open) {
mk_sense_buffer(scp, DATA_PROTECT,
- INSUFF_RES_ASC,
- INSUFF_ZONE_ASCQ);
+ INSUFFICIENT_ZONE_RESOURCES);
return check_condition_result;
}
zbc_open_zone(devip, zsp, false);
@@ -3923,17 +3914,18 @@ static inline int check_device_access_params
struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
if (lba + num > sdebug_capacity) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return check_condition_result;
}
/* transfer length excessive (tie in to block limits VPD page) */
if (num > sdebug_store_sectors) {
/* needs work to find which cdb byte 'num' comes from */
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return check_condition_result;
}
if (write && unlikely(sdebug_wp)) {
- mk_sense_buffer(scp, DATA_PROTECT, WRITE_PROTECTED, 0x2);
+ mk_sense_buffer(scp, DATA_PROTECT, LU_SOFTWARE_WRITE_PROTECTED);
return check_condition_result;
}
if (sdebug_dev_is_zoned(devip))
@@ -4442,17 +4434,17 @@ static int resp_read_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
i++, pos++, blp++) {
devip->tape_location[partition] = pos + 1;
if (IS_TAPE_BLOCK_FM(blp->fl_size)) {
- mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
- FILEMARK_DETECTED_ASCQ, fixed ? num - i : size,
- SENSE_FLAG_FILEMARK);
+ mk_sense_info_tape(scp, NO_SENSE, FILEMARK_DETECTED,
+ fixed ? num - i : size,
+ SENSE_FLAG_FILEMARK);
scsi_set_resid(scp, (num - i) * size);
return check_condition_result;
}
/* Assume no REW */
if (IS_TAPE_BLOCK_EOD(blp->fl_size)) {
- mk_sense_info_tape(scp, BLANK_CHECK, NO_ADDITIONAL_SENSE,
- EOD_DETECTED_ASCQ, fixed ? num - i : size,
- 0);
+ mk_sense_info_tape(scp, BLANK_CHECK,
+ END_OF_DATA_DETECTED,
+ fixed ? num - i : size, 0);
devip->tape_location[partition] = pos;
scsi_set_resid(scp, (num - i) * size);
return check_condition_result;
@@ -4464,9 +4456,9 @@ static int resp_read_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (fixed) {
if (blp->fl_size != devip->tape_blksize) {
scsi_set_resid(scp, (num - i) * size);
- mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
- 0, num - i,
- SENSE_FLAG_ILI);
+ mk_sense_info_tape(scp, NO_SENSE,
+ NO_ADDITIONAL_SENSE_INFORMATION,
+ num - i, SENSE_FLAG_ILI);
return check_condition_result;
}
} else {
@@ -4474,18 +4466,19 @@ static int resp_read_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (blp->fl_size < size)
scsi_set_resid(scp, size - blp->fl_size);
if (!sili) {
- mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
- 0, size - blp->fl_size,
- SENSE_FLAG_ILI);
+ mk_sense_info_tape(scp, NO_SENSE,
+ NO_ADDITIONAL_SENSE_INFORMATION,
+ size - blp->fl_size,
+ SENSE_FLAG_ILI);
return check_condition_result;
}
}
}
}
if (pos >= devip->tape_eop[partition]) {
- mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
- EOP_EOM_DETECTED_ASCQ, fixed ? num - i : size,
- SENSE_FLAG_EOM);
+ mk_sense_info_tape(scp, NO_SENSE,
+ END_OF_PARTITION_MEDIUM_DETECTED,
+ fixed ? num - i : size, SENSE_FLAG_EOM);
devip->tape_location[partition] = pos - 1;
return check_condition_result;
}
@@ -4572,8 +4565,7 @@ static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (unlikely((SDEBUG_OPT_MEDIUM_ERR & sdebug_opts) &&
(lba <= (sdebug_medium_error_start + sdebug_medium_error_count - 1)) &&
((lba + num) > sdebug_medium_error_start))) {
- /* claim unrecoverable read error */
- mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
+ mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERROR);
/* set info field and valid bit for fixed descriptor */
if (0x70 == (scp->sense_buffer[0] & 0x7f)) {
scp->sense_buffer[0] |= 0x80; /* Valid bit */
@@ -4597,22 +4589,26 @@ static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
case 1: /* Guard tag error */
if (cmd[1] >> 5 != 3) { /* RDPROTECT != 3 */
sdeb_meta_read_unlock(sip);
- mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
+ mk_sense_buffer(scp, ABORTED_COMMAND,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
return check_condition_result;
} else if (scp->prot_flags & SCSI_PROT_GUARD_CHECK) {
sdeb_meta_read_unlock(sip);
- mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
return illegal_condition_result;
}
break;
case 3: /* Reference tag error */
if (cmd[1] >> 5 != 3) { /* RDPROTECT != 3 */
sdeb_meta_read_unlock(sip);
- mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 3);
+ mk_sense_buffer(scp, ABORTED_COMMAND,
+ LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
return check_condition_result;
} else if (scp->prot_flags & SCSI_PROT_REF_CHECK) {
sdeb_meta_read_unlock(sip);
- mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 3);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
return illegal_condition_result;
}
break;
@@ -4630,16 +4626,18 @@ static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
atomic_read(&sdeb_inject_pending))) {
if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
- mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
+ mk_sense_buffer(scp, RECOVERED_ERROR,
+ FAILURE_PREDICTION_THRESHOLD_EXCEEDED);
atomic_set(&sdeb_inject_pending, 0);
return check_condition_result;
} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
- /* Logical block guard check failed */
- mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
+ mk_sense_buffer(scp, ABORTED_COMMAND,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
return illegal_condition_result;
} else if (SDEBUG_OPT_DIX_ERR & sdebug_opts) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
return illegal_condition_result;
}
@@ -4846,16 +4844,14 @@ static int resp_write_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
blp->fl_size = TAPE_BLOCK_EOD_FLAG;
if (pos >= devip->tape_eop[partition] - 1) {
mk_sense_info_tape(scp, VOLUME_OVERFLOW,
- NO_ADDITIONAL_SENSE, EOP_EOM_DETECTED_ASCQ,
- fixed ? num - i : transfer,
- SENSE_FLAG_EOM);
+ END_OF_PARTITION_MEDIUM_DETECTED,
+ fixed ? num - i : transfer, SENSE_FLAG_EOM);
return check_condition_result;
}
if (ew) { /* early warning */
mk_sense_info_tape(scp, NO_SENSE,
- NO_ADDITIONAL_SENSE, EOP_EOM_DETECTED_ASCQ,
- fixed ? num - i : transfer,
- SENSE_FLAG_EOM);
+ END_OF_PARTITION_MEDIUM_DETECTED,
+ fixed ? num - i : transfer, SENSE_FLAG_EOM);
return check_condition_result;
}
@@ -4877,8 +4873,7 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (unlikely(sdebug_opts & SDEBUG_OPT_UNALIGNED_WRITE &&
atomic_read(&sdeb_inject_pending))) {
atomic_set(&sdeb_inject_pending, 0);
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE,
- UNALIGNED_WRITE_ASCQ);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, UNALIGNED_WRITE_COMMAND);
return check_condition_result;
}
@@ -4959,22 +4954,26 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
case 1: /* Guard tag error */
if (scp->prot_flags & SCSI_PROT_GUARD_CHECK) {
sdeb_meta_write_unlock(sip);
- mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
return illegal_condition_result;
} else if (scp->cmnd[1] >> 5 != 3) { /* WRPROTECT != 3 */
sdeb_meta_write_unlock(sip);
- mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
+ mk_sense_buffer(scp, ABORTED_COMMAND,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
return check_condition_result;
}
break;
case 3: /* Reference tag error */
if (scp->prot_flags & SCSI_PROT_REF_CHECK) {
sdeb_meta_write_unlock(sip);
- mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 3);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
return illegal_condition_result;
} else if (scp->cmnd[1] >> 5 != 3) { /* WRPROTECT != 3 */
sdeb_meta_write_unlock(sip);
- mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 3);
+ mk_sense_buffer(scp, ABORTED_COMMAND,
+ LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
return check_condition_result;
}
break;
@@ -5002,16 +5001,18 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
atomic_read(&sdeb_inject_pending))) {
if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
- mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
+ mk_sense_buffer(scp, RECOVERED_ERROR,
+ FAILURE_PREDICTION_THRESHOLD_EXCEEDED);
atomic_set(&sdeb_inject_pending, 0);
return check_condition_result;
} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
- /* Logical block guard check failed */
- mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
+ mk_sense_buffer(scp, ABORTED_COMMAND,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
return illegal_condition_result;
} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
return illegal_condition_result;
}
@@ -5074,7 +5075,7 @@ static int resp_write_scat(struct scsi_cmnd *scp,
if (sdebug_verbose)
sdev_printk(KERN_INFO, scp->device,
"%s: LB Data Offset field bad\n", my_name);
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return illegal_condition_result;
}
lbdof_blen = lbdof * lb_size;
@@ -5082,7 +5083,7 @@ static int resp_write_scat(struct scsi_cmnd *scp,
if (sdebug_verbose)
sdev_printk(KERN_INFO, scp->device,
"%s: LBA range descriptors don't fit\n", my_name);
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return illegal_condition_result;
}
lrdp = kzalloc(lbdof_blen, GFP_ATOMIC | __GFP_NOWARN);
@@ -5123,8 +5124,7 @@ static int resp_write_scat(struct scsi_cmnd *scp,
sdev_printk(KERN_INFO, scp->device,
"%s: sum of blocks > data provided\n",
my_name);
- mk_sense_buffer(scp, ILLEGAL_REQUEST, WRITE_ERROR_ASC,
- 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, WRITE_ERROR);
ret = illegal_condition_result;
goto err_out_unlock;
}
@@ -5135,8 +5135,9 @@ static int resp_write_scat(struct scsi_cmnd *scp,
ei_lba);
if (prot_ret) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10,
- prot_ret);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ scsi_sense_code(ASC_ID_CRC_OR_ECC_ERROR,
+ prot_ret));
ret = illegal_condition_result;
goto err_out_unlock;
}
@@ -5163,18 +5164,20 @@ static int resp_write_scat(struct scsi_cmnd *scp,
if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
atomic_read(&sdeb_inject_pending))) {
if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
- mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
+ mk_sense_buffer(scp, RECOVERED_ERROR,
+ FAILURE_PREDICTION_THRESHOLD_EXCEEDED);
atomic_set(&sdeb_inject_pending, 0);
ret = check_condition_result;
goto err_out_unlock;
} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
- /* Logical block guard check failed */
- mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
+ mk_sense_buffer(scp, ABORTED_COMMAND,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
ret = illegal_condition_result;
goto err_out_unlock;
} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
ret = illegal_condition_result;
goto err_out_unlock;
@@ -5393,8 +5396,7 @@ static int resp_comp_write(struct scsi_cmnd *scp,
dnum = 2 * num;
arr = kcalloc(lb_size, dnum, GFP_ATOMIC);
if (NULL == arr) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
- INSUFF_RES_ASCQ);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFFICIENT_RESOURCES);
return check_condition_result;
}
@@ -5410,7 +5412,8 @@ static int resp_comp_write(struct scsi_cmnd *scp,
sdeb_data_write_lock(sip);
sdeb_meta_write_lock(sip);
if (!comp_write_worker(sip, lba, num, arr, false)) {
- mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
+ mk_sense_buffer(scp, MISCOMPARE,
+ MISCOMPARE_DURING_VERIFY_OPERATION);
retval = check_condition_result;
goto cleanup_unlock;
}
@@ -5453,8 +5456,7 @@ static int resp_unmap(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
buf = kzalloc(scsi_bufflen(scp), GFP_ATOMIC);
if (!buf) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
- INSUFF_RES_ASCQ);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFFICIENT_RESOURCES);
return check_condition_result;
}
@@ -5592,7 +5594,8 @@ static int resp_sync_cache(struct scsi_cmnd *scp,
num_blocks = get_unaligned_be32(cmd + 10);
}
if (lba + num_blocks > sdebug_capacity) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return check_condition_result;
}
if (!write_since_sync || (cmd[1] & 0x2))
@@ -5630,7 +5633,8 @@ static int resp_pre_fetch(struct scsi_cmnd *scp,
nblks = get_unaligned_be32(cmd + 10);
}
if (lba + nblks > sdebug_capacity) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return check_condition_result;
}
if (!fsp)
@@ -5801,8 +5805,7 @@ static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
arr = kcalloc(lb_size, vnum, GFP_ATOMIC | __GFP_NOWARN);
if (!arr) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
- INSUFF_RES_ASCQ);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFFICIENT_RESOURCES);
return check_condition_result;
}
/* Not changing store, so only need read access */
@@ -5823,7 +5826,8 @@ static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
}
ret = 0;
if (!comp_write_worker(sip, lba, vnum, arr, true)) {
- mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
+ mk_sense_buffer(scp, MISCOMPARE,
+ MISCOMPARE_DURING_VERIFY_OPERATION);
ret = check_condition_result;
goto cleanup;
}
@@ -5862,7 +5866,8 @@ static int resp_report_zones(struct scsi_cmnd *scp,
partial = cmd[14] & 0x80;
if (zs_lba >= sdebug_capacity) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return check_condition_result;
}
@@ -5873,8 +5878,8 @@ static int resp_report_zones(struct scsi_cmnd *scp,
arr = kzalloc(arr_len, GFP_ATOMIC | __GFP_NOWARN);
if (!arr) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
- INSUFF_RES_ASCQ);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ INSUFFICIENT_RESOURCES);
return check_condition_result;
}
@@ -5939,8 +5944,7 @@ static int resp_report_zones(struct scsi_cmnd *scp,
continue;
break;
default:
- mk_sense_buffer(scp, ILLEGAL_REQUEST,
- INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
ret = check_condition_result;
goto fini;
}
@@ -6005,13 +6009,13 @@ static int resp_atomic_write(struct scsi_cmnd *scp,
if (sdebug_atomic_wr_align &&
do_div(lba_tmp, sdebug_atomic_wr_align)) {
/* Does not meet alignment requirement */
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return check_condition_result;
}
if (sdebug_atomic_wr_gran && len % sdebug_atomic_wr_gran) {
/* Does not meet alignment requirement */
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return check_condition_result;
}
@@ -6072,8 +6076,8 @@ static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
/* Check if all closed zones can be open */
if (devip->max_open &&
devip->nr_exp_open + devip->nr_closed > devip->max_open) {
- mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
- INSUFF_ZONE_ASCQ);
+ mk_sense_buffer(scp, DATA_PROTECT,
+ INSUFFICIENT_ZONE_RESOURCES);
res = check_condition_result;
goto fini;
}
@@ -6085,19 +6089,20 @@ static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
/* Open the specified zone */
z_id = get_unaligned_be64(cmd + 2);
if (z_id >= sdebug_capacity) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
res = check_condition_result;
goto fini;
}
zsp = zbc_zone(devip, z_id);
if (z_id != zsp->z_start) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
if (zbc_zone_is_conv(zsp)) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
@@ -6107,8 +6112,7 @@ static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
goto fini;
if (devip->max_open && devip->nr_exp_open >= devip->max_open) {
- mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
- INSUFF_ZONE_ASCQ);
+ mk_sense_buffer(scp, DATA_PROTECT, INSUFFICIENT_ZONE_RESOURCES);
res = check_condition_result;
goto fini;
}
@@ -6152,19 +6156,20 @@ static int resp_close_zone(struct scsi_cmnd *scp,
/* Close specified zone */
z_id = get_unaligned_be64(cmd + 2);
if (z_id >= sdebug_capacity) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
res = check_condition_result;
goto fini;
}
zsp = zbc_zone(devip, z_id);
if (z_id != zsp->z_start) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
if (zbc_zone_is_conv(zsp)) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
@@ -6224,19 +6229,20 @@ static int resp_finish_zone(struct scsi_cmnd *scp,
/* Finish the specified zone */
z_id = get_unaligned_be64(cmd + 2);
if (z_id >= sdebug_capacity) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
res = check_condition_result;
goto fini;
}
zsp = zbc_zone(devip, z_id);
if (z_id != zsp->z_start) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
if (zbc_zone_is_conv(zsp)) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
@@ -6303,19 +6309,20 @@ static int resp_rwp_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
z_id = get_unaligned_be64(cmd + 2);
if (z_id >= sdebug_capacity) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
res = check_condition_result;
goto fini;
}
zsp = zbc_zone(devip, z_id);
if (z_id != zsp->z_start) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
if (zbc_zone_is_conv(zsp)) {
- mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
+ mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
@@ -7186,7 +7193,7 @@ static int schedule_resp(struct scsi_cmnd *cmnd, struct sdebug_dev_info *devip,
cmnd->result = scsi_result;
if (cmnd->result == 0 && unlikely(sdebug_opts & SDEBUG_OPT_TRANSPORT_ERR)) {
if (atomic_read(&sdeb_inject_pending)) {
- mk_sense_buffer(cmnd, ABORTED_COMMAND, TRANSPORT_PROBLEM, ACK_NAK_TO);
+ mk_sense_buffer(cmnd, ABORTED_COMMAND, ACK_NAK_TIMEOUT);
atomic_set(&sdeb_inject_pending, 0);
cmnd->result = check_condition_result;
}
@@ -8979,7 +8986,8 @@ static int resp_not_ready(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
return 0;
}
}
- mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x1);
+ mk_sense_buffer(scp, NOT_READY,
+ LU_IS_IN_PROCESS_OF_BECOMING_READY);
if (sdebug_verbose)
sdev_printk(KERN_INFO, sdp,
"%s: Not ready: in process of becoming ready\n", my_name);
@@ -8997,7 +9005,8 @@ static int resp_not_ready(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
return check_condition_result;
}
}
- mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
+ mk_sense_buffer(scp, NOT_READY,
+ LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED);
if (sdebug_verbose)
sdev_printk(KERN_INFO, sdp, "%s: Not ready: initializing command required\n",
my_name);
@@ -9194,7 +9203,8 @@ static int sdebug_fail_cmd(struct scsi_cmnd *cmnd, int *retval,
out_handle:
if (err->cnt < 0)
err->cnt++;
- mk_sense_buffer(cmnd, err->sense_key, err->asc, err->asq);
+ mk_sense_buffer(cmnd, err->sense_key,
+ scsi_sense_code(err->asc, err->asq));
result = err->status_byte | err->host_byte << 16 | err->driver_byte << 24;
*info = *err;
*retval = schedule_resp(cmnd, devip, result, NULL, 0, 0);
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 32/37] scsi: hpsa: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (30 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 31/37] scsi: scsi_debug: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 33/37] scsi: storvsc: " Damien Le Moal
` (5 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the hpsa driver to replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
The function decode_sense_data() is also modified to take a pointer to a
16-bits sense_code variable in place of the two pointers to the additional
sense code and its code qualifier. The local definitions of ASCs and ASCQs
are deleted too.
No functional change intended, but the function hpsa_volume_offline() was
checking only the addditional sense code qualifier with checking the
additional sense code. This change assumes that the intended additional
sense code to check is ASC_LU_NOT_READY.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/hpsa.c | 69 +++++++++++++++++++++--------------------
drivers/scsi/hpsa_cmd.h | 23 --------------
2 files changed, 35 insertions(+), 57 deletions(-)
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 8edad1830abe..795e8c7592af 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -353,14 +353,13 @@ static inline bool hpsa_is_cmd_idle(struct CommandList *c)
/* extract sense key, asc, and ascq from sense data. -1 means invalid. */
static void decode_sense_data(const u8 *sense_data, int sense_data_len,
- u8 *sense_key, u8 *asc, u8 *ascq)
+ u8 *sense_key, u16 *sense_code)
{
struct scsi_sense_hdr sshdr;
bool rc;
*sense_key = -1;
- *asc = -1;
- *ascq = -1;
+ *sense_code = -1;
if (sense_data_len < 1)
return;
@@ -368,15 +367,15 @@ static void decode_sense_data(const u8 *sense_data, int sense_data_len,
rc = scsi_normalize_sense(sense_data, sense_data_len, &sshdr);
if (rc) {
*sense_key = sshdr.sense_key;
- *asc = sshdr.asc;
- *ascq = sshdr.ascq;
+ *sense_code = sshdr.sense_code;
}
}
static int check_for_unit_attention(struct ctlr_info *h,
struct CommandList *c)
{
- u8 sense_key, asc, ascq;
+ u8 sense_key;
+ u16 sense_code;
int sense_len;
if (c->err_info->SenseLen > sizeof(c->err_info->SenseInfo))
@@ -385,34 +384,35 @@ static int check_for_unit_attention(struct ctlr_info *h,
sense_len = c->err_info->SenseLen;
decode_sense_data(c->err_info->SenseInfo, sense_len,
- &sense_key, &asc, &ascq);
- if (sense_key != UNIT_ATTENTION || asc == 0xff)
+ &sense_key, &sense_code);
+ if (sense_key != UNIT_ATTENTION ||
+ scsi_sense_code_asc(sense_code) == 0xff)
return 0;
- switch (asc) {
- case STATE_CHANGED:
+ switch (scsi_sense_code_asc(sense_code)) {
+ case ASC_PARAMETERS_CHANGED:
dev_warn(&h->pdev->dev,
"%s: a state change detected, command retried\n",
h->devname);
break;
- case LUN_FAILED:
+ case ASC_LU_HAS_NOT_SELF_CONFIGURED_YET:
dev_warn(&h->pdev->dev,
"%s: LUN failure detected\n", h->devname);
break;
- case REPORT_LUNS_CHANGED:
+ case ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED:
dev_warn(&h->pdev->dev,
"%s: report LUN data changed\n", h->devname);
/*
- * Note: this REPORT_LUNS_CHANGED condition only occurs on the external
- * target (array) devices.
+ * Note: this ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED condition
+ * only occurs on the external target (array) devices.
*/
break;
- case POWER_OR_RESET:
+ case ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED:
dev_warn(&h->pdev->dev,
"%s: a power on or device reset detected\n",
h->devname);
break;
- case UNIT_ATTENTION_CLEARED:
+ case ASC_COMMANDS_CLEARED_BY_ANOTHER_INITIATOR:
dev_warn(&h->pdev->dev,
"%s: unit attention cleared by another initiator\n",
h->devname);
@@ -2562,10 +2562,8 @@ static void complete_scsi_command(struct CommandList *cp)
struct ErrorInfo *ei;
struct hpsa_scsi_dev_t *dev;
struct io_accel2_cmd *c2;
-
u8 sense_key;
- u8 asc; /* additional sense code */
- u8 ascq; /* additional sense code qualifier */
+ u16 sense_code;
unsigned long sense_data_size;
ei = cp->err_info;
@@ -2666,18 +2664,19 @@ static void complete_scsi_command(struct CommandList *cp)
memcpy(cmd->sense_buffer, ei->SenseInfo, sense_data_size);
if (ei->ScsiStatus)
decode_sense_data(ei->SenseInfo, sense_data_size,
- &sense_key, &asc, &ascq);
+ &sense_key, &sense_code);
if (ei->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
switch (sense_key) {
case ABORTED_COMMAND:
cmd->result |= DID_SOFT_ERROR << 16;
break;
case UNIT_ATTENTION:
- if (asc == 0x3F && ascq == 0x0E)
+ if (sense_code ==
+ REPORTED_LUNS_DATA_HAS_CHANGED)
h->drv_req_rescan = 1;
break;
case ILLEGAL_REQUEST:
- if (asc == 0x25 && ascq == 0x00) {
+ if (sense_code == LU_NOT_SUPPORTED) {
dev->removed = 1;
cmd->result = DID_NO_CONNECT << 16;
}
@@ -2693,7 +2692,9 @@ static void complete_scsi_command(struct CommandList *cp)
"Sense: 0x%x, ASC: 0x%x, ASCQ: 0x%x, "
"Returning result: 0x%x\n",
cp, ei->ScsiStatus,
- sense_key, asc, ascq,
+ sense_key,
+ scsi_sense_code_asc(sense_code),
+ scsi_sense_code_ascq(sense_code),
cmd->result);
} else { /* scsi status is zero??? How??? */
dev_warn(&h->pdev->dev, "cp %p SCSI status was 0. "
@@ -2919,7 +2920,8 @@ static void hpsa_scsi_interpret_error(struct ctlr_info *h,
{
const struct ErrorInfo *ei = cp->err_info;
struct device *d = &cp->h->pdev->dev;
- u8 sense_key, asc, ascq;
+ u8 sense_key;
+ u16 sense_code;
int sense_len;
switch (ei->CommandStatus) {
@@ -2928,12 +2930,13 @@ static void hpsa_scsi_interpret_error(struct ctlr_info *h,
sense_len = sizeof(ei->SenseInfo);
else
sense_len = ei->SenseLen;
- decode_sense_data(ei->SenseInfo, sense_len,
- &sense_key, &asc, &ascq);
+ decode_sense_data(ei->SenseInfo, sense_len, &sense_key,
+ &sense_code);
hpsa_print_cmd(h, "SCSI status", cp);
if (ei->ScsiStatus == SAM_STAT_CHECK_CONDITION)
dev_warn(d, "SCSI Status = 02, Sense key = 0x%02x, ASC = 0x%02x, ASCQ = 0x%02x\n",
- sense_key, asc, ascq);
+ sense_key, scsi_sense_code_asc(sense_code),
+ scsi_sense_code_ascq(sense_code));
else
dev_warn(d, "SCSI Status = 0x%02x\n", ei->ScsiStatus);
if (ei->ScsiStatus == 0)
@@ -3868,12 +3871,10 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
{
struct CommandList *c;
unsigned char *sense;
- u8 sense_key, asc, ascq;
+ u8 sense_key;
+ u16 sense_code;
int sense_len;
int rc, ldstat = 0;
-#define ASC_LUN_NOT_READY 0x04
-#define ASCQ_LUN_NOT_READY_FORMAT_IN_PROGRESS 0x04
-#define ASCQ_LUN_NOT_READY_INITIALIZING_CMD_REQ 0x02
c = cmd_alloc(h);
@@ -3889,7 +3890,7 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
sense_len = sizeof(c->err_info->SenseInfo);
else
sense_len = c->err_info->SenseLen;
- decode_sense_data(sense, sense_len, &sense_key, &asc, &ascq);
+ decode_sense_data(sense, sense_len, &sense_key, &sense_code);
cmd_free(h, c);
/* Determine the reason for not ready state */
@@ -3912,8 +3913,8 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
/* If VPD status page isn't available,
* use ASC/ASCQ to determine state
*/
- if ((ascq == ASCQ_LUN_NOT_READY_FORMAT_IN_PROGRESS) ||
- (ascq == ASCQ_LUN_NOT_READY_INITIALIZING_CMD_REQ))
+ if (sense_code == LU_NOT_READY_FORMAT_IN_PROGRESS ||
+ sense_code == LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)
return ldstat;
break;
default:
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
index ba6a3aa8d954..0dbfbec37ce2 100644
--- a/drivers/scsi/hpsa_cmd.h
+++ b/drivers/scsi/hpsa_cmd.h
@@ -63,29 +63,6 @@
#define CISS_TMF_WRONG_LUN 0x09
#define CISS_TMF_OVERLAPPED_TAG 0x0a
-/* Unit Attentions ASC's as defined for the MSA2012sa */
-#define POWER_OR_RESET 0x29
-#define STATE_CHANGED 0x2a
-#define UNIT_ATTENTION_CLEARED 0x2f
-#define LUN_FAILED 0x3e
-#define REPORT_LUNS_CHANGED 0x3f
-
-/* Unit Attentions ASCQ's as defined for the MSA2012sa */
-
- /* These ASCQ's defined for ASC = POWER_OR_RESET */
-#define POWER_ON_RESET 0x00
-#define POWER_ON_REBOOT 0x01
-#define SCSI_BUS_RESET 0x02
-#define MSA_TARGET_RESET 0x03
-#define CONTROLLER_FAILOVER 0x04
-#define TRANSCEIVER_SE 0x05
-#define TRANSCEIVER_LVD 0x06
-
- /* These ASCQ's defined for ASC = STATE_CHANGED */
-#define RESERVATION_PREEMPTED 0x03
-#define ASYM_ACCESS_CHANGED 0x06
-#define LUN_CAPACITY_CHANGED 0x09
-
/* transfer direction */
#define XFER_NONE 0x00
#define XFER_WRITE 0x01
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 33/37] scsi: storvsc: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (31 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 32/37] scsi: hpsa: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:27 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 34/37] usb: storage: " Damien Le Moal
` (4 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the storvsc driver to use the 16-bits sense_code field of
struct scsi_sense_hdr and replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/scsi/storvsc_drv.c | 15 +++++++++------
1 file changed, 9 insertions(+), 6 deletions(-)
diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
index ef3cd3bc7390..625db97d1a03 100644
--- a/drivers/scsi/storvsc_drv.c
+++ b/drivers/scsi/storvsc_drv.c
@@ -1016,7 +1016,7 @@ static int storvsc_channel_init(struct hv_device *device, bool is_fc)
static void storvsc_handle_error(struct vmscsi_request *vm_srb,
struct scsi_cmnd *scmnd,
struct Scsi_Host *host,
- u8 asc, u8 ascq)
+ struct scsi_sense_hdr *sshdr)
{
struct storvsc_scan_work *wrk;
void (*process_err_fn)(struct work_struct *work);
@@ -1033,7 +1033,7 @@ static void storvsc_handle_error(struct vmscsi_request *vm_srb,
case SRB_STATUS_DATA_OVERRUN:
if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID) {
/* Check for capacity change */
- if ((asc == 0x2a) && (ascq == 0x9)) {
+ if (sshdr->sense_code == CAPACITY_DATA_HAS_CHANGED) {
process_err_fn = storvsc_device_scan;
/* Retry the I/O that triggered this. */
set_host_byte(scmnd, DID_REQUEUE);
@@ -1049,8 +1049,12 @@ static void storvsc_handle_error(struct vmscsi_request *vm_srb,
* want scsi_report_sense() to output a message
* that a sysadmin wouldn't know what to do with.
*/
- if ((asc == 0x3f) && (ascq != 0x03) &&
- (ascq != 0x0e)) {
+ if (scsi_sense_asc(sshdr) ==
+ ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED &&
+ sshdr->sense_code !=
+ INQUIRY_DATA_HAS_CHANGED &&
+ sshdr->sense_code !=
+ REPORTED_LUNS_DATA_HAS_CHANGED) {
process_err_fn = storvsc_device_scan;
set_host_byte(scmnd, DID_REQUEUE);
goto do_work;
@@ -1141,8 +1145,7 @@ static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request,
}
if (vm_srb->srb_status != SRB_STATUS_SUCCESS) {
- storvsc_handle_error(vm_srb, scmnd, host, sense_hdr.asc,
- sense_hdr.ascq);
+ storvsc_handle_error(vm_srb, scmnd, host, &sense_hdr);
/*
* The Windows driver set data_transfer_length on
* SRB_STATUS_DATA_OVERRUN. On other errors, this value
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 33/37] scsi: storvsc: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 33/37] scsi: storvsc: " Damien Le Moal
@ 2026-08-31 2:27 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:27 UTC (permalink / raw)
To: Damien Le Moal; +Cc: cassel, linux-ide, dlemoal, linux-scsi
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Use-After-Free when an asynchronous I/O completion enqueues work onto a destroyed workqueue during device removal.
--
commit d0f50a340823cdbe80b900f5e21694a095dae714
Author: Damien Le Moal <dlemoal@kernel.org>
scsi: storvsc: use 16-bits defined sense codes
This refactors the storvsc driver to use the 16-bits sense_code field of
struct scsi_sense_hdr. It replaces hard-coded additional sense codes with
the enum values defined in include/scsi/scsi_sense.h to improve code
clarity.
> diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
> index ef3cd3bc7390e..625db97d1a03e 100644
> --- a/drivers/scsi/storvsc_drv.c
> +++ b/drivers/scsi/storvsc_drv.c
[ ... ]
> @@ -1033,7 +1033,7 @@ static void storvsc_handle_error(struct vmscsi_request *vm_srb,
> case SRB_STATUS_DATA_OVERRUN:
> if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID) {
> /* Check for capacity change */
> - if ((asc == 0x2a) && (ascq == 0x9)) {
> + if (sshdr->sense_code == CAPACITY_DATA_HAS_CHANGED) {
> process_err_fn = storvsc_device_scan;
> /* Retry the I/O that triggered this. */
> set_host_byte(scmnd, DID_REQUEUE);
> goto do_work;
[Severity: High]
This isn't a bug introduced by this patch, but can this lead to a
use-after-free during device removal?
In storvsc_remove(), the driver destroys the workqueue before stopping the
VMBus channel and draining outstanding requests:
drivers/scsi/storvsc_drv.c:storvsc_remove() {
...
destroy_workqueue(host_dev->handle_error_wq);
scsi_remove_host(host);
storvsc_dev_remove(dev);
...
}
If an asynchronous I/O completion indicating a capacity change arrives after
this point, it will call storvsc_handle_error(), take this goto do_work
path, and blindly enqueue work onto the destroyed workqueue:
drivers/scsi/storvsc_drv.c:storvsc_handle_error() {
...
do_work:
...
queue_work(host_dev->handle_error_wq, &wrk->work);
}
> }
[ ... ]
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=33
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 34/37] usb: storage: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (32 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 33/37] scsi: storvsc: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:04 ` [PATCH 35/37] cdrom: " Damien Le Moal
` (3 subsequent siblings)
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the USB mass storage driver to replace all hard-coded additional
sense codes and additional sense code qualifiers with the enum values
defined in include/scsi/scsi_sense.h. This helps with code clarity as the
sense codes being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/usb/gadget/function/f_mass_storage.c | 34 +++++-----
drivers/usb/gadget/function/storage_common.h | 71 +++++++++++++++-----
drivers/usb/storage/transport.c | 5 +-
3 files changed, 74 insertions(+), 36 deletions(-)
diff --git a/drivers/usb/gadget/function/f_mass_storage.c b/drivers/usb/gadget/function/f_mass_storage.c
index a50743caf083..05e138968389 100644
--- a/drivers/usb/gadget/function/f_mass_storage.c
+++ b/drivers/usb/gadget/function/f_mass_storage.c
@@ -1103,9 +1103,9 @@ static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
* FSG normally uses option a); enable this code to use option b).
*/
#if 0
- if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
+ if (curlun && curlun->unit_attention_data != NO_SENSE) {
curlun->sense_data = curlun->unit_attention_data;
- curlun->unit_attention_data = SS_NO_SENSE;
+ curlun->unit_attention_data = NO_SENSE;
}
#endif
@@ -1118,18 +1118,18 @@ static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
sd = curlun->sense_data;
sdinfo = curlun->sense_data_info;
valid = curlun->info_valid << 7;
- curlun->sense_data = SS_NO_SENSE;
+ curlun->sense_data = NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
memset(buf, 0, 18);
buf[0] = valid | 0x70; /* Valid, current error */
- buf[2] = SK(sd);
+ buf[2] = usb_sense_key(sd);
put_unaligned_be32(sdinfo, &buf[3]); /* Sense information */
buf[7] = 18 - 8; /* Additional sense length */
- buf[12] = ASC(sd);
- buf[13] = ASCQ(sd);
+ buf[12] = usb_sense_asc(sd);
+ buf[13] = usb_sense_ascq(sd);
return 18;
}
@@ -1678,21 +1678,23 @@ static void send_status(struct fsg_common *common)
if (curlun) {
sd = curlun->sense_data;
sdinfo = curlun->sense_data_info;
- } else if (common->bad_lun_okay)
- sd = SS_NO_SENSE;
- else
+ } else if (common->bad_lun_okay) {
+ sd = NO_SENSE;
+ } else {
sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
+ }
if (common->phase_error) {
DBG(common, "sending phase-error status\n");
status = US_BULK_STAT_PHASE;
sd = SS_INVALID_COMMAND;
- } else if (sd != SS_NO_SENSE) {
+ } else if (sd != NO_SENSE) {
DBG(common, "sending command-failure status\n");
status = US_BULK_STAT_FAIL;
VDBG(common, " sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
" info x%x\n",
- SK(sd), ASC(sd), ASCQ(sd), sdinfo);
+ usb_sense_key(sd), usb_sense_asc(sd),
+ usb_sense_ascq(sd), sdinfo);
}
/* Store and send the Bulk-only CSW */
@@ -1798,7 +1800,7 @@ static int check_command(struct fsg_common *common, int cmnd_size,
curlun = common->curlun;
if (curlun) {
if (common->cmnd[0] != REQUEST_SENSE) {
- curlun->sense_data = SS_NO_SENSE;
+ curlun->sense_data = NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
@@ -1820,11 +1822,11 @@ static int check_command(struct fsg_common *common, int cmnd_size,
* If a unit attention condition exists, only INQUIRY and
* REQUEST SENSE commands are allowed; anything else must fail.
*/
- if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
+ if (curlun && curlun->unit_attention_data != NO_SENSE &&
common->cmnd[0] != INQUIRY &&
common->cmnd[0] != REQUEST_SENSE) {
curlun->sense_data = curlun->unit_attention_data;
- curlun->unit_attention_data = SS_NO_SENSE;
+ curlun->unit_attention_data = NO_SENSE;
return -EINVAL;
}
@@ -2501,8 +2503,8 @@ static void handle_exception(struct fsg_common *common)
if (!curlun)
continue;
curlun->prevent_medium_removal = 0;
- curlun->sense_data = SS_NO_SENSE;
- curlun->unit_attention_data = SS_NO_SENSE;
+ curlun->sense_data = NO_SENSE;
+ curlun->unit_attention_data = NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
diff --git a/drivers/usb/gadget/function/storage_common.h b/drivers/usb/gadget/function/storage_common.h
index 11ac785d5eee..e73a30cc553f 100644
--- a/drivers/usb/gadget/function/storage_common.h
+++ b/drivers/usb/gadget/function/storage_common.h
@@ -70,24 +70,59 @@ do { \
#define MAX_COMMAND_SIZE 16
/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
-#define SS_NO_SENSE 0
-#define SS_COMMUNICATION_FAILURE 0x040800
-#define SS_INVALID_COMMAND 0x052000
-#define SS_INVALID_FIELD_IN_CDB 0x052400
-#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE 0x052100
-#define SS_LOGICAL_UNIT_NOT_SUPPORTED 0x052500
-#define SS_MEDIUM_NOT_PRESENT 0x023a00
-#define SS_MEDIUM_REMOVAL_PREVENTED 0x055302
-#define SS_NOT_READY_TO_READY_TRANSITION 0x062800
-#define SS_RESET_OCCURRED 0x062900
-#define SS_SAVING_PARAMETERS_NOT_SUPPORTED 0x053900
-#define SS_UNRECOVERED_READ_ERROR 0x031100
-#define SS_WRITE_ERROR 0x030c02
-#define SS_WRITE_PROTECTED 0x072700
-
-#define SK(x) ((u8) ((x) >> 16)) /* Sense Key byte, etc. */
-#define ASC(x) ((u8) ((x) >> 8))
-#define ASCQ(x) ((u8) (x))
+static inline u32 usb_sense_kc(u8 sense_key, u16 sense_code)
+{
+ return ((u32)sense_key << 16) | (u32)sense_code;
+}
+
+static inline u8 usb_sense_key(u32 kc)
+{
+ return kc >> 16;
+}
+
+static inline u16 usb_sense_code(u32 kc)
+{
+ return kc & 0xFFFF;
+}
+
+static inline u8 usb_sense_asc(u32 kc)
+{
+ return scsi_sense_code_asc(usb_sense_code(kc));
+}
+
+static inline u8 usb_sense_ascq(u32 kc)
+{
+ return scsi_sense_code_ascq(usb_sense_code(kc));
+}
+
+#define SS_COMMUNICATION_FAILURE \
+ usb_sense_kc(HARDWARE_ERROR, LU_COMMUNICATION_FAILURE)
+#define SS_INVALID_COMMAND \
+ usb_sense_kc(ILLEGAL_REQUEST, INVALID_COMMAND_OP_CODE)
+#define SS_INVALID_FIELD_IN_CDB \
+ usb_sense_kc(ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB)
+#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE \
+ usb_sense_kc(ILLEGAL_REQUEST, LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE)
+#define SS_LOGICAL_UNIT_NOT_SUPPORTED \
+ usb_sense_kc(ILLEGAL_REQUEST, LU_NOT_SUPPORTED)
+#define SS_MEDIUM_NOT_PRESENT \
+ usb_sense_kc(NOT_READY, MEDIUM_NOT_PRESENT)
+#define SS_MEDIUM_REMOVAL_PREVENTED \
+ usb_sense_kc(ILLEGAL_REQUEST, MEDIUM_REMOVAL_PREVENTED)
+#define SS_NOT_READY_TO_READY_TRANSITION \
+ usb_sense_kc(UNIT_ATTENTION, \
+ NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED)
+#define SS_RESET_OCCURRED \
+ usb_sense_kc(UNIT_ATTENTION, \
+ POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
+#define SS_SAVING_PARAMETERS_NOT_SUPPORTED \
+ usb_sense_kc(ILLEGAL_REQUEST, SAVING_PARAMETERS_NOT_SUPPORTED)
+#define SS_UNRECOVERED_READ_ERROR \
+ usb_sense_kc(MEDIUM_ERROR, UNRECOVERED_READ_ERROR)
+#define SS_WRITE_ERROR \
+ usb_sense_kc(MEDIUM_ERROR, WRITE_ERROR_AUTO_REALLOCATION_FAILED)
+#define SS_WRITE_PROTECTED \
+ usb_sense_kc(DATA_PROTECT, WRITE_PROTECTED)
/*
* Vendor (8 chars), product (16 chars), release (4 hexadecimal digits) and NUL
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 8e9359501d88..8de3015bce05 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -803,7 +803,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
temp_result);
usb_stor_dbg(us, "-- code: 0x%x, key: 0x%x, ASC: 0x%x, ASCQ: 0x%x\n",
sshdr.response_code, sshdr.sense_key,
- sshdr.asc, sshdr.ascq);
+ scsi_sense_asc(&sshdr), scsi_sense_ascq(&sshdr));
#ifdef CONFIG_USB_STORAGE_DEBUG
usb_stor_show_sense(us, &sshdr);
#endif
@@ -820,7 +820,8 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
* everything worked or that there was an unspecified
* problem. We have to decide which.
*/
- if (sshdr.sense_key == 0 && sshdr.asc == 0 && sshdr.ascq == 0 &&
+ if (sshdr.sense_key == NO_SENSE &&
+ sshdr.sense_code == NO_ADDITIONAL_SENSE_INFORMATION &&
fm_ili == 0) {
/*
* If things are really okay, then let's show that.
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* [PATCH 35/37] cdrom: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (33 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 34/37] usb: storage: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:29 ` sashiko-bot
2026-08-31 2:04 ` [PATCH 36/37] ata: libata: " Damien Le Moal
` (2 subsequent siblings)
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor the cdrom driver to use the 16-bits sense_code field of
struct scsi_sense_hdr and replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/cdrom/cdrom.c | 10 ++++------
1 file changed, 4 insertions(+), 6 deletions(-)
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 4f1fd389260f..c717e35ea2af 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -345,9 +345,8 @@ int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
struct packet_command *cgc)
{
if (cgc->sshdr) {
- cgc->sshdr->sense_key = 0x05;
- cgc->sshdr->asc = 0x20;
- cgc->sshdr->ascq = 0x00;
+ cgc->sshdr->sense_key = ILLEGAL_REQUEST;
+ cgc->sshdr->sense_code = INVALID_COMMAND_OP_CODE;
}
cgc->stat = -EIO;
@@ -2979,9 +2978,8 @@ static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
cgc->sshdr = &sshdr;
cgc->data_direction = CGC_DATA_READ;
ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
- if (ret && sshdr.sense_key == 0x05 &&
- sshdr.asc == 0x20 &&
- sshdr.ascq == 0x00) {
+ if (ret && sshdr.sense_key == ILLEGAL_REQUEST &&
+ sshdr.sense_code == INVALID_COMMAND_OP_CODE) {
/*
* SCSI-II devices are not required to support
* READ_CD, so let's try switching block size
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 35/37] cdrom: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 35/37] cdrom: " Damien Le Moal
@ 2026-08-31 2:29 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:29 UTC (permalink / raw)
To: Damien Le Moal; +Cc: dlemoal, cassel, linux-ide, linux-scsi
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Tracepoint scsi_cmd_done_timeout_template incorrectly logs the 'ascq' field as the 'asc' value.
--
commit 7e6312a47a6eeb4644f3eba5f9acd48a9a7fd4c4
Author: Damien Le Moal <dlemoal@kernel.org>
cdrom: use 16-bits defined sense codes
Refactor the cdrom driver to use the 16-bits sense_code field of
struct scsi_sense_hdr and replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
> diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
> index 4f1fd389260f5..c717e35ea2afc 100644
> --- a/drivers/cdrom/cdrom.c
> +++ b/drivers/cdrom/cdrom.c
> @@ -345,9 +345,8 @@ int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
> struct packet_command *cgc)
> {
> if (cgc->sshdr) {
> - cgc->sshdr->sense_key = 0x05;
> - cgc->sshdr->asc = 0x20;
> - cgc->sshdr->ascq = 0x00;
> + cgc->sshdr->sense_key = ILLEGAL_REQUEST;
> + cgc->sshdr->sense_code = INVALID_COMMAND_OP_CODE;
> }
[Severity: Medium]
While reviewing the sense code changes, I noticed a related issue in
include/trace/events/scsi.h. Does the scsi_cmd_done_timeout_template
tracepoint incorrectly log the 'ascq' field?
include/trace/events/scsi.h:scsi_cmd_done_timeout_template() {
...
if (cmd->sense_buffer && SCSI_SENSE_VALID(cmd) &&
scsi_command_normalize_sense(cmd, &sshdr)) {
__entry->sense_key = sshdr.sense_key;
__entry->asc = scsi_sense_asc(&sshdr);
__entry->ascq = scsi_sense_asc(&sshdr);
} else {
...
}
Any time a tracepoint based on scsi_cmd_done_timeout_template is hit and a
valid SCSI sense buffer is present, it looks like scsi_sense_asc(&sshdr) is
called twice, assigning its return value to both __entry->asc and
__entry->ascq.
Does this irrevocably lose the Additional Sense Code Qualifier (ascq) value
in trace events (like scsi_dispatch_cmd_done and scsi_dispatch_cmd_timeout),
corrupting the trace output and hampering debugging?
>
> cgc->stat = -EIO;
> return -EIO;
> }
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=35
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 36/37] ata: libata: use 16-bits defined sense codes
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (34 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 35/37] cdrom: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-09-02 11:29 ` Niklas Cassel
2026-08-31 2:04 ` [PATCH 37/37] scsi: cleanup scsi_proto.h Damien Le Moal
2026-08-31 2:36 ` [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Refactor libata core code to use the 16-bits sense_code field of
struct scsi_sense_hdr and replace all hard-coded additional sense codes
and additional sense code qualifiers with the enum values defined in
include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
being processed are easier to test and self-documented.
No functional change intended.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
drivers/ata/libata-eh.c | 13 +-
drivers/ata/libata-sata.c | 14 +-
drivers/ata/libata-scsi.c | 346 +++++++++++++++++++++++---------------
drivers/ata/libata.h | 5 +-
4 files changed, 226 insertions(+), 152 deletions(-)
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index c93c24b22d9c..71961fbaa42f 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -1516,11 +1516,13 @@ static bool ata_eh_request_sense(struct ata_queued_cmd *qc)
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
/* 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)) {
+ u16 sense_code = scsi_sense_code(tf.lbam, tf.lbal);
+
+ if (ata_scsi_sense_is_valid(tf.lbah, sense_code)) {
/* 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);
+ scsi_set_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
+ cmd->sense_buffer, tf.lbah,
+ sense_code);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
return true;
}
@@ -2094,7 +2096,8 @@ static void ata_eh_get_success_sense(struct ata_link *link)
continue;
/* This success command had sense data, but we failed to get. */
- ata_scsi_set_sense(dev, qc->scsicmd, ABORTED_COMMAND, 0, 0);
+ ata_scsi_set_sense(dev, qc->scsicmd, ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
}
ata_eh_done(link, dev, ATA_EH_GET_SUCCESS_SENSE);
diff --git a/drivers/ata/libata-sata.c b/drivers/ata/libata-sata.c
index ad40f516c6d4..c80505469332 100644
--- a/drivers/ata/libata-sata.c
+++ b/drivers/ata/libata-sata.c
@@ -1588,7 +1588,7 @@ int ata_eh_get_ncq_success_sense(struct ata_link *link)
asc = sense[1];
ascq = sense[2];
- if (!ata_scsi_sense_is_valid(sk, asc, ascq)) {
+ if (!ata_scsi_sense_is_valid(sk, scsi_sense_code(asc, ascq))) {
ret = -EIO;
continue;
}
@@ -1684,14 +1684,14 @@ void ata_eh_analyze_ncq_error(struct ata_link *link)
* stored the sense data in qc->result_tf.auxiliary.
*/
if (qc->result_tf.auxiliary) {
- char sense_key, asc, ascq;
+ u16 sense_code;
+ u8 sense_key;
sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
- asc = (qc->result_tf.auxiliary >> 8) & 0xff;
- ascq = qc->result_tf.auxiliary & 0xff;
- if (ata_scsi_sense_is_valid(sense_key, asc, ascq)) {
- ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc,
- ascq);
+ sense_code = qc->result_tf.auxiliary & 0xffff;
+ if (ata_scsi_sense_is_valid(sense_key, sense_code)) {
+ ata_scsi_set_sense(dev, qc->scsicmd, sense_key,
+ sense_code);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
}
}
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index a7d667cfcfec..66fef7ffbf1b 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -190,28 +190,25 @@ DEVICE_ATTR(unload_heads, S_IRUGO | S_IWUSR,
ata_scsi_park_show, ata_scsi_park_store);
EXPORT_SYMBOL_GPL(dev_attr_unload_heads);
-bool ata_scsi_sense_is_valid(u8 sk, u8 asc, u8 ascq)
+bool ata_scsi_sense_is_valid(u8 sense_key, u16 sense_code)
{
- /*
- * If sk == NO_SENSE, and asc + ascq == NO ADDITIONAL SENSE INFORMATION,
- * then there is no sense data to add.
- */
- if (sk == 0 && asc == 0 && ascq == 0)
+ if (sense_key == NO_SENSE &&
+ sense_code == NO_ADDITIONAL_SENSE_INFORMATION)
return false;
/* If sk > COMPLETED, sense data is bogus. */
- if (sk > COMPLETED)
+ if (sense_key > COMPLETED)
return false;
return true;
}
void ata_scsi_set_sense(struct ata_device *dev, struct scsi_cmnd *cmd,
- u8 sk, u8 asc, u8 ascq)
+ u8 sk, u16 code)
{
bool d_sense = (dev->flags & ATA_DFLAG_D_SENSE);
- scsi_build_sense(cmd, d_sense, sk, asc, ascq);
+ scsi_set_sense(cmd, d_sense, sk, code);
}
static void ata_scsi_set_sense_information(struct ata_queued_cmd *qc)
@@ -316,8 +313,7 @@ static void ata_scsi_set_passthru_sense_fields(struct ata_queued_cmd *qc)
static void ata_scsi_set_invalid_field(struct ata_device *dev,
struct scsi_cmnd *cmd, u16 field, u8 bit)
{
- ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x24, 0x0);
- /* "Invalid field in CDB" */
+ ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
scsi_set_sense_field_pointer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
field, bit, 1);
}
@@ -325,8 +321,8 @@ static void ata_scsi_set_invalid_field(struct ata_device *dev,
static void ata_scsi_set_invalid_parameter(struct ata_device *dev,
struct scsi_cmnd *cmd, u16 field)
{
- /* "Invalid field in parameter list" */
- ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x26, 0x0);
+ ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_PARAMETER_LIST);
scsi_set_sense_field_pointer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
field, 0xff, 0);
}
@@ -525,7 +521,8 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
* check condition even if no error. Filter that. */
if (scsi_status_is_check_condition(cmd_result)) {
if (sshdr.sense_key == RECOVERED_ERROR &&
- sshdr.asc == 0 && sshdr.ascq == 0x1d)
+ sshdr.sense_code ==
+ ATA_PASS_THROUGH_INFORMATION_AVAILABLE)
cmd_result &= ~SAM_STAT_CHECK_CONDITION;
}
@@ -613,7 +610,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
* check condition even if no error. Filter that. */
if (cmd_result & SAM_STAT_CHECK_CONDITION) {
if (sshdr.sense_key == RECOVERED_ERROR &&
- sshdr.asc == 0 && sshdr.ascq == 0x1d)
+ sshdr.sense_code ==
+ ATA_PASS_THROUGH_INFORMATION_AVAILABLE)
cmd_result &= ~SAM_STAT_CHECK_CONDITION;
}
@@ -792,79 +790,143 @@ static void ata_qc_set_pc_nbytes(struct ata_queued_cmd *qc)
qc->nbytes = scsi_bufflen(scmd) + qc->extrabytes;
}
+struct ata_err_sense {
+ u8 err_mask;
+ u8 sense_key;
+ u16 sense_code;
+};
+
/**
* ata_to_sense_error - convert ATA error to SCSI error
* @drv_stat: value contained in ATA status register
* @drv_err: value contained in ATA error register
* @sk: the sense key we'll fill out
- * @asc: the additional sense code we'll fill out
- * @ascq: the additional sense code qualifier we'll fill out
+ * @scode: the additional sense code and its qualifier we'll fill out
*
* Converts an ATA error into a SCSI error. Fill out pointers to
- * SK, ASC, and ASCQ bytes for later use in fixed or descriptor
+ * the sense key and sense code for later use in fixed or descriptor
* format sense blocks.
*
* LOCKING:
* spin_lock_irqsave(host lock)
*/
-static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
- u8 *ascq)
+static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u16 *scode)
{
int i;
/* Based on the 3ware driver translation table */
- static const unsigned char sense_table[][4] = {
- /* BBD|ECC|ID|MAR */
- {0xd1, ABORTED_COMMAND, 0x00, 0x00},
- // Device busy Aborted command
- /* BBD|ECC|ID */
- {0xd0, ABORTED_COMMAND, 0x00, 0x00},
- // Device busy Aborted command
- /* ECC|MC|MARK */
- {0x61, HARDWARE_ERROR, 0x00, 0x00},
- // Device fault Hardware error
- /* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
- {0x84, ABORTED_COMMAND, 0x47, 0x00},
- // Data CRC error SCSI parity error
- /* MC|ID|ABRT|TRK0|MARK */
- {0x37, NOT_READY, 0x04, 0x00},
- // Unit offline Not ready
- /* MCR|MARK */
- {0x09, NOT_READY, 0x04, 0x00},
- // Unrecovered disk error Not ready
- /* Bad address mark */
- {0x01, MEDIUM_ERROR, 0x13, 0x00},
- // Address mark not found for data field
- /* TRK0 - Track 0 not found */
- {0x02, HARDWARE_ERROR, 0x00, 0x00},
- // Hardware error
- /* Abort: 0x04 is not translated here, see below */
- /* Media change request */
- {0x08, NOT_READY, 0x04, 0x00},
- // FIXME: faking offline
- /* SRV/IDNF - ID not found */
- {0x10, ILLEGAL_REQUEST, 0x21, 0x00},
- // Logical address out of range
- /* MC - Media Changed */
- {0x20, UNIT_ATTENTION, 0x28, 0x00},
- // Not ready to ready change, medium may have changed
- /* ECC - Uncorrectable ECC error */
- {0x40, MEDIUM_ERROR, 0x11, 0x04},
- // Unrecovered read error
- /* BBD - block marked bad */
- {0x80, MEDIUM_ERROR, 0x11, 0x04},
- // Block marked bad Medium error, unrecovered read error
- {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
+ static const struct ata_err_sense sense_table[] = {
+ {
+ /* BBD|ECC|ID|MAR - Device busy */
+ 0xd1,
+ ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION
+ },
+ {
+ /* BBD|ECC|ID - Device busy */
+ 0xd0,
+ ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION
+ },
+ {
+ /* ECC|MC|MARK - Device fault */
+ 0x61,
+ HARDWARE_ERROR,
+ NO_ADDITIONAL_SENSE_INFORMATION
+ },
+ {
+ /* ICRC|ABRT - Data CRC error */
+ /* NB: ICRC & !ABRT is BBD */
+ 0x84,
+ ABORTED_COMMAND,
+ SCSI_PARITY_ERROR
+ },
+ {
+ /* MC|ID|ABRT|TRK0|MARK - Unit offline */
+ 0x37,
+ NOT_READY,
+ LU_NOT_READY
+ },
+ {
+ /* MCR|MARK - Unrecovered disk error */
+ 0x09,
+ NOT_READY,
+ LU_NOT_READY
+ },
+ {
+ /* Bad address mark */
+ 0x01,
+ MEDIUM_ERROR,
+ ADDRESS_MARK_NOT_FOUND_FOR_DATA_FIELD
+ },
+ {
+ /* TRK0 - Track 0 not found */
+ 0x02,
+ HARDWARE_ERROR,
+ NO_ADDITIONAL_SENSE_INFORMATION
+ },
+ {
+ /* Abort: 0x04 is not translated here, see below */
+ /* Media change request */
+ 0x08,
+ NOT_READY,
+ LU_NOT_READY
+ },
+ {
+ /* SRV/IDNF - ID not found */
+ 0x10,
+ ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE
+ },
+ {
+ /* MC - Media Changed */
+ 0x20,
+ UNIT_ATTENTION,
+ NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED
+ },
+ {
+ /* ECC - Uncorrectable ECC error */
+ 0x40,
+ MEDIUM_ERROR,
+ UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED
+ },
+ {
+ /* BBD - block marked bad */
+ 0x80,
+ MEDIUM_ERROR,
+ UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED
+ },
+ {
+ /* END mark */
+ 0xFF, 0xFF, 0xFFFF
+ },
};
- static const unsigned char stat_table[][4] = {
- /* Busy: must be first because BUSY means no other bits valid */
- { ATA_BUSY, ABORTED_COMMAND, 0x00, 0x00 },
- /* Device fault: INTERNAL TARGET FAILURE */
- { ATA_DF, HARDWARE_ERROR, 0x44, 0x00 },
- /* Corrected data error */
- { ATA_CORR, RECOVERED_ERROR, 0x00, 0x00 },
-
- { 0xFF, 0xFF, 0xFF, 0xFF }, /* END mark */
+ static const struct ata_err_sense stat_table[] = {
+ {
+ /*
+ * Busy: must be first because BUSY means no other bits
+ * valid.
+ */
+ ATA_BUSY,
+ ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION
+ },
+ {
+ /* Device fault */
+ ATA_DF,
+ HARDWARE_ERROR,
+ INTERNAL_TARGET_FAILURE
+ },
+ {
+ /* Corrected data error */
+ ATA_CORR,
+ RECOVERED_ERROR,
+ NO_ADDITIONAL_SENSE_INFORMATION
+ },
+ {
+ /* END mark */
+ 0xFF, 0xFF, 0xFFFF
+ },
};
/*
@@ -876,13 +938,12 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
if (drv_err) {
/* Look for drv_err */
- for (i = 0; sense_table[i][0] != 0xFF; i++) {
+ for (i = 0; sense_table[i].err_mask != 0xFF; i++) {
/* Look for best matches first */
- if ((sense_table[i][0] & drv_err) ==
- sense_table[i][0]) {
- *sk = sense_table[i][1];
- *asc = sense_table[i][2];
- *ascq = sense_table[i][3];
+ if ((sense_table[i].err_mask & drv_err) ==
+ sense_table[i].err_mask) {
+ *sk = sense_table[i].sense_key;
+ *scode = sense_table[i].sense_code;
return;
}
}
@@ -893,11 +954,10 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
* has only the ABRT bit set, we decode drv_stat. ABRT by itself
* is not descriptive enough.
*/
- for (i = 0; stat_table[i][0] != 0xFF; i++) {
- if (stat_table[i][0] & drv_stat) {
- *sk = stat_table[i][1];
- *asc = stat_table[i][2];
- *ascq = stat_table[i][3];
+ for (i = 0; stat_table[i].err_mask != 0xFF; i++) {
+ if (stat_table[i].err_mask & drv_stat) {
+ *sk = stat_table[i].sense_key;
+ *scode = stat_table[i].sense_code;
return;
}
}
@@ -907,8 +967,7 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
* that won't cause people to do things like return a disk wrongly.
*/
*sk = ABORTED_COMMAND;
- *asc = 0x00;
- *ascq = 0x00;
+ *scode = NO_ADDITIONAL_SENSE_INFORMATION;
}
/*
@@ -931,40 +990,41 @@ static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
struct ata_device *dev = qc->dev;
struct scsi_cmnd *cmd = qc->scsicmd;
struct ata_taskfile *tf = &qc->result_tf;
- u8 sense_key, asc, ascq;
+ u16 sense_code;
+ u8 sense_key;
if (!(qc->flags & ATA_QCFLAG_RTF_FILLED)) {
ata_dev_dbg(dev,
"missing result TF: can't generate ATA PT sense data\n");
if (qc->err_mask)
- ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
+ ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION);
return;
}
/*
- * Use ata_to_sense_error() to map status register bits
- * onto sense key, asc & ascq.
+ * Use ata_to_sense_error() to map status register bits onto sense key
+ * and sense code.
*/
if (qc->err_mask ||
tf->status & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
ata_to_sense_error(tf->status, tf->error,
- &sense_key, &asc, &ascq);
- ata_scsi_set_sense(qc->dev, cmd, sense_key, asc, ascq);
- } else {
- /*
- * ATA PASS-THROUGH INFORMATION AVAILABLE
- *
- * Note: we are supposed to call ata_scsi_set_sense(), which
- * respects the D_SENSE bit, instead of unconditionally
- * generating the sense data in descriptor format. However,
- * because hdparm, hddtemp, and udisks incorrectly assume sense
- * data in descriptor format, without even looking at the
- * RESPONSE CODE field in the returned sense data (to see which
- * format the returned sense data is in), we are stuck with
- * being bug compatible with older kernels.
- */
- scsi_build_sense(cmd, 1, RECOVERED_ERROR, 0, 0x1D);
+ &sense_key, &sense_code);
+ ata_scsi_set_sense(qc->dev, cmd, sense_key, sense_code);
+ return;
}
+
+ /*
+ * Note: we are supposed to call ata_scsi_set_sense(), which respects
+ * the D_SENSE bit, instead of unconditionally generating the sense data
+ * in descriptor format. However, because hdparm, hddtemp, and udisks
+ * incorrectly assume sense data in descriptor format, without even
+ * looking at the RESPONSE CODE field in the returned sense data (to see
+ * which format the returned sense data is in), we are stuck with being
+ * bug compatible with older kernels.
+ */
+ scsi_set_sense(cmd, 1, RECOVERED_ERROR,
+ ATA_PASS_THROUGH_INFORMATION_AVAILABLE);
}
/**
@@ -981,19 +1041,18 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
struct ata_device *dev = qc->dev;
struct scsi_cmnd *cmd = qc->scsicmd;
struct ata_taskfile *tf = &qc->result_tf;
- u8 sense_key, asc, ascq;
if (ata_dev_disabled(dev)) {
/* Device disabled after error recovery */
- /* LOGICAL UNIT NOT READY, HARD RESET REQUIRED */
- ata_scsi_set_sense(dev, cmd, NOT_READY, 0x04, 0x21);
+ ata_scsi_set_sense(dev, cmd, NOT_READY,
+ LU_NOT_READY_HARD_RESET_REQUIRED);
return;
}
if (ata_id_is_locked(dev->id)) {
/* Security locked */
- /* LOGICAL UNIT ACCESS NOT AUTHORIZED */
- ata_scsi_set_sense(dev, cmd, DATA_PROTECT, 0x74, 0x71);
+ ata_scsi_set_sense(dev, cmd, DATA_PROTECT,
+ LU_ACCESS_NOT_AUTHORIZED);
return;
}
@@ -1008,9 +1067,12 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
*/
if (qc->err_mask ||
tf->status & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
+ u16 sense_code;
+ u8 sense_key;
+
ata_to_sense_error(tf->status, tf->error,
- &sense_key, &asc, &ascq);
- ata_scsi_set_sense(dev, cmd, sense_key, asc, ascq);
+ &sense_key, &sense_code);
+ ata_scsi_set_sense(dev, cmd, sense_key, sense_code);
return;
}
@@ -1019,7 +1081,8 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
"Could not decode error 0x%x, status 0x%x (err_mask=0x%x)\n",
tf->error, tf->status, qc->err_mask);
aborted:
- ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
+ ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION);
}
void ata_scsi_sdev_config(struct scsi_device *sdev)
@@ -1273,7 +1336,8 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
/* Ignore IMMED bit (cdb[1] & 0x1), violates sat-r05 */
if (!ata_dev_power_init_tf(qc->dev, &qc->tf, cdb[4] & 0x1)) {
- ata_scsi_set_sense(qc->dev, scmd, ABORTED_COMMAND, 0, 0);
+ ata_scsi_set_sense(qc->dev, scmd, ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION);
return 1;
}
@@ -1501,8 +1565,8 @@ static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
return 1;
out_of_range:
- ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x21, 0x0);
- /* "Logical Block Address out of range" */
+ ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return 1;
nothing_to_do:
@@ -1638,8 +1702,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
return 1;
out_of_range:
- ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x21, 0x0);
- /* "Logical Block Address out of range" */
+ ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
+ LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return 1;
nothing_to_do:
@@ -2015,7 +2079,8 @@ static void ata_scsi_rbuf_fill(struct ata_device *dev, struct scsi_cmnd *cmd,
len = actor(dev, cmd, ata_scsi_rbuf);
if (len) {
if (WARN_ON(len > ATA_SCSI_RBUF_SIZE)) {
- ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
+ ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
+ NO_ADDITIONAL_SENSE_INFORMATION);
spin_unlock_irqrestore(&ata_scsi_rbuf_lock, flags);
return;
}
@@ -2894,8 +2959,8 @@ static unsigned int ata_scsiop_mode_sense(struct ata_device *dev,
return 0;
saving_not_supp:
- ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x39, 0x0);
- /* "Saving parameters not supported" */
+ ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
+ SAVING_PARAMETERS_NOT_SUPPORTED);
return 0;
}
@@ -3732,12 +3797,12 @@ static unsigned int ata_scsi_write_same_xlat(struct ata_queued_cmd *qc)
ata_scsi_set_invalid_field(dev, scmd, fp, bp);
return 1;
invalid_param_len:
- /* "Parameter list length error" */
- ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
+ ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
+ PARAMETER_LIST_LENGTH_ERROR);
return 1;
invalid_opcode:
- /* "Invalid command operation code" */
- ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
+ ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
return 1;
}
@@ -4199,8 +4264,8 @@ static unsigned int ata_scsi_zbc_in_xlat(struct ata_queued_cmd *qc)
return 1;
invalid_param_len:
- /* "Parameter list length error" */
- ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
+ ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
+ PARAMETER_LIST_LENGTH_ERROR);
return 1;
}
@@ -4277,8 +4342,8 @@ static unsigned int ata_scsi_zbc_out_xlat(struct ata_queued_cmd *qc)
ata_scsi_set_invalid_field(qc->dev, scmd, fp, 0xff);
return 1;
invalid_param_len:
- /* "Parameter list length error" */
- ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
+ ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
+ PARAMETER_LIST_LENGTH_ERROR);
return 1;
}
@@ -4629,8 +4694,8 @@ static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc)
return 1;
invalid_param_len:
- /* "Parameter list length error" */
- ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
+ ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
+ PARAMETER_LIST_LENGTH_ERROR);
return 1;
skip:
@@ -4789,7 +4854,8 @@ ata_scsi_get_phys_element_status_xlat(struct ata_queued_cmd *qc)
/* ATA_CMD_GET_PHYS_ELEMENT_STATUS is a DMA command. */
if (!(dev->flags & ATA_DFLAG_DEPOP) || !ata_dma_enabled(dev)) {
- ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
+ ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
return 1;
}
@@ -4841,7 +4907,7 @@ static void ata_scsi_depop_ua_cap_changed_complete(struct ata_queued_cmd *qc)
*/
if (is_success && !is_ata_passthru)
ata_scsi_set_sense(qc->dev, scmd, UNIT_ATTENTION,
- UA_CHANGED_ASC, CAPACITY_CHANGED_ASCQ);
+ CAPACITY_DATA_HAS_CHANGED);
ata_scsi_qc_complete(qc);
}
@@ -4856,7 +4922,8 @@ ata_scsi_remove_element_and_truncate_xlat(struct ata_queued_cmd *qc)
u32 id;
if (!(dev->flags & ATA_DFLAG_DEPOP)) {
- ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
+ ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
return 1;
}
@@ -4899,7 +4966,8 @@ ata_scsi_remove_element_and_modify_zones_xlat(struct ata_queued_cmd *qc)
u32 id;
if (!(dev->flags & ATA_DFLAG_DEPOP_MODIFY)) {
- ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
+ ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
return 1;
}
@@ -4927,7 +4995,8 @@ ata_scsi_restore_elements_and_rebuild_xlat(struct ata_queued_cmd *qc)
struct ata_taskfile *tf = &qc->tf;
if (!(dev->flags & ATA_DFLAG_DEPOP_RESTORE)) {
- ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
+ ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
return 1;
}
@@ -5088,7 +5157,8 @@ static void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
break;
case REQUEST_SENSE:
- ata_scsi_set_sense(dev, cmd, 0, 0, 0);
+ ata_scsi_set_sense(dev, cmd, NO_SENSE,
+ NO_ADDITIONAL_SENSE_INFORMATION);
break;
/* if we reach this, then writeback caching is disabled,
@@ -5117,8 +5187,8 @@ static void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
/* all other commands */
default:
- ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x20, 0x0);
- /* "Invalid command operation code" */
+ ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OP_CODE);
break;
}
diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h
index 48274691cd0e..d222a2c92efc 100644
--- a/drivers/ata/libata.h
+++ b/drivers/ata/libata.h
@@ -164,9 +164,10 @@ extern int ata_scsi_add_hosts(struct ata_host *host,
const struct scsi_host_template *sht);
extern void ata_scsi_scan_host(struct ata_port *ap, int sync);
extern bool ata_scsi_offline_dev(struct ata_device *dev);
-extern bool ata_scsi_sense_is_valid(u8 sk, u8 asc, u8 ascq);
+extern bool ata_scsi_sense_is_valid(u8 sense_key, u16 sense_code);
extern void ata_scsi_set_sense(struct ata_device *dev,
- struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq);
+ struct scsi_cmnd *cmd, u8 sense_key,
+ u16 sense_code);
extern void ata_scsi_media_change_notify(struct ata_device *dev);
extern void ata_scsi_hotplug(struct work_struct *work);
extern void ata_scsi_dev_rescan(struct work_struct *work);
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 36/37] ata: libata: use 16-bits defined sense codes
2026-08-31 2:04 ` [PATCH 36/37] ata: libata: " Damien Le Moal
@ 2026-09-02 11:29 ` Niklas Cassel
0 siblings, 0 replies; 51+ messages in thread
From: Niklas Cassel @ 2026-09-02 11:29 UTC (permalink / raw)
To: Damien Le Moal
Cc: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, linux-usb, Alan Stern, Greg Kroah-Hartman
On Mon, Aug 31, 2026 at 11:04:50AM +0900, Damien Le Moal wrote:
> Refactor libata core code to use the 16-bits sense_code field of
> struct scsi_sense_hdr and replace all hard-coded additional sense codes
> and additional sense code qualifiers with the enum values defined in
> include/scsi/scsi_sense.h. This helps with code clarity as the sense codes
> being processed are easier to test and self-documented.
>
> No functional change intended.
>
> Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
> ---
> drivers/ata/libata-eh.c | 13 +-
> drivers/ata/libata-sata.c | 14 +-
> drivers/ata/libata-scsi.c | 346 +++++++++++++++++++++++---------------
> drivers/ata/libata.h | 5 +-
> 4 files changed, 226 insertions(+), 152 deletions(-)
>
> diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
> index c93c24b22d9c..71961fbaa42f 100644
> --- a/drivers/ata/libata-eh.c
> +++ b/drivers/ata/libata-eh.c
> @@ -1516,11 +1516,13 @@ static bool ata_eh_request_sense(struct ata_queued_cmd *qc)
> err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
> /* 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)) {
> + u16 sense_code = scsi_sense_code(tf.lbam, tf.lbal);
Here you take asc and ascq and combine them to one.
I see the reason, since ata_scsi_sense_is_valid() takes a u16 sense code.
That is fine, and I think makes ata_scsi_sense_is_valid() easier to read.
> +
> + if (ata_scsi_sense_is_valid(tf.lbah, sense_code)) {
> /* 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);
> + scsi_set_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
> + cmd->sense_buffer, tf.lbah,
> + sense_code);
However, here you call scsi_set_sense_buffer() which is just an inline
function that calls:
scsi_build_sense_buffer(desc, buf, key, scsi_sense_code_asc(code),
scsi_sense_code_ascq(code));
which will call scsi_sense_code_asc() and scsi_sense_code_ascq() to
split sense_code to asc and ascq again.
It seems that you series has decided to not kill scsi_build_sense_buffer().
As long as scsi_build_sense_buffer() exists, and since we already have asc
and ascq stored in separate variables, I think we should let this code
continue calling scsi_build_sense_buffer().
Especially since, even after this series, we still will have a call to
scsi_build_sense_buffer() in libata-sata.c:ata_eh_get_ncq_success_sense().
I think either this function and ata_eh_get_ncq_success_sense() should both
call scsi_build_sense_buffer(), or both should call scsi_set_sense_buffer().
Is there a reason why you don't convert all scsi_build_sense_buffer() users
to scsi_set_sense_buffer() and drop scsi_build_sense_buffer() ?
You could even keep the same function name (scsi_build_sense_buffer()) and
just have it take an u16 sense_code instead of u8 asc + u8 ascq?
(Doing a git grep scsi_build_sense_buffer shows a few users even after this
series.)
Kind regards,
Niklas
^ permalink raw reply [flat|nested] 51+ messages in thread
* [PATCH 37/37] scsi: cleanup scsi_proto.h
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (35 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 36/37] ata: libata: " Damien Le Moal
@ 2026-08-31 2:04 ` Damien Le Moal
2026-08-31 2:31 ` sashiko-bot
2026-08-31 2:36 ` [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
37 siblings, 1 reply; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:04 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
Now that all users of SCSI sense codes have been modified to use macro
definitions and the 16-bits sense code instead of separate 8-bits ASC and
ASCQ, remove the now unused asc and ascq fields of struct scsi_failure and
struct scsi_sense_hdr, and the old (and incomplete) definitions of SCSI
additional sense codes and sense code qualifiers in scsi_proto.h.
Signed-off-by: Damien Le Moal <dlemoal@kernel.org>
---
include/scsi/scsi_common.h | 13 +---------
include/scsi/scsi_device.h | 13 +---------
include/scsi/scsi_proto.h | 51 --------------------------------------
3 files changed, 2 insertions(+), 75 deletions(-)
diff --git a/include/scsi/scsi_common.h b/include/scsi/scsi_common.h
index 6fb2c290ba33..405512554ee8 100644
--- a/include/scsi/scsi_common.h
+++ b/include/scsi/scsi_common.h
@@ -71,18 +71,7 @@ extern u64 scsilun_to_int(struct scsi_lun *);
struct scsi_sense_hdr { /* See SPC-3 section 4.5 */
u8 response_code; /* permit: 0x0, 0x70, 0x71, 0x72, 0x73 */
u8 sense_key;
- union {
- struct {
-#if defined(__BIG_ENDIAN)
- u8 asc;
- u8 ascq;
-#elif defined(__LITTLE_ENDIAN)
- u8 ascq;
- u8 asc;
-#endif
- };
- u16 sense_code;
- };
+ u16 sense_code;
u8 byte4;
u8 byte5;
u8 byte6;
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 11910142ac50..e6fd6bc30644 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -527,18 +527,7 @@ extern void scsi_sanitize_inquiry_string(unsigned char *s, int len);
struct scsi_failure {
int result;
u8 sense_key;
- union {
- struct {
-#if defined(__BIG_ENDIAN)
- u8 asc;
- u8 ascq;
-#elif defined(__LITTLE_ENDIAN)
- u8 ascq;
- u8 asc;
-#endif
- };
- u16 sense_code;
- };
+ u16 sense_code;
/*
* Number of times scsi_execute_cmd will retry the failure. It does
* not count for the total_allowed.
diff --git a/include/scsi/scsi_proto.h b/include/scsi/scsi_proto.h
index f742a3bfeb86..9c7d31aa6bae 100644
--- a/include/scsi/scsi_proto.h
+++ b/include/scsi/scsi_proto.h
@@ -219,57 +219,6 @@ enum sam_status {
#define STATUS_MASK 0xfe
-/*
- * Additional Sense Codes (ASC).
- */
-#define NO_ADDITIONAL_SENSE 0x00
-#define OVERLAP_ATOMIC_COMMAND_ASC 0x00
-#define LOGICAL_UNIT_NOT_READY 0x04
-#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
-#define WRITE_ERROR_ASC 0x0c
-#define UNRECOVERED_READ_ERR 0x11
-#define PARAMETER_LIST_LENGTH_ERR 0x1a
-#define MISCOMPARE_VERIFY_ASC 0x1d
-#define INVALID_OPCODE 0x20
-#define LBA_OUT_OF_RANGE 0x21
-#define INVALID_FIELD_IN_CDB 0x24
-#define INVALID_FIELD_IN_PARAM_LIST 0x26
-#define WRITE_PROTECTED 0x27
-#define UA_READY_ASC 0x28
-#define UA_RESET_ASC 0x29
-#define UA_CHANGED_ASC 0x2a
-#define TOO_MANY_IN_PARTITION_ASC 0x3b
-#define TARGET_CHANGED_ASC 0x3f
-#define SAVING_PARAMS_UNSUP 0x39
-#define TRANSPORT_PROBLEM 0x4b
-#define INSUFF_RES_ASC 0x55
-#define LOW_POWER_COND_ON 0x5e
-#define THRESHOLD_EXCEEDED 0x5d
-
-/*
- * Additional Sense Code Qualifiers (ASCQ).
- */
-#define POWER_ON_RESET_ASCQ 0x00
-#define MODE_CHANGED_ASCQ 0x01 /* mode parameters changed */
-#define FILEMARK_DETECTED_ASCQ 0x01
-#define POWER_ON_OCCURRED_ASCQ 0x01
-#define MICROCODE_CHANGED_ASCQ 0x01 /* with TARGET_CHANGED_ASC */
-#define BUS_RESET_ASCQ 0x02 /* scsi bus reset occurred */
-#define EOP_EOM_DETECTED_ASCQ 0x02
-#define INSUFF_RES_ASCQ 0x03
-#define BEGINNING_OF_P_M_DETECTED_ASCQ 0x04
-#define UNALIGNED_WRITE_ASCQ 0x04
-#define EOD_DETECTED_ASCQ 0x05
-#define WRITE_BOUNDARY_ASCQ 0x05
-#define READ_INVDATA_ASCQ 0x06
-#define READ_BOUNDARY_ASCQ 0x07
-#define CAPACITY_CHANGED_ASCQ 0x09
-#define ATTEMPT_ACCESS_GAP 0x09
-#define LUNS_CHANGED_ASCQ 0x0e
-#define INSUFF_ZONE_ASCQ 0x0e
-#define MICROCODE_CHANGED_WO_RESET_ASCQ 0x16
-#define OVERLAP_ATOMIC_COMMAND_ASCQ 0x23
-
/*
* DEVICE TYPES
* Please keep them in 0x%02x format for $MODALIAS to work
--
2.55.0
^ permalink raw reply related [flat|nested] 51+ messages in thread* Re: [PATCH 37/37] scsi: cleanup scsi_proto.h
2026-08-31 2:04 ` [PATCH 37/37] scsi: cleanup scsi_proto.h Damien Le Moal
@ 2026-08-31 2:31 ` sashiko-bot
0 siblings, 0 replies; 51+ messages in thread
From: sashiko-bot @ 2026-08-31 2:31 UTC (permalink / raw)
To: Damien Le Moal; +Cc: dlemoal, cassel, linux-scsi, linux-ide
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Trace event records incorrect ASCQ value due to a copy-paste error.
--
commit 18b8d3cbe68a6be05817a223fa4182ba612faa08
Author: Damien Le Moal <dlemoal@kernel.org>
scsi: core: use 16-bits defined sense codes
This commit refactors the SCSI core code to use the 16-bit sense_code field
instead of separate 8-bit ASC and ASCQ fields. It updates various structure
fields and sense code logic to utilize macro definitions from
include/scsi/scsi_sense.h to improve code clarity and testing.
> diff --git a/include/trace/events/scsi.h b/include/trace/events/scsi.h
> index c36c72ab7f2bf..4d17c9b61e44a 100644
> --- a/include/trace/events/scsi.h
> +++ b/include/trace/events/scsi.h
> @@ -303,8 +303,8 @@ DECLARE_EVENT_CLASS(scsi_cmd_done_timeout_template,
> if (cmd->sense_buffer && SCSI_SENSE_VALID(cmd) &&
> scsi_command_normalize_sense(cmd, &sshdr)) {
> __entry->sense_key = sshdr.sense_key;
> - __entry->asc = sshdr.asc;
> - __entry->ascq = sshdr.ascq;
> + __entry->asc = scsi_sense_asc(&sshdr);
> + __entry->ascq = scsi_sense_asc(&sshdr);
[Severity: Medium]
Is there a copy-paste error here where the trace event records an incorrect
ASCQ value?
Assigning scsi_sense_asc(&sshdr) to __entry->ascq instead of
scsi_sense_ascq(&sshdr) will duplicate the ASC value, losing the actual
Additional Sense Code Qualifier in the trace output.
> } else {
> __entry->sense_key = 0;
> __entry->asc = 0;
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260831020451.585944-1-dlemoal@kernel.org?part=37
^ permalink raw reply [flat|nested] 51+ messages in thread
* Re: [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations
2026-08-31 2:04 [PATCH 00/37] Use defined 16-bits ASC/ASCQ combinations Damien Le Moal
` (36 preceding siblings ...)
2026-08-31 2:04 ` [PATCH 37/37] scsi: cleanup scsi_proto.h Damien Le Moal
@ 2026-08-31 2:36 ` Damien Le Moal
37 siblings, 0 replies; 51+ messages in thread
From: Damien Le Moal @ 2026-08-31 2:36 UTC (permalink / raw)
To: Martin K . Petersen, James E . J . Bottomley, linux-scsi,
linux-ide, Niklas Cassel, linux-usb, Alan Stern,
Greg Kroah-Hartman
On 8/31/26 11:04, Damien Le Moal wrote:
> Martin, James,
>
> This patch series defines as macros all ASC/ASCQ combinations present in
> https://www.t10.org/lists/asc-num.txt and converts the SCSI core code and
> SCSI low level drivers to use these macros instead of hard-coded
> ASC/ASCQs. To do this, struct scsi_sense_hdr and struct scsi_failure are
> modified to replace the asc and ascq 8-bits fields with a 16-bits
> sense_code field.
>
> This cleans up the code in many places and makes it easier, and self
> documented, to test sense codes in the case of errors.
>
> Overall, there should be no functional chnages here.
Sashiko pointed out a couple of valid mistakes in this series that I fixed
locally. I will wait for further comments before sending v2.
Sashiko also pointed out further pre-existing issues that I am not going to
address with this series.
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 51+ messages in thread