diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig index 1eec66195cf4..90b65bebec70 100644 --- a/drivers/scsi/Kconfig +++ b/drivers/scsi/Kconfig @@ -569,7 +569,8 @@ config SCSI_MYRS config VMWARE_PVSCSI tristate "VMware PVSCSI driver support" - depends on PCI && SCSI && X86 + depends on PCI && SCSI + depends on X86 || (ARM64 && !CPU_BIG_ENDIAN && PAGE_SIZE_4KB) help This driver supports VMware's para virtualized SCSI HBA. To compile this driver as a module, choose M here: the diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c index 87ac0a6d63e5..06eb35cc9d7c 100644 --- a/drivers/scsi/device_handler/scsi_dh_alua.c +++ b/drivers/scsi/device_handler/scsi_dh_alua.c @@ -29,9 +29,6 @@ #define TPGS_SUPPORT_TRANSITION 0x80 #define TPGS_SUPPORT_ALL 0xdf -#define RTPG_FMT_MASK 0x70 -#define RTPG_FMT_EXT_HDR 0x10 - #define TPGS_MODE_UNINITIALIZED -1 #define TPGS_MODE_NONE 0x0 #define TPGS_MODE_IMPLICIT 0x1 @@ -120,34 +117,6 @@ static void release_port_group(struct kref *kref) kfree_rcu(pg, rcu); } -/* - * submit_rtpg - Issue a REPORT TARGET GROUP STATES command - * @sdev: sdev the command should be sent to - */ -static int submit_rtpg(struct scsi_device *sdev, unsigned char *buff, - int bufflen, struct scsi_sense_hdr *sshdr, int flags) -{ - u8 cdb[MAX_COMMAND_SIZE]; - blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV | - REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER; - const struct scsi_exec_args exec_args = { - .sshdr = sshdr, - }; - - /* Prepare the command. */ - memset(cdb, 0x0, MAX_COMMAND_SIZE); - cdb[0] = MAINTENANCE_IN; - if (!(flags & ALUA_RTPG_EXT_HDR_UNSUPP)) - cdb[1] = MI_REPORT_TARGET_PGS | MI_EXT_HDR_PARAM_FMT; - else - cdb[1] = MI_REPORT_TARGET_PGS; - put_unaligned_be32(bufflen, &cdb[6]); - - return scsi_execute_cmd(sdev, cdb, opf, buff, bufflen, - ALUA_FAILOVER_TIMEOUT * HZ, - ALUA_FAILOVER_RETRIES, &exec_args); -} - /* * submit_stpg - Issue a SET TARGET PORT GROUP command * @@ -518,6 +487,9 @@ static int alua_tur(struct scsi_device *sdev) static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) { struct scsi_sense_hdr sense_hdr; + const struct scsi_exec_args exec_args = { + .sshdr = &sense_hdr, + }; struct alua_port_group *tmp_pg; int len, k, off, bufflen = ALUA_RTPG_SIZE; int group_id_old, state_old, pref_old, valid_states_old; @@ -549,7 +521,17 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) retry: err = 0; - retval = submit_rtpg(sdev, buff, bufflen, &sense_hdr, pg->flags); + retval = scsi_report_tpgs(sdev, &buff, &bufflen, + !(pg->flags & ALUA_RTPG_EXT_HDR_UNSUPP), + ALUA_FAILOVER_TIMEOUT * HZ, + ALUA_FAILOVER_RETRIES, &exec_args); + if (!buff) { + sdev_printk(KERN_WARNING, sdev, + "%s: kmalloc buffer failed\n", __func__); + /* Temporary failure, bypass */ + pg->expiry = 0; + return SCSI_DH_DEV_TEMP_BUSY; + } if (retval) { /* @@ -581,7 +563,7 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) } /* - * submit_rtpg() has failed on existing arrays + * scsi_report_tpgs() has failed on existing arrays * when requesting extended header info, and * the array doesn't support extended headers, * even though it shouldn't according to T10. @@ -629,21 +611,6 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) len = get_unaligned_be32(&buff[0]) + 4; - if (len > bufflen) { - /* Resubmit with the correct length */ - kfree(buff); - bufflen = len; - buff = kmalloc(bufflen, GFP_KERNEL); - if (!buff) { - sdev_printk(KERN_WARNING, sdev, - "%s: kmalloc buffer failed\n",__func__); - /* Temporary failure, bypass */ - pg->expiry = 0; - return SCSI_DH_DEV_TEMP_BUSY; - } - goto retry; - } - orig_transition_tmo = pg->transition_tmo; if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR && buff[5] != 0) pg->transition_tmo = buff[5]; diff --git a/drivers/scsi/mvme16x_scsi.c b/drivers/scsi/mvme16x_scsi.c index f4db93c13986..ff6b22c864a9 100644 --- a/drivers/scsi/mvme16x_scsi.c +++ b/drivers/scsi/mvme16x_scsi.c @@ -60,6 +60,7 @@ static int mvme16x_probe(struct platform_device *dev) hostdata->base = (void __iomem *)0xfff47000UL; hostdata->clock = 50; /* XXX - depends on the CPU clock! */ hostdata->chip710 = 1; + hostdata->burst_length = 8; hostdata->dmode_extra = DMODE_FC2; hostdata->dcntl_extra = EA_710; hostdata->ctest7_extra = CTEST7_TT1; diff --git a/drivers/scsi/qedf/qedf_main.c b/drivers/scsi/qedf/qedf_main.c index da429b3a4283..f2bc0ac684e0 100644 --- a/drivers/scsi/qedf/qedf_main.c +++ b/drivers/scsi/qedf/qedf_main.c @@ -2496,7 +2496,6 @@ static void qedf_recv_frame(struct qedf_ctx *qedf, /* Pull the header */ hp = (struct fcoe_hdr *)skb->data; - fh = (struct fc_frame_header *) skb_transport_header(skb); skb_pull(skb, sizeof(struct fcoe_hdr)); fr_len = skb->len - sizeof(struct fcoe_crc_eof); diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c index cfc259fd0141..b1f3bcd739b4 100644 --- a/drivers/scsi/scsi_devinfo.c +++ b/drivers/scsi/scsi_devinfo.c @@ -688,6 +688,7 @@ static ssize_t proc_scsi_devinfo_write(struct file *file, { char *buffer; ssize_t err = length; + int ret; if (!buf || length>PAGE_SIZE) return -EINVAL; @@ -706,7 +707,9 @@ static ssize_t proc_scsi_devinfo_write(struct file *file, goto out; } - scsi_dev_info_list_add_str(buffer); + ret = scsi_dev_info_list_add_str(buffer); + if (ret) + err = ret; out: kfree(buffer); diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c index 75442d60c30e..b8d3c6f2ad33 100644 --- a/drivers/scsi/scsi_error.c +++ b/drivers/scsi/scsi_error.c @@ -27,6 +27,7 @@ #include #include #include +#include #include #include @@ -57,6 +58,21 @@ #define BUS_RESET_SETTLE_TIME (10) #define HOST_RESET_SETTLE_TIME (10) +/* + * Number of times a command is retried if it receives the same UNIT ATTENTION + * repeatedly before the error handler is invoked to clear that condition. + */ +#define SCSI_UA_RETRIES 2 +/* + * Maximum number of error handler invocations for a command with unlimited + * retries that keeps receiving the same UNIT ATTENTION. + */ +#define SCSI_UA_EH_ROUNDS 3 +/* Maximum number of TEST UNIT READY commands sent to clear a UNIT ATTENTION. */ +#define SCSI_EH_CLEAR_UA_TURS 4 +/* Delay in milliseconds before a TEST UNIT READY command is retried. */ +#define SCSI_EH_CLEAR_UA_RETRY_DELAY_MS 100 + static int scsi_eh_try_stu(struct scsi_cmnd *scmd); static enum scsi_disposition scsi_try_to_abort_cmd(const struct scsi_host_template *, struct scsi_cmnd *); @@ -559,17 +575,15 @@ static inline void set_scsi_ml_byte(struct scsi_cmnd *cmd, u8 status) } /** - * scsi_check_sense - Examine scsi cmd sense + * __scsi_check_sense - Examine scsi cmd sense * @scmd: Cmd to have sense checked. + * @escalate_ua: Whether to invoke the SCSI error handler for UNIT ATTENTION + * conditions that persist after retries. * - * Return value: - * SUCCESS or FAILED or NEEDS_RETRY or ADD_TO_MLQUEUE - * - * Notes: - * When a deferred error is detected the current command has - * not been executed and needs retrying. + * Return: SUCCESS, FAILED, NEEDS_RETRY or ADD_TO_MLQUEUE. */ -enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) +static enum scsi_disposition __scsi_check_sense(struct scsi_cmnd *scmd, + bool escalate_ua) { struct request *req = scsi_cmd_to_rq(scmd); struct scsi_device *sdev = scmd->device; @@ -716,6 +730,40 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) sshdr.sense_code == LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED) return FAILED; + /* + * Retry a UNIT ATTENTION that is reported repeatedly with the + * same additional sense code SCSI_UA_RETRIES times on the + * normal completion path for non-removable block requests, + * then invoke the error handler so TEST UNIT READY can clear a + * stuck UNIT ATTENTION. Use a dedicated counter instead of + * scmd->retries since the latter is also incremented for + * other retry reasons and by the error handler. Comparing the + * additional sense code prevents escalation if a target + * reports multiple queued UNIT ATTENTION conditions. + */ + if (escalate_ua && sshdr.sense_key == UNIT_ATTENTION && + !sdev->removable && !scsi_noretry_cmd(scmd)) { + u8 asc = scsi_sense_asc(&sshdr); + + if (scmd->ua_asc != asc) { + scmd->ua_asc = asc; + scmd->ua_count = 0; + } + if (scmd->ua_count < U8_MAX) + scmd->ua_count++; + if (scmd->ua_count <= SCSI_UA_RETRIES) + return NEEDS_RETRY; + /* + * scsi_eh_flush_done_q() limits the number of error + * handler invocations unless retries are unlimited. + * Pass the UNIT ATTENTION upwards in the latter case + * once SCSI_UA_EH_ROUNDS attempts to clear it failed. + */ + if (scmd->allowed == SCSI_CMD_RETRIES_NO_LIMIT && + scmd->ua_count > SCSI_UA_RETRIES + SCSI_UA_EH_ROUNDS) + return SUCCESS; + return FAILED; + } /* * Pass the UA upwards for a determination in the completion * functions. @@ -790,6 +838,27 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) return SUCCESS; } } + +/** + * scsi_check_sense - Examine scsi cmd sense + * @scmd: Cmd to have sense checked. + * + * Return value: + * SUCCESS or FAILED or NEEDS_RETRY or ADD_TO_MLQUEUE + * + * Notes: + * When a deferred error is detected the current command has + * not been executed and needs retrying. + * + * Unlike the sense data evaluation by scsi_decide_disposition(), this + * function never invokes the SCSI error handler for UNIT ATTENTION + * conditions that persist after retries. Callers with their own error + * handler, e.g. libata, rely on this. + */ +enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) +{ + return __scsi_check_sense(scmd, false); +} EXPORT_SYMBOL_GPL(scsi_check_sense); static void scsi_handle_queue_ramp_up(struct scsi_device *sdev) @@ -1582,6 +1651,33 @@ static int scsi_eh_try_stu(struct scsi_cmnd *scmd) return 1; } +/* + * Return true if @scmd completed with CHECK CONDITION and current (not + * deferred) sense data and store the normalized sense data in @sshdr. + */ +static bool scsi_cmd_current_sense(const struct scsi_cmnd *scmd, + struct scsi_sense_hdr *sshdr) +{ + if ((scmd->eh_eflags & SCSI_EH_ABORT_SCHEDULED) || + host_byte(scmd->result) != DID_OK || + !scsi_status_is_check_condition(scmd->result)) + return false; + + return scsi_command_normalize_sense(scmd, sshdr) && + !scsi_sense_is_deferred(sshdr); +} + +static bool scsi_cmd_needs_stu(const struct scsi_cmnd *scmd) +{ + struct scsi_sense_hdr sshdr; + + return scmd->device->allow_restart && + scsi_cmd_current_sense(scmd, &sshdr) && + (sshdr.sense_key == NOT_READY || + sshdr.sense_key == UNIT_ATTENTION) && + sshdr.sense_code == LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED; +} + /** * scsi_eh_stu - send START_UNIT if needed * @shost: &scsi host being recovered. @@ -1610,8 +1706,7 @@ static int scsi_eh_stu(struct Scsi_Host *shost, } stu_scmd = NULL; list_for_each_entry(scmd, work_q, eh_entry) - if (scmd->device == sdev && SCSI_SENSE_VALID(scmd) && - scsi_check_sense(scmd) == FAILED ) { + if (scmd->device == sdev && scsi_cmd_needs_stu(scmd)) { stu_scmd = scmd; break; } @@ -1645,6 +1740,130 @@ static int scsi_eh_stu(struct Scsi_Host *shost, return list_empty(work_q); } +static bool scsi_cmd_has_ua(const struct scsi_cmnd *scmd) +{ + struct scsi_sense_hdr sshdr; + + return scsi_cmd_current_sense(scmd, &sshdr) && + sshdr.sense_key == UNIT_ATTENTION; +} + +static bool scsi_eh_send_tur_clear_ua(struct scsi_cmnd *scmd) +{ + static unsigned char tur_command[6] = { TEST_UNIT_READY }; + struct Scsi_Host *shost = scmd->device->host; + u8 sense_buf[SCSI_SENSE_BUFFERSIZE]; + struct scsi_sense_hdr sshdr; + enum scsi_disposition rtn; + bool cleared = false; + int i; + + memcpy(sense_buf, scmd->sense_buffer, sizeof(sense_buf)); + + /* + * The first TEST UNIT READY command consumes the pending UNIT + * ATTENTION and the second TEST UNIT READY command verifies that the + * condition has been cleared. Allow additional attempts in case + * multiple UNIT ATTENTION conditions have been queued or in case the + * device is temporarily busy or becoming ready. + */ + for (i = 0; i < SCSI_EH_CLEAR_UA_TURS; i++) { + if (scsi_host_eh_past_deadline(shost)) + break; + rtn = scsi_send_eh_cmnd(scmd, tur_command, sizeof(tur_command), + scmd->device->eh_timeout, 0); + if (rtn == NEEDS_RETRY) { + if (i + 1 < SCSI_EH_CLEAR_UA_TURS) + msleep(SCSI_EH_CLEAR_UA_RETRY_DELAY_MS); + continue; + } + if (rtn != SUCCESS) + break; + if (!scsi_command_normalize_sense(scmd, &sshdr) || + sshdr.sense_key == NO_SENSE || + sshdr.sense_key == RECOVERED_ERROR) { + cleared = true; + break; + } + if (sshdr.sense_key != UNIT_ATTENTION) + break; + } + + memcpy(scmd->sense_buffer, sense_buf, sizeof(sense_buf)); + return cleared; +} + +/** + * scsi_eh_clear_ua - clear pending UNIT ATTENTION conditions if needed + * @shost: SCSI host being recovered. + * @work_q: &list_head for pending commands. + * @done_q: &list_head for processed commands. + * + * If commands fail repeatedly with UNIT ATTENTION because a target does not + * clear the condition for those commands (for example, WRITE), send + * TEST UNIT READY to clear the UNIT ATTENTION before escalating to a reset. + * + * Return: 1 if @work_q is empty, 0 otherwise. + */ +static int scsi_eh_clear_ua(struct Scsi_Host *shost, + struct list_head *work_q, + struct list_head *done_q) +{ + static DEFINE_RATELIMIT_STATE(rs, DEFAULT_RATELIMIT_INTERVAL, + DEFAULT_RATELIMIT_BURST); + struct scsi_cmnd *scmd, *ua_scmd, *next; + struct scsi_device *sdev; + + shost_for_each_device(sdev, shost) { + if (scsi_host_eh_past_deadline(shost)) { + SCSI_LOG_ERROR_RECOVERY(3, + sdev_printk(KERN_INFO, sdev, + "%s: skip clear UA, past eh deadline\n", + current->comm)); + scsi_device_put(sdev); + break; + } + + ua_scmd = NULL; + list_for_each_entry(scmd, work_q, eh_entry) { + if (scmd->device == sdev && scsi_cmd_has_ua(scmd)) { + ua_scmd = scmd; + break; + } + } + + if (!ua_scmd) + continue; + + SCSI_LOG_ERROR_RECOVERY(3, + sdev_printk(KERN_INFO, sdev, + "%s: Sending TEST_UNIT_READY to clear UA\n", + current->comm)); + + if (scsi_device_online(sdev)) { + if (!scsi_eh_send_tur_clear_ua(ua_scmd)) { + SCSI_LOG_ERROR_RECOVERY(3, + sdev_printk(KERN_INFO, sdev, + "%s: Failed to clear UA\n", + current->comm)); + continue; + } + if (__ratelimit(&rs)) + sdev_printk(KERN_INFO, sdev, + "Cleared persistent UNIT ATTENTION\n"); + } + + sdev->expecting_cc_ua = 0; + list_for_each_entry_safe(scmd, next, work_q, eh_entry) { + if (scmd->device == sdev && + scsi_cmd_has_ua(scmd) && + scsi_eh_action(scmd, SUCCESS) == SUCCESS) + scsi_eh_finish_cmd(scmd, done_q); + } + } + + return list_empty(work_q); +} /** * scsi_eh_bus_device_reset - send bdr if needed @@ -2115,7 +2334,7 @@ enum scsi_disposition scsi_decide_disposition(struct scsi_cmnd *scmd) case SAM_STAT_TASK_ABORTED: goto maybe_retry; case SAM_STAT_CHECK_CONDITION: - rtn = scsi_check_sense(scmd); + rtn = __scsi_check_sense(scmd, true); if (rtn == NEEDS_RETRY) goto maybe_retry; /* if rtn == FAILED, we have no sense information; @@ -2275,13 +2494,13 @@ void scsi_eh_ready_devs(struct Scsi_Host *shost, struct list_head *work_q, struct list_head *done_q) { - if (!scsi_eh_stu(shost, work_q, done_q)) - if (!scsi_eh_bus_device_reset(shost, work_q, done_q)) - if (!scsi_eh_target_reset(shost, work_q, done_q)) - if (!scsi_eh_bus_reset(shost, work_q, done_q)) - if (!scsi_eh_host_reset(shost, work_q, done_q)) - scsi_eh_offline_sdevs(work_q, - done_q); + if (!scsi_eh_stu(shost, work_q, done_q) && + !scsi_eh_clear_ua(shost, work_q, done_q) && + !scsi_eh_bus_device_reset(shost, work_q, done_q) && + !scsi_eh_target_reset(shost, work_q, done_q) && + !scsi_eh_bus_reset(shost, work_q, done_q) && + !scsi_eh_host_reset(shost, work_q, done_q)) + scsi_eh_offline_sdevs(work_q, done_q); } EXPORT_SYMBOL_GPL(scsi_eh_ready_devs); diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c index ab39514cc0c6..1a4781e461ac 100644 --- a/drivers/scsi/scsi_lib.c +++ b/drivers/scsi/scsi_lib.c @@ -849,6 +849,9 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result) */ cmd->device->changed = 1; action = ACTION_FAIL; + } else if (cmd->allowed != SCSI_CMD_RETRIES_NO_LIMIT && + cmd->retries > max(cmd->allowed, 3)) { + action = ACTION_FAIL; } else { /* Must have been a power glitch, or a * bus reset. Could not have been a @@ -1272,6 +1275,8 @@ static void scsi_initialize_rq(struct request *rq) init_rcu_head(&cmd->rcu); cmd->jiffies_at_alloc = jiffies; cmd->retries = 0; + cmd->ua_asc = 0; + cmd->ua_count = 0; } /** @@ -3079,6 +3084,15 @@ int scsi_internal_device_unblock_nowait(struct scsi_device *sdev, else sdev->sdev_state = SDEV_CREATED; break; + case SDEV_RUNNING: + /* + * The device was set running through sysfs while it was + * blocked, so its queue is still stopped. Finish the unblock. + */ + if (!sdev->queue_stopped) + return -EINVAL; + sdev->sdev_state = new_state; + break; case SDEV_CANCEL: case SDEV_OFFLINE: break; @@ -3595,6 +3609,58 @@ int scsi_vpd_tpg_id(struct scsi_device *sdev, int *rel_id) } EXPORT_SYMBOL(scsi_vpd_tpg_id); +/** + * scsi_report_tpgs - Issue a REPORT TARGET PORT GROUPS command + * @sdev: SCSI device to send the command to + * @buff: buffer for the parameter data, replaced if it is too small + * @bufflen: length of @buff + * @ext_hdr: request the extended header parameter data format + * @timeout: command timeout in jiffies + * @retries: number of times to retry the command in the midlayer + * @args: optional arguments for scsi_execute_cmd() + * + * Resend the command with a larger buffer if the parameter data does not + * fit. + * + * Return: the result of the last command, or -ENOMEM with *@buff set to + * NULL if a larger buffer could not be allocated. + */ +int scsi_report_tpgs(struct scsi_device *sdev, unsigned char **buff, + int *bufflen, bool ext_hdr, int timeout, int retries, + const struct scsi_exec_args *args) +{ + blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV | + REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER; + u8 cdb[MAX_COMMAND_SIZE] = { }; + int ret, len; + + cdb[0] = MAINTENANCE_IN; + cdb[1] = MI_REPORT_TARGET_PGS; + if (ext_hdr) + cdb[1] |= MI_EXT_HDR_PARAM_FMT; + + retry: + put_unaligned_be32(*bufflen, &cdb[6]); + ret = scsi_execute_cmd(sdev, cdb, opf, *buff, *bufflen, timeout, + retries, args); + if (ret) + return ret; + + len = get_unaligned_be32(&(*buff)[0]) + 4; + if (len > *bufflen) { + /* Resubmit with the correct length */ + kfree(*buff); + *bufflen = len; + *buff = kmalloc(len, GFP_KERNEL); + if (!*buff) + return -ENOMEM; + goto retry; + } + + return 0; +} +EXPORT_SYMBOL_GPL(scsi_report_tpgs); + /** * scsi_set_sense - build sense data for a command * @scmd: scsi command for which the sense should be formatted diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c index 8aae12fd38f3..b78b257b4b24 100644 --- a/drivers/scsi/scsi_scan.c +++ b/drivers/scsi/scsi_scan.c @@ -861,6 +861,98 @@ static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result, return 0; } +/** + * scsi_read_access_state - Read the ALUA state of a device + * @sdev: SCSI device that supports target port groups + * + * Send REPORT TARGET PORT GROUPS and set sdev->access_state to the + * asymmetric access state that the device reports for the target port + * group of this path, as identified in VPD page 0x83. If the command + * fails, e.g. with LOGICAL UNIT NOT SUPPORTED because no LU is mapped at + * this LUN for this I_T nexus, sdev->access_state is left unchanged. The + * ALUA device handler, if attached, keeps the state up to date later. + * + * Returns true if the state was read. + */ +static bool scsi_read_access_state(struct scsi_device *sdev) +{ + /* + * Each UNIT ATTENTION reports a different condition queued for this + * I_T nexus, e.g. a power on or reset after login followed by ALUA + * state and INQUIRY data changes, so retry until the target answers + * the command itself. + */ + struct scsi_failure failure_defs[] = { + { + .sense_key = UNIT_ATTENTION, + .sense_code = SCMD_FAILURE_SENSE_CODE_ANY, + .allowed = 5, + .result = SAM_STAT_CHECK_CONDITION, + }, + {} + }; + struct scsi_failures failures = { + .failure_definitions = failure_defs, + }; + struct scsi_sense_hdr sshdr; + const struct scsi_exec_args exec_args = { + .sshdr = &sshdr, + .failures = &failures, + }; + /* scsi_report_tpgs() replaces the buffer if this is too small */ + int bufflen = 128; + int group_id, len, k, off; + unsigned char *buff, *desc; + bool ext_hdr = true; + bool found = false; + int ret; + + group_id = scsi_vpd_tpg_id(sdev, NULL); + if (group_id < 0) + return false; + + buff = kzalloc(bufflen, GFP_KERNEL); + if (!buff) + return false; + + retry: + ret = scsi_report_tpgs(sdev, &buff, &bufflen, ext_hdr, + HZ / 2 + HZ * scsi_inq_timeout, 3, &exec_args); + if (ret) { + /* + * Some targets reject the extended header format with + * ILLEGAL REQUEST (see alua_rtpg()), so retry without it, + * unless the reason is that no LU is mapped at this LUN. + */ + if (ret > 0 && ext_hdr && scsi_sense_valid(&sshdr) && + sshdr.sense_key == ILLEGAL_REQUEST && + sshdr.sense_code != LU_NOT_SUPPORTED) { + ext_hdr = false; + goto retry; + } + goto out; + } + + len = get_unaligned_be32(&buff[0]) + 4; + if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR) + k = 8; + else + k = 4; + + for (desc = buff + k; k + 8 <= len; k += off, desc += off) { + off = 8 + (desc[7] * 4); + if (get_unaligned_be16(&desc[2]) == group_id) { + sdev->access_state = desc[0]; + found = true; + break; + } + } + + out: + kfree(buff); + return found; +} + /** * scsi_add_lun - allocate and fully initialize a scsi_device * @sdev: holds information to be stored in the new scsi_device @@ -1126,6 +1218,24 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result, scsi_cdl_check(sdev); + /* + * Read the ALUA state before the device is registered, so that + * scsi_bus_match() can use it. This needs VPD page 0x83. + */ + if (scsi_device_tpgs(sdev)) { + bool read = scsi_read_access_state(sdev); + + /* + * SPC-4 requires PQ 001b in the ALUA unavailable state, and + * an unmapped LUN fails the command, so take this to be a + * mapped LU that is unavailable. Decide once, like the + * peripheral qualifier itself: access_state changes when the + * ALUA state does. + */ + sdev->match_unavailable = + read && sdev->inq_periph_qual == SCSI_INQ_PQ_NOT_CON; + } + sdev->max_queue_depth = sdev->queue_depth; WARN_ON_ONCE(sdev->max_queue_depth > sdev->budget_map.depth); diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c index fe54792ed69e..4866b5f35aed 100644 --- a/drivers/scsi/scsi_sysfs.c +++ b/drivers/scsi/scsi_sysfs.c @@ -539,7 +539,19 @@ static int scsi_bus_match(struct device *dev, const struct device_driver *gendrv sdp = to_scsi_device(dev); if (sdp->no_uld_attach) return 0; - return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0; + if (sdp->inq_periph_qual == SCSI_INQ_PQ_CON) + return 1; + /* + * Peripheral qualifier 001b is also what a LU reports while it is in + * the ALUA unavailable state on this target port (SPC-4 5.15.2.4.5). + * scsi_add_lun() reads that state with REPORT TARGET PORT GROUPS + * before the device is registered and records whether to match it. + * A LUN that is not mapped reports 001b too, but fails REPORT TARGET + * PORT GROUPS and so is not matched. The decision is not made from + * access_state here, as that changes with the ALUA state while the + * peripheral qualifier does not. + */ + return sdp->match_unavailable; } static int scsi_bus_uevent(const struct device *dev, struct kobj_uevent_env *env) diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c index bec6ca38375b..a935e0c723c2 100644 --- a/drivers/scsi/scsi_transport_fc.c +++ b/drivers/scsi/scsi_transport_fc.c @@ -905,6 +905,9 @@ fc_host_fpin_rcv(struct Scsi_Host *shost, u32 fpin_len, char *fpin_buf, enum fc_host_event_code event_code = event_acknowledge ? FCH_EVT_LINK_FPIN_ACK : FCH_EVT_LINK_FPIN; + if (fpin_len < offsetof(struct fc_els_fpin, fpin_desc)) + return; + /* Update Statistics */ tlv = (struct fc_tlv_desc *)&fpin->fpin_desc[0]; bytes_remain = fpin_len - offsetof(struct fc_els_fpin, fpin_desc); diff --git a/drivers/scsi/sd_trace.h b/drivers/scsi/sd_trace.h deleted file mode 100644 index cba3c0b825ba..000000000000 --- a/drivers/scsi/sd_trace.h +++ /dev/null @@ -1,84 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -/* - * Copyright (C) 2022 Western Digital Corporation or its affiliates. - */ -#undef TRACE_SYSTEM -#define TRACE_SYSTEM sd - -#undef TRACE_INCLUDE_FILE -#define TRACE_INCLUDE_FILE sd_trace - -#if !defined(_SD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) -#include -#include -#include - -TRACE_EVENT(scsi_prepare_zone_append, - - TP_PROTO(struct scsi_cmnd *cmnd, sector_t lba, - unsigned int wp_offset), - - TP_ARGS(cmnd, lba, wp_offset), - - TP_STRUCT__entry( - __field( unsigned int, host_no ) - __field( unsigned int, channel ) - __field( unsigned int, id ) - __field( unsigned int, lun ) - __field( sector_t, lba ) - __field( unsigned int, wp_offset ) - ), - - TP_fast_assign( - __entry->host_no = cmnd->device->host->host_no; - __entry->channel = cmnd->device->channel; - __entry->id = cmnd->device->id; - __entry->lun = cmnd->device->lun; - __entry->lba = lba; - __entry->wp_offset = wp_offset; - ), - - TP_printk("host_no=%u, channel=%u id=%u lun=%u lba=%llu wp_offset=%u", - __entry->host_no, __entry->channel, __entry->id, - __entry->lun, __entry->lba, __entry->wp_offset) -); - -TRACE_EVENT(scsi_zone_wp_update, - - TP_PROTO(struct scsi_cmnd *cmnd, sector_t rq_sector, - unsigned int wp_offset, unsigned int good_bytes), - - TP_ARGS(cmnd, rq_sector, wp_offset, good_bytes), - - TP_STRUCT__entry( - __field( unsigned int, host_no ) - __field( unsigned int, channel ) - __field( unsigned int, id ) - __field( unsigned int, lun ) - __field( sector_t, rq_sector ) - __field( unsigned int, wp_offset ) - __field( unsigned int, good_bytes ) - ), - - TP_fast_assign( - __entry->host_no = cmnd->device->host->host_no; - __entry->channel = cmnd->device->channel; - __entry->id = cmnd->device->id; - __entry->lun = cmnd->device->lun; - __entry->rq_sector = rq_sector; - __entry->wp_offset = wp_offset; - __entry->good_bytes = good_bytes; - ), - - TP_printk("host_no=%u, channel=%u id=%u lun=%u rq_sector=%llu" \ - " wp_offset=%u good_bytes=%u", - __entry->host_no, __entry->channel, __entry->id, - __entry->lun, __entry->rq_sector, __entry->wp_offset, - __entry->good_bytes) -); -#endif /* _SD_TRACE_H */ - -/* This part must be outside protection */ -#undef TRACE_INCLUDE_PATH -#define TRACE_INCLUDE_PATH ../../drivers/scsi -#include diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c index 8cbf171e6fab..0f95ed2e0dc5 100644 --- a/drivers/scsi/sd_zbc.c +++ b/drivers/scsi/sd_zbc.c @@ -20,9 +20,6 @@ #include "sd.h" -#define CREATE_TRACE_POINTS -#include "sd_trace.h" - /* Whether or not a SCSI zone descriptor describes a gap zone. */ static bool sd_zbc_is_gap_zone(const u8 buf[64]) { diff --git a/drivers/scsi/vmw_pvscsi.c b/drivers/scsi/vmw_pvscsi.c index 151cac9f9c2a..3271045a7b3d 100644 --- a/drivers/scsi/vmw_pvscsi.c +++ b/drivers/scsi/vmw_pvscsi.c @@ -201,6 +201,9 @@ static u64 pvscsi_map_context(const struct pvscsi_adapter *adapter, static struct pvscsi_ctx * pvscsi_get_context(const struct pvscsi_adapter *adapter, u64 context) { + if (unlikely(context == 0 || context > adapter->req_depth)) + return NULL; + return &adapter->cmd_map[context - 1]; } @@ -548,8 +551,15 @@ static void pvscsi_complete_request(struct pvscsi_adapter *adapter, struct completion *abort_cmp; u32 btstat = e->hostStatus; u32 sdstat = e->scsiStatus; + u64 data_len = e->dataLen; + u32 data_trans = 0; ctx = pvscsi_get_context(adapter, e->context); + if (ctx == NULL || ctx->cmd == NULL) { + dev_err_ratelimited(&adapter->dev->dev, + "Can not find mapping for context %llu", e->context); + return; + } cmd = ctx->cmd; abort_cmp = ctx->abort_cmp; pvscsi_unmap_buffers(adapter, ctx); @@ -590,15 +600,16 @@ static void pvscsi_complete_request(struct pvscsi_adapter *adapter, * returns zero dataLen with non zero data - do not set * residual count in that case. */ - if (e->dataLen && (e->dataLen < scsi_bufflen(cmd))) - scsi_set_resid(cmd, scsi_bufflen(cmd) - e->dataLen); + if (data_len && (data_len < scsi_bufflen(cmd))) + scsi_set_resid(cmd, scsi_bufflen(cmd) - data_len); cmd->result = (DID_OK << 16); break; case BTSTAT_DATARUN: case BTSTAT_DATA_UNDERRUN: /* Report residual data in underruns */ - scsi_set_resid(cmd, scsi_bufflen(cmd) - e->dataLen); + data_trans = min_t(u64, data_len, scsi_bufflen(cmd)); + scsi_set_resid(cmd, scsi_bufflen(cmd) - data_trans); cmd->result = (DID_ERROR << 16); break; @@ -650,12 +661,18 @@ static void pvscsi_complete_request(struct pvscsi_adapter *adapter, } /* - * barrier usage : Since the PVSCSI device is emulated, there could be cases - * where we may want to serialize some accesses between the driver and the - * emulation layer. We use compiler barriers instead of the more expensive - * memory barriers because PVSCSI is only supported on X86 which has strong - * memory access ordering. + * The completion consumer index must be incremented only after the completion + * entry is read. The read memory barrier combined with READ/WRITE_ONCE + * ensures that all reads from the entry happen before the increment. */ +static void pvscsi_increment_cons_idx(u32 *cons_idx) +{ + u32 new_cons_idx; + dma_rmb(); + new_cons_idx = READ_ONCE(*cons_idx) + 1; + WRITE_ONCE(*cons_idx, new_cons_idx); +} + static void pvscsi_process_completion_ring(struct pvscsi_adapter *adapter) { struct PVSCSIRingsState *s = adapter->rings_state; @@ -666,21 +683,14 @@ static void pvscsi_process_completion_ring(struct pvscsi_adapter *adapter) struct PVSCSIRingCmpDesc *e = ring + (s->cmpConsIdx & MASK(cmp_entries)); /* - * This barrier() ensures that *e is not dereferenced while + * This barrier ensures that *e is not dereferenced while * the device emulation still writes data into the slot. * Since the device emulation advances s->cmpProdIdx only after * updating the slot we want to check it first. */ - barrier(); + dma_rmb(); pvscsi_complete_request(adapter, e); - /* - * This barrier() ensures that compiler doesn't reorder write - * to s->cmpConsIdx before the read of (*e) inside - * pvscsi_complete_request. Otherwise, device emulation may - * overwrite *e before we had a chance to read it. - */ - barrier(); - s->cmpConsIdx++; + pvscsi_increment_cons_idx(&s->cmpConsIdx); } } @@ -764,7 +774,11 @@ static int pvscsi_queue_ring(struct pvscsi_adapter *adapter, e->context = pvscsi_map_context(adapter, ctx); - barrier(); + /* + * Ensure writes to the request entry are done before + * transferring ownership. + */ + dma_wmb(); s->reqProdIdx++; @@ -1105,10 +1119,9 @@ static void pvscsi_process_msg_ring(const struct pvscsi_adapter *adapter) struct PVSCSIRingMsgDesc *e = ring + (s->msgConsIdx & MASK(msg_entries)); - barrier(); + dma_rmb(); pvscsi_process_msg(adapter, e); - barrier(); - s->msgConsIdx++; + pvscsi_increment_cons_idx(&s->msgConsIdx); } } diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c index ea65d39fef88..604fca959f2e 100644 --- a/drivers/target/target_core_iblock.c +++ b/drivers/target/target_core_iblock.c @@ -461,8 +461,6 @@ iblock_execute_zero_out(struct block_device *bdev, struct se_cmd *cmd) int ret; buf = kmap(sg_page(sg)) + sg->offset; - if (!buf) - return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; /* * Fall back to block_execute_write_same() slow-path if * incoming WRITE_SAME payload does not contain zeros. diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c index 927861c30afc..9819515ce967 100644 --- a/drivers/target/target_core_transport.c +++ b/drivers/target/target_core_transport.c @@ -1646,10 +1646,8 @@ static int __target_submit(struct se_cmd *cmd) BUG_ON(!sgl); buf = kmap_local_page(sg_page(sgl)); - if (buf) { - memset(buf + sgl->offset, 0, sgl->length); - kunmap_local(buf); - } + memset(buf + sgl->offset, 0, sgl->length); + kunmap_local(buf); } } diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h index 2f2364c96457..5a8f7a45dc6d 100644 --- a/include/scsi/scsi_cmnd.h +++ b/include/scsi/scsi_cmnd.h @@ -98,6 +98,13 @@ struct scsi_cmnd { enum scsi_cmnd_submitter submitter; unsigned short cmd_len; + /* + * Additional sense code of the most recent UNIT ATTENTION and the + * number of consecutive UNIT ATTENTIONs with that additional sense + * code. Only used by the SCSI core. + */ + u8 ua_asc; + u8 ua_count; enum dma_data_direction sc_data_direction; unsigned char cmnd[32]; /* SCSI CDB */ diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h index e6fd6bc30644..b9540a412ae8 100644 --- a/include/scsi/scsi_device.h +++ b/include/scsi/scsi_device.h @@ -196,6 +196,12 @@ struct scsi_device { */ unsigned is_ata:1; + /* + * Set if a ULD should be matched to a PQ 001b device in the ALUA + * unavailable state. + */ + unsigned match_unavailable:1; + unsigned removable:1; unsigned changed:1; /* Data invalid due to media change */ unsigned busy:1; /* Used to prevent races */ @@ -583,6 +589,9 @@ extern void sdev_enable_disk_events(struct scsi_device *sdev); extern int scsi_vpd_lun_id(struct scsi_device *, char *, size_t); extern int scsi_vpd_lun_serial(struct scsi_device *, char *, size_t); extern int scsi_vpd_tpg_id(struct scsi_device *, int *); +int scsi_report_tpgs(struct scsi_device *sdev, unsigned char **buff, + int *bufflen, bool ext_hdr, int timeout, int retries, + const struct scsi_exec_args *args); #ifdef CONFIG_PM extern int scsi_autopm_get_device(struct scsi_device *); diff --git a/include/scsi/scsi_proto.h b/include/scsi/scsi_proto.h index 9c7d31aa6bae..6826f2d74407 100644 --- a/include/scsi/scsi_proto.h +++ b/include/scsi/scsi_proto.h @@ -145,6 +145,9 @@ #define MI_MANAGEMENT_PROTOCOL_IN 0x10 /* value for MI_REPORT_TARGET_PGS ext header */ #define MI_EXT_HDR_PARAM_FMT 0x20 +/* format field in byte 4 of the REPORT TARGET PORT GROUPS parameter data */ +#define RTPG_FMT_MASK 0x70 +#define RTPG_FMT_EXT_HDR 0x10 /* values for maintenance out */ #define MO_SET_IDENTIFYING_INFORMATION 0x06 #define MO_SET_TARGET_PGS 0x0a