Lines Matching refs:cmd
83 scsi_set_blocked(struct scsi_cmnd *cmd, int reason)
85 struct Scsi_Host *host = cmd->device->host;
86 struct scsi_device *device = cmd->device;
118 static void scsi_mq_requeue_cmd(struct scsi_cmnd *cmd)
120 struct scsi_device *sdev = cmd->device;
121 struct request_queue *q = cmd->request->q;
123 blk_mq_requeue_request(cmd->request);
130 * @cmd: The SCSI command being requeued
140 static void __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy)
142 struct scsi_device *device = cmd->device;
146 SCSI_LOG_MLQUEUE(1, scmd_printk(KERN_INFO, cmd,
147 "Inserting command %p into mlqueue\n", cmd));
149 scsi_set_blocked(cmd, reason);
164 cmd->result = 0;
166 scsi_mq_requeue_cmd(cmd);
170 blk_requeue_request(q, cmd->request);
180 * Arguments: cmd - command that we are adding to queue.
194 void scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
196 __scsi_queue_insert(cmd, reason, 1);
201 * @cmd: scsi command
214 int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
232 req->cmd_len = COMMAND_SIZE(cmd[0]);
233 memcpy(req->cmd, cmd, req->cmd_len);
264 int scsi_execute_req_flags(struct scsi_device *sdev, const unsigned char *cmd,
277 result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen,
290 * Purpose: Initialize cmd fields related to error handling.
292 * Arguments: cmd - command that is ready to be queued.
298 static void scsi_init_cmd_errh(struct scsi_cmnd *cmd)
300 cmd->serial_number = 0;
301 scsi_set_resid(cmd, 0);
302 memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
303 if (cmd->cmd_len == 0)
304 cmd->cmd_len = scsi_command_size(cmd->cmnd);
515 * cmd - command that may need to be requeued.
525 * Notes: Upon return, cmd is a stale pointer.
527 static void scsi_requeue_command(struct request_queue *q, struct scsi_cmnd *cmd)
529 struct scsi_device *sdev = cmd->device;
530 struct request *req = cmd->request;
536 scsi_put_command(cmd);
545 void scsi_next_command(struct scsi_cmnd *cmd)
547 struct scsi_device *sdev = cmd->device;
550 scsi_put_command(cmd);
625 static void scsi_uninit_cmd(struct scsi_cmnd *cmd)
627 if (cmd->request->cmd_type == REQ_TYPE_FS) {
628 struct scsi_driver *drv = scsi_cmd_to_driver(cmd);
631 drv->uninit_command(cmd);
635 static void scsi_mq_free_sgtables(struct scsi_cmnd *cmd)
637 if (cmd->sdb.table.nents)
638 scsi_free_sgtable(&cmd->sdb, true);
639 if (cmd->request->next_rq && cmd->request->next_rq->special)
640 scsi_free_sgtable(cmd->request->next_rq->special, true);
641 if (scsi_prot_sg_count(cmd))
642 scsi_free_sgtable(cmd->prot_sdb, true);
645 static void scsi_mq_uninit_cmd(struct scsi_cmnd *cmd)
647 struct scsi_device *sdev = cmd->device;
651 scsi_mq_free_sgtables(cmd);
652 scsi_uninit_cmd(cmd);
655 BUG_ON(list_empty(&cmd->list));
657 list_del_init(&cmd->list);
667 * Arguments: cmd - command that we are bailing.
678 static void scsi_release_buffers(struct scsi_cmnd *cmd)
680 if (cmd->sdb.table.nents)
681 scsi_free_sgtable(&cmd->sdb, false);
683 memset(&cmd->sdb, 0, sizeof(cmd->sdb));
685 if (scsi_prot_sg_count(cmd))
686 scsi_free_sgtable(cmd->prot_sdb, false);
689 static void scsi_release_bidi_buffers(struct scsi_cmnd *cmd)
691 struct scsi_data_buffer *bidi_sdb = cmd->request->next_rq->special;
695 cmd->request->next_rq->special = NULL;
701 struct scsi_cmnd *cmd = req->special;
702 struct scsi_device *sdev = cmd->device;
724 scsi_mq_uninit_cmd(cmd);
739 scsi_release_bidi_buffers(cmd);
745 scsi_release_buffers(cmd);
746 scsi_next_command(cmd);
754 * @cmd: SCSI command (unused)
766 static int __scsi_error_from_host_byte(struct scsi_cmnd *cmd, int result)
775 set_host_byte(cmd, DID_OK);
779 set_host_byte(cmd, DID_OK);
783 set_host_byte(cmd, DID_OK);
787 set_host_byte(cmd, DID_OK);
803 * Arguments: cmd - command that is finished.
827 void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
829 int result = cmd->result;
830 struct request_queue *q = cmd->device->request_queue;
831 struct request *req = cmd->request;
838 unsigned long wait_for = (cmd->allowed + 1) * req->timeout;
841 sense_valid = scsi_command_normalize_sense(cmd, &sshdr);
852 int len = 8 + cmd->sense_buffer[7];
856 memcpy(req->sense, cmd->sense_buffer, len);
860 error = __scsi_error_from_host_byte(cmd, result);
865 req->errors = cmd->result;
867 req->resid_len = scsi_get_resid(cmd);
869 if (scsi_bidi_cmnd(cmd)) {
874 req->next_rq->resid_len = scsi_in(cmd)->resid;
887 error = __scsi_error_from_host_byte(cmd, result);
897 SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, cmd,
915 scsi_print_sense("", cmd);
930 if (error && scsi_noretry_cmd(cmd)) {
943 error = __scsi_error_from_host_byte(cmd, result);
954 if (cmd->device->removable) {
958 cmd->device->changed = 1;
978 if ((cmd->device->use_10_for_rw &&
980 (cmd->cmnd[0] == READ_10 ||
981 cmd->cmnd[0] == WRITE_10)) {
983 cmd->device->use_10_for_rw = 0;
1035 time_before(cmd->jiffies_at_alloc + wait_for, jiffies))
1042 scsi_print_result(cmd);
1044 scsi_print_sense("", cmd);
1045 scsi_print_command(cmd);
1056 cmd->request->cmd_flags &= ~REQ_DONTPREP;
1057 scsi_mq_uninit_cmd(cmd);
1058 scsi_mq_requeue_cmd(cmd);
1060 scsi_release_buffers(cmd);
1061 scsi_requeue_command(q, cmd);
1066 __scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, 0);
1070 __scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, 0);
1103 * Arguments: cmd - Command descriptor we wish to initialize
1109 int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
1111 struct scsi_device *sdev = cmd->device;
1112 struct request *rq = cmd->request;
1118 error = scsi_init_sgtable(rq, &cmd->sdb, gfp_mask);
1141 struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;
1157 cmd->prot_sdb = prot_sdb;
1158 cmd->prot_sdb->table.nents = count;
1164 scsi_mq_free_sgtables(cmd);
1166 scsi_release_buffers(cmd);
1167 cmd->request->special = NULL;
1168 scsi_put_command(cmd);
1178 struct scsi_cmnd *cmd;
1185 cmd = scsi_get_command(sdev, GFP_ATOMIC);
1186 if (unlikely(!cmd)) {
1190 req->special = cmd;
1192 cmd = req->special;
1196 cmd->tag = req->tag;
1197 cmd->request = req;
1199 cmd->cmnd = req->cmd;
1200 cmd->prot_op = SCSI_PROT_NORMAL;
1202 return cmd;
1207 struct scsi_cmnd *cmd = req->special;
1216 int ret = scsi_init_io(cmd, GFP_ATOMIC);
1222 memset(&cmd->sdb, 0, sizeof(cmd->sdb));
1225 cmd->cmd_len = req->cmd_len;
1226 cmd->transfersize = blk_rq_bytes(req);
1227 cmd->allowed = req->retries;
1237 struct scsi_cmnd *cmd = req->special;
1246 memset(cmd->cmnd, 0, BLK_MAX_CDB);
1247 return scsi_cmd_to_driver(cmd)->init_command(cmd);
1252 struct scsi_cmnd *cmd = req->special;
1255 cmd->sc_data_direction = DMA_NONE;
1257 cmd->sc_data_direction = DMA_TO_DEVICE;
1259 cmd->sc_data_direction = DMA_FROM_DEVICE;
1335 struct scsi_cmnd *cmd = req->special;
1336 scsi_release_buffers(cmd);
1337 scsi_put_command(cmd);
1361 struct scsi_cmnd *cmd;
1368 cmd = scsi_get_cmd_from_req(sdev, req);
1369 if (unlikely(!cmd)) {
1572 struct scsi_cmnd *cmd = req->special;
1579 scmd_printk(KERN_INFO, cmd, "killing request\n");
1581 sdev = cmd->device;
1584 scsi_init_cmd_errh(cmd);
1585 cmd->result = DID_NO_CONNECT << 16;
1586 atomic_inc(&cmd->device->iorequest_cnt);
1603 struct scsi_cmnd *cmd = rq->special;
1604 unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;
1607 INIT_LIST_HEAD(&cmd->eh_entry);
1609 atomic_inc(&cmd->device->iodone_cnt);
1610 if (cmd->result)
1611 atomic_inc(&cmd->device->ioerr_cnt);
1613 disposition = scsi_decide_disposition(cmd);
1615 time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
1616 sdev_printk(KERN_ERR, cmd->device,
1622 scsi_log_completion(cmd, disposition);
1626 scsi_finish_command(cmd);
1629 scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
1632 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
1635 if (!scsi_eh_scmd_add(cmd, 0))
1636 scsi_finish_command(cmd);
1642 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
1651 static void scsi_done(struct scsi_cmnd *cmd)
1653 trace_scsi_dispatch_cmd_done(cmd);
1654 blk_complete_request(cmd->request);
1674 struct scsi_cmnd *cmd;
1710 cmd = req->special;
1711 if (unlikely(cmd == NULL)) {
1747 scsi_init_cmd_errh(cmd);
1752 cmd->scsi_done = scsi_done;
1753 rtn = scsi_dispatch_cmd(cmd);
1755 scsi_queue_insert(cmd, rtn);
1798 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
1801 unsigned char *sense_buf = cmd->sense_buffer;
1804 memset(cmd, 0, sizeof(struct scsi_cmnd));
1806 req->special = cmd;
1808 cmd->request = req;
1809 cmd->device = sdev;
1810 cmd->sense_buffer = sense_buf;
1812 cmd->tag = req->tag;
1814 cmd->cmnd = req->cmd;
1815 cmd->prot_op = SCSI_PROT_NORMAL;
1817 INIT_LIST_HEAD(&cmd->list);
1818 INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
1819 cmd->jiffies_at_alloc = jiffies;
1823 list_add_tail(&cmd->list, &sdev->cmd_list);
1827 sg = (void *)cmd + sizeof(struct scsi_cmnd) + shost->hostt->cmd_size;
1828 cmd->sdb.table.sgl = sg;
1831 cmd->prot_sdb = (void *)sg +
1833 memset(cmd->prot_sdb, 0, sizeof(struct scsi_data_buffer));
1835 cmd->prot_sdb->table.sgl =
1836 (struct scatterlist *)(cmd->prot_sdb + 1);
1855 static void scsi_mq_done(struct scsi_cmnd *cmd)
1857 trace_scsi_dispatch_cmd_done(cmd);
1858 blk_mq_complete_request(cmd->request);
1867 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
1901 scsi_init_cmd_errh(cmd);
1902 cmd->scsi_done = scsi_mq_done;
1904 reason = scsi_dispatch_cmd(cmd);
1906 scsi_set_blocked(cmd, reason);
1937 scsi_mq_uninit_cmd(cmd);
1957 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
1959 cmd->sense_buffer = kzalloc_node(SCSI_SENSE_BUFFERSIZE, GFP_KERNEL,
1961 if (!cmd->sense_buffer)
1969 struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
1971 kfree(cmd->sense_buffer);
2242 unsigned char cmd[10];
2246 memset(cmd, 0, sizeof(cmd));
2247 cmd[1] = (pf ? 0x10 : 0) | (sp ? 0x01 : 0);
2266 cmd[0] = MODE_SELECT_10;
2267 cmd[7] = len >> 8;
2268 cmd[8] = len;
2285 cmd[0] = MODE_SELECT;
2286 cmd[4] = len;
2289 ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len,
2318 unsigned char cmd[12];
2325 memset(&cmd[0], 0, 12);
2326 cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */
2327 cmd[2] = modepage;
2340 cmd[0] = MODE_SENSE_10;
2341 cmd[8] = len;
2347 cmd[0] = MODE_SENSE;
2348 cmd[4] = len;
2354 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
2422 char cmd[] = {
2435 result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, sshdr,