Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

scsi: remove MSG_*_TAG defines

Browse source 
For SPI drivers use the message definitions from scsi.h, and for target
drivers introduce a new TCM_*_TAG namespace.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com
This commit is contained in:
Christoph Hellwig 2014-11-24 07:07:25 -08:00 committed by Christoph Hellwig
parent 4e484896ac
commit 68d81f4004
18 changed files with 58 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
drivers/infiniband/ulp/srpt/ib_srpt.c
View file

@ -1708,17 +1708,17 @@ static int srpt_handle_cmd(struct srpt_rdma_ch *ch,
switch (srp_cmd->task_attr) { switch (srp_cmd->task_attr) {
case SRP_CMD_SIMPLE_Q: case SRP_CMD_SIMPLE_Q:
cmd->sam_task_attr = MSG_SIMPLE_TAG; cmd->sam_task_attr = TCM_SIMPLE_TAG;
break; break;
case SRP_CMD_ORDERED_Q: case SRP_CMD_ORDERED_Q:
default: default:
cmd->sam_task_attr = MSG_ORDERED_TAG; cmd->sam_task_attr = TCM_ORDERED_TAG;
break; break;
case SRP_CMD_HEAD_OF_Q: case SRP_CMD_HEAD_OF_Q:
cmd->sam_task_attr = MSG_HEAD_TAG; cmd->sam_task_attr = TCM_HEAD_TAG;
break; break;
case SRP_CMD_ACA: case SRP_CMD_ACA:
cmd->sam_task_attr = MSG_ACA_TAG; cmd->sam_task_attr = TCM_ACA_TAG;
break; break;
} }
@ -1733,7 +1733,7 @@ static int srpt_handle_cmd(struct srpt_rdma_ch *ch,
sizeof(srp_cmd->lun)); sizeof(srp_cmd->lun));
rc = target_submit_cmd(cmd, ch->sess, srp_cmd->cdb, rc = target_submit_cmd(cmd, ch->sess, srp_cmd->cdb,
&send_ioctx->sense_data[0], unpacked_lun, data_len, &send_ioctx->sense_data[0], unpacked_lun, data_len,
MSG_SIMPLE_TAG, dir, TARGET_SCF_ACK_KREF); TCM_SIMPLE_TAG, dir, TARGET_SCF_ACK_KREF);
if (rc != 0) { if (rc != 0) {
ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
goto send_sense; goto send_sense;

8
drivers/scsi/advansys.c
View file

@ -7921,9 +7921,9 @@ static int asc_build_req(struct asc_board *boardp, struct scsi_cmnd *scp,
*/ */
if ((asc_dvc->cur_dvc_qng[scp->device->id] > 0) && if ((asc_dvc->cur_dvc_qng[scp->device->id] > 0) &&
(boardp->reqcnt[scp->device->id] % 255) == 0) { (boardp->reqcnt[scp->device->id] % 255) == 0) {
asc_scsi_q->q2.tag_code = MSG_ORDERED_TAG; asc_scsi_q->q2.tag_code = ORDERED_QUEUE_TAG;
} else { } else {
asc_scsi_q->q2.tag_code = MSG_SIMPLE_TAG; asc_scsi_q->q2.tag_code = SIMPLE_QUEUE_TAG;
} }
/* Build ASC_SCSI_Q */ /* Build ASC_SCSI_Q */
@ -8351,7 +8351,7 @@ static int AscPutReadyQueue(ASC_DVC_VAR *asc_dvc, ASC_SCSI_Q *scsiq, uchar q_no)
} }
q_addr = ASC_QNO_TO_QADDR(q_no); q_addr = ASC_QNO_TO_QADDR(q_no);
if ((scsiq->q1.target_id & asc_dvc->use_tagged_qng) == 0) { if ((scsiq->q1.target_id & asc_dvc->use_tagged_qng) == 0) {
scsiq->q2.tag_code &= ~MSG_SIMPLE_TAG; scsiq->q2.tag_code &= ~SIMPLE_QUEUE_TAG;
} }
scsiq->q1.status = QS_FREE; scsiq->q1.status = QS_FREE;
AscMemWordCopyPtrToLram(iop_base, AscMemWordCopyPtrToLram(iop_base,
@ -8669,7 +8669,7 @@ static int AscExeScsiQueue(ASC_DVC_VAR *asc_dvc, ASC_SCSI_Q *scsiq)
} }
} }
if (disable_syn_offset_one_fix) { if (disable_syn_offset_one_fix) {
scsiq->q2.tag_code &= ~MSG_SIMPLE_TAG; scsiq->q2.tag_code &= ~SIMPLE_QUEUE_TAG;
scsiq->q2.tag_code |= (ASC_TAG_FLAG_DISABLE_ASYN_USE_SYN_FIX | scsiq->q2.tag_code |= (ASC_TAG_FLAG_DISABLE_ASYN_USE_SYN_FIX |
ASC_TAG_FLAG_DISABLE_DISCONNECT); ASC_TAG_FLAG_DISABLE_DISCONNECT);
} else { } else {

12
drivers/scsi/qla2xxx/qla_target.c
View file

@ -3218,25 +3218,25 @@ static inline int qlt_get_fcp_task_attr(struct scsi_qla_host *vha,
switch (task_codes) { switch (task_codes) {
case ATIO_SIMPLE_QUEUE: case ATIO_SIMPLE_QUEUE:
fcp_task_attr = MSG_SIMPLE_TAG; fcp_task_attr = TCM_SIMPLE_TAG;
break; break;
case ATIO_HEAD_OF_QUEUE: case ATIO_HEAD_OF_QUEUE:
fcp_task_attr = MSG_HEAD_TAG; fcp_task_attr = TCM_HEAD_TAG;
break; break;
case ATIO_ORDERED_QUEUE: case ATIO_ORDERED_QUEUE:
fcp_task_attr = MSG_ORDERED_TAG; fcp_task_attr = TCM_ORDERED_TAG;
break; break;
case ATIO_ACA_QUEUE: case ATIO_ACA_QUEUE:
fcp_task_attr = MSG_ACA_TAG; fcp_task_attr = TCM_ACA_TAG;
break; break;
case ATIO_UNTAGGED: case ATIO_UNTAGGED:
fcp_task_attr = MSG_SIMPLE_TAG; fcp_task_attr = TCM_SIMPLE_TAG;
break; break;
default: default:
ql_dbg(ql_dbg_tgt_mgt, vha, 0xf05d, ql_dbg(ql_dbg_tgt_mgt, vha, 0xf05d,
"qla_target: unknown task code %x, use ORDERED instead\n", "qla_target: unknown task code %x, use ORDERED instead\n",
task_codes); task_codes);
fcp_task_attr = MSG_ORDERED_TAG; fcp_task_attr = TCM_ORDERED_TAG;
break; break;
} }

1
drivers/scsi/scsi_debug.c
View file

@ -128,7 +128,6 @@ static const char *scsi_debug_version_date = "20141022";
#define DEF_REMOVABLE false #define DEF_REMOVABLE false
#define DEF_SCSI_LEVEL 6 /* INQUIRY, byte2 [6->SPC-4] */ #define DEF_SCSI_LEVEL 6 /* INQUIRY, byte2 [6->SPC-4] */
#define DEF_SECTOR_SIZE 512 #define DEF_SECTOR_SIZE 512
#define DEF_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
#define DEF_UNMAP_ALIGNMENT 0 #define DEF_UNMAP_ALIGNMENT 0
#define DEF_UNMAP_GRANULARITY 1 #define DEF_UNMAP_GRANULARITY 1
#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF #define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF

2
drivers/scsi/scsi_transport_spi.c
View file

@ -1221,7 +1221,7 @@ EXPORT_SYMBOL_GPL(spi_populate_ppr_msg);
int spi_populate_tag_msg(unsigned char *msg, struct scsi_cmnd *cmd) int spi_populate_tag_msg(unsigned char *msg, struct scsi_cmnd *cmd)
{ {
if (cmd->flags & SCMD_TAGGED) { if (cmd->flags & SCMD_TAGGED) {
*msg++ = MSG_SIMPLE_TAG; *msg++ = SIMPLE_QUEUE_TAG;
*msg++ = cmd->request->tag; *msg++ = cmd->request->tag;
return 2; return 2;
} }

14
drivers/target/iscsi/iscsi_target.c
View file

@ -943,17 +943,17 @@ int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
*/ */
if ((iscsi_task_attr == ISCSI_ATTR_UNTAGGED) || if ((iscsi_task_attr == ISCSI_ATTR_UNTAGGED) ||
(iscsi_task_attr == ISCSI_ATTR_SIMPLE)) (iscsi_task_attr == ISCSI_ATTR_SIMPLE))
sam_task_attr = MSG_SIMPLE_TAG; sam_task_attr = TCM_SIMPLE_TAG;
else if (iscsi_task_attr == ISCSI_ATTR_ORDERED) else if (iscsi_task_attr == ISCSI_ATTR_ORDERED)
sam_task_attr = MSG_ORDERED_TAG; sam_task_attr = TCM_ORDERED_TAG;
else if (iscsi_task_attr == ISCSI_ATTR_HEAD_OF_QUEUE) else if (iscsi_task_attr == ISCSI_ATTR_HEAD_OF_QUEUE)
sam_task_attr = MSG_HEAD_TAG; sam_task_attr = TCM_HEAD_TAG;
else if (iscsi_task_attr == ISCSI_ATTR_ACA) else if (iscsi_task_attr == ISCSI_ATTR_ACA)
sam_task_attr = MSG_ACA_TAG; sam_task_attr = TCM_ACA_TAG;
else { else {
pr_debug("Unknown iSCSI Task Attribute: 0x%02x, using" pr_debug("Unknown iSCSI Task Attribute: 0x%02x, using"
" MSG_SIMPLE_TAG\n", iscsi_task_attr); " TCM_SIMPLE_TAG\n", iscsi_task_attr);
sam_task_attr = MSG_SIMPLE_TAG; sam_task_attr = TCM_SIMPLE_TAG;
} }
cmd->iscsi_opcode = ISCSI_OP_SCSI_CMD; cmd->iscsi_opcode = ISCSI_OP_SCSI_CMD;
@ -1811,7 +1811,7 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
transport_init_se_cmd(&cmd->se_cmd, transport_init_se_cmd(&cmd->se_cmd,
&lio_target_fabric_configfs->tf_ops, &lio_target_fabric_configfs->tf_ops,
conn->sess->se_sess, 0, DMA_NONE, conn->sess->se_sess, 0, DMA_NONE,
MSG_SIMPLE_TAG, cmd->sense_buffer + 2); TCM_SIMPLE_TAG, cmd->sense_buffer + 2);
target_get_sess_cmd(conn->sess->se_sess, &cmd->se_cmd, true); target_get_sess_cmd(conn->sess->se_sess, &cmd->se_cmd, true);
sess_ref = true; sess_ref = true;

4
drivers/target/loopback/tcm_loop.c
View file

@ -168,7 +168,7 @@ static void tcm_loop_submission_work(struct work_struct *work)
rc = target_submit_cmd_map_sgls(se_cmd, tl_nexus->se_sess, sc->cmnd, rc = target_submit_cmd_map_sgls(se_cmd, tl_nexus->se_sess, sc->cmnd,
&tl_cmd->tl_sense_buf[0], tl_cmd->sc->device->lun, &tl_cmd->tl_sense_buf[0], tl_cmd->sc->device->lun,
transfer_length, MSG_SIMPLE_TAG, transfer_length, TCM_SIMPLE_TAG,
sc->sc_data_direction, 0, sc->sc_data_direction, 0,
scsi_sglist(sc), scsi_sg_count(sc), scsi_sglist(sc), scsi_sg_count(sc),
sgl_bidi, sgl_bidi_count, sgl_bidi, sgl_bidi_count,
@ -248,7 +248,7 @@ static int tcm_loop_issue_tmr(struct tcm_loop_tpg *tl_tpg,
* Initialize struct se_cmd descriptor from target_core_mod infrastructure * Initialize struct se_cmd descriptor from target_core_mod infrastructure
*/ */
transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 0, transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 0,
DMA_NONE, MSG_SIMPLE_TAG, DMA_NONE, TCM_SIMPLE_TAG,
&tl_cmd->tl_sense_buf[0]); &tl_cmd->tl_sense_buf[0]);
rc = core_tmr_alloc_req(se_cmd, tl_tmr, tmr, GFP_KERNEL); rc = core_tmr_alloc_req(se_cmd, tl_tmr, tmr, GFP_KERNEL);

2
drivers/target/sbp/sbp_target.c
View file

@ -1237,7 +1237,7 @@ static void sbp_handle_command(struct sbp_target_request *req)
if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf, if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
req->sense_buf, unpacked_lun, data_length, req->sense_buf, unpacked_lun, data_length,
MSG_SIMPLE_TAG, data_dir, 0)) TCM_SIMPLE_TAG, data_dir, 0))
goto err; goto err;
return; return;

2
drivers/target/target_core_pscsi.c
View file

@ -1094,7 +1094,7 @@ pscsi_execute_cmd(struct se_cmd *cmd)
req->retries = PS_RETRY; req->retries = PS_RETRY;
blk_execute_rq_nowait(pdv->pdv_sd->request_queue, NULL, req, blk_execute_rq_nowait(pdv->pdv_sd->request_queue, NULL, req,
(cmd->sam_task_attr == MSG_HEAD_TAG), (cmd->sam_task_attr == TCM_HEAD_TAG),
pscsi_req_done); pscsi_req_done);
return 0; return 0;

2
drivers/target/target_core_sbc.c
View file

@ -485,7 +485,7 @@ static sense_reason_t compare_and_write_callback(struct se_cmd *cmd)
cmd->t_data_nents_orig = cmd->t_data_nents; cmd->t_data_nents_orig = cmd->t_data_nents;
cmd->t_data_nents = 1; cmd->t_data_nents = 1;
cmd->sam_task_attr = MSG_HEAD_TAG; cmd->sam_task_attr = TCM_HEAD_TAG;
cmd->transport_complete_callback = compare_and_write_post; cmd->transport_complete_callback = compare_and_write_post;
/* /*
* Now reset ->execute_cmd() to the normal sbc_execute_rw() handler * Now reset ->execute_cmd() to the normal sbc_execute_rw() handler

4
drivers/target/target_core_spc.c
View file

@ -1357,7 +1357,7 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
* Do implicit HEAD_OF_QUEUE processing for INQUIRY. * Do implicit HEAD_OF_QUEUE processing for INQUIRY.
* See spc4r17 section 5.3 * See spc4r17 section 5.3
*/ */
cmd->sam_task_attr = MSG_HEAD_TAG; cmd->sam_task_attr = TCM_HEAD_TAG;
cmd->execute_cmd = spc_emulate_inquiry; cmd->execute_cmd = spc_emulate_inquiry;
break; break;
case SECURITY_PROTOCOL_IN: case SECURITY_PROTOCOL_IN:
@ -1391,7 +1391,7 @@ spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
* Do implicit HEAD_OF_QUEUE processing for REPORT_LUNS * Do implicit HEAD_OF_QUEUE processing for REPORT_LUNS
* See spc4r17 section 5.3 * See spc4r17 section 5.3
*/ */
cmd->sam_task_attr = MSG_HEAD_TAG; cmd->sam_task_attr = TCM_HEAD_TAG;
break; break;
case TEST_UNIT_READY: case TEST_UNIT_READY:
cmd->execute_cmd = spc_emulate_testunitready; cmd->execute_cmd = spc_emulate_testunitready;

16
drivers/target/target_core_transport.c
View file

@ -1159,7 +1159,7 @@ transport_check_alloc_task_attr(struct se_cmd *cmd)
if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV)
return 0; return 0;
if (cmd->sam_task_attr == MSG_ACA_TAG) { if (cmd->sam_task_attr == TCM_ACA_TAG) {
pr_debug("SAM Task Attribute ACA" pr_debug("SAM Task Attribute ACA"
" emulation is not supported\n"); " emulation is not supported\n");
return TCM_INVALID_CDB_FIELD; return TCM_INVALID_CDB_FIELD;
@ -1531,7 +1531,7 @@ int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
BUG_ON(!se_tpg); BUG_ON(!se_tpg);
transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess,
0, DMA_NONE, MSG_SIMPLE_TAG, sense); 0, DMA_NONE, TCM_SIMPLE_TAG, sense);
/* /*
* FIXME: Currently expect caller to handle se_cmd->se_tmr_req * FIXME: Currently expect caller to handle se_cmd->se_tmr_req
* allocation failure. * allocation failure.
@ -1718,12 +1718,12 @@ static bool target_handle_task_attr(struct se_cmd *cmd)
* to allow the passed struct se_cmd list of tasks to the front of the list. * to allow the passed struct se_cmd list of tasks to the front of the list.
*/ */
switch (cmd->sam_task_attr) { switch (cmd->sam_task_attr) {
case MSG_HEAD_TAG: case TCM_HEAD_TAG:
pr_debug("Added HEAD_OF_QUEUE for CDB: 0x%02x, " pr_debug("Added HEAD_OF_QUEUE for CDB: 0x%02x, "
"se_ordered_id: %u\n", "se_ordered_id: %u\n",
cmd->t_task_cdb[0], cmd->se_ordered_id); cmd->t_task_cdb[0], cmd->se_ordered_id);
return false; return false;
case MSG_ORDERED_TAG: case TCM_ORDERED_TAG:
atomic_inc_mb(&dev->dev_ordered_sync); atomic_inc_mb(&dev->dev_ordered_sync);
pr_debug("Added ORDERED for CDB: 0x%02x to ordered list, " pr_debug("Added ORDERED for CDB: 0x%02x to ordered list, "
@ -1828,7 +1828,7 @@ static void target_restart_delayed_cmds(struct se_device *dev)
__target_execute_cmd(cmd); __target_execute_cmd(cmd);
if (cmd->sam_task_attr == MSG_ORDERED_TAG) if (cmd->sam_task_attr == TCM_ORDERED_TAG)
break; break;
} }
} }
@ -1844,18 +1844,18 @@ static void transport_complete_task_attr(struct se_cmd *cmd)
if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV)
return; return;
if (cmd->sam_task_attr == MSG_SIMPLE_TAG) { if (cmd->sam_task_attr == TCM_SIMPLE_TAG) {
atomic_dec_mb(&dev->simple_cmds); atomic_dec_mb(&dev->simple_cmds);
dev->dev_cur_ordered_id++; dev->dev_cur_ordered_id++;
pr_debug("Incremented dev->dev_cur_ordered_id: %u for" pr_debug("Incremented dev->dev_cur_ordered_id: %u for"
" SIMPLE: %u\n", dev->dev_cur_ordered_id, " SIMPLE: %u\n", dev->dev_cur_ordered_id,
cmd->se_ordered_id); cmd->se_ordered_id);
} else if (cmd->sam_task_attr == MSG_HEAD_TAG) { } else if (cmd->sam_task_attr == TCM_HEAD_TAG) {
dev->dev_cur_ordered_id++; dev->dev_cur_ordered_id++;
pr_debug("Incremented dev_cur_ordered_id: %u for" pr_debug("Incremented dev_cur_ordered_id: %u for"
" HEAD_OF_QUEUE: %u\n", dev->dev_cur_ordered_id, " HEAD_OF_QUEUE: %u\n", dev->dev_cur_ordered_id,
cmd->se_ordered_id); cmd->se_ordered_id);
} else if (cmd->sam_task_attr == MSG_ORDERED_TAG) { } else if (cmd->sam_task_attr == TCM_ORDERED_TAG) {
atomic_dec_mb(&dev->dev_ordered_sync); atomic_dec_mb(&dev->dev_ordered_sync);
dev->dev_cur_ordered_id++; dev->dev_cur_ordered_id++;

8
drivers/target/tcm_fc/tfc_cmd.c
View file

@ -554,17 +554,17 @@ static void ft_send_work(struct work_struct *work)
*/ */
switch (fcp->fc_pri_ta & FCP_PTA_MASK) { switch (fcp->fc_pri_ta & FCP_PTA_MASK) {
case FCP_PTA_HEADQ: case FCP_PTA_HEADQ:
task_attr = MSG_HEAD_TAG; task_attr = TCM_HEAD_TAG;
break; break;
case FCP_PTA_ORDERED: case FCP_PTA_ORDERED:
task_attr = MSG_ORDERED_TAG; task_attr = TCM_ORDERED_TAG;
break; break;
case FCP_PTA_ACA: case FCP_PTA_ACA:
task_attr = MSG_ACA_TAG; task_attr = TCM_ACA_TAG;
break; break;
case FCP_PTA_SIMPLE: /* Fallthrough */ case FCP_PTA_SIMPLE: /* Fallthrough */
default: default:
task_attr = MSG_SIMPLE_TAG; task_attr = TCM_SIMPLE_TAG;
} }
fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd); fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd);

10
drivers/usb/gadget/legacy/tcm_usb_gadget.c
View file

@ -1131,19 +1131,19 @@ static int usbg_submit_command(struct f_uas *fu,
switch (cmd_iu->prio_attr & 0x7) { switch (cmd_iu->prio_attr & 0x7) {
case UAS_HEAD_TAG: case UAS_HEAD_TAG:
cmd->prio_attr = MSG_HEAD_TAG; cmd->prio_attr = TCM_HEAD_TAG;
break; break;
case UAS_ORDERED_TAG: case UAS_ORDERED_TAG:
cmd->prio_attr = MSG_ORDERED_TAG; cmd->prio_attr = TCM_ORDERED_TAG;
break; break;
case UAS_ACA: case UAS_ACA:
cmd->prio_attr = MSG_ACA_TAG; cmd->prio_attr = TCM_ACA_TAG;
break; break;
default: default:
pr_debug_once("Unsupported prio_attr: %02x.\n", pr_debug_once("Unsupported prio_attr: %02x.\n",
cmd_iu->prio_attr); cmd_iu->prio_attr);
case UAS_SIMPLE_TAG: case UAS_SIMPLE_TAG:
cmd->prio_attr = MSG_SIMPLE_TAG; cmd->prio_attr = TCM_SIMPLE_TAG;
break; break;
} }
@ -1240,7 +1240,7 @@ static int bot_submit_command(struct f_uas *fu,
goto err; goto err;
} }
cmd->prio_attr = MSG_SIMPLE_TAG; cmd->prio_attr = TCM_SIMPLE_TAG;
se_cmd = &cmd->se_cmd; se_cmd = &cmd->se_cmd;
cmd->unpacked_lun = cbw->Lun; cmd->unpacked_lun = cbw->Lun;
cmd->is_read = cbw->Flags & US_BULK_FLAG_IN ? 1 : 0; cmd->is_read = cbw->Flags & US_BULK_FLAG_IN ? 1 : 0;

2
drivers/xen/xen-scsiback.c
View file

@ -606,7 +606,7 @@ static void scsiback_device_action(struct vscsibk_pend *pending_req,
init_waitqueue_head(&tmr->tmr_wait); init_waitqueue_head(&tmr->tmr_wait);
transport_init_se_cmd(se_cmd, tpg->se_tpg.se_tpg_tfo, transport_init_se_cmd(se_cmd, tpg->se_tpg.se_tpg_tfo,
tpg->tpg_nexus->tvn_se_sess, 0, DMA_NONE, MSG_SIMPLE_TAG, tpg->tpg_nexus->tvn_se_sess, 0, DMA_NONE, TCM_SIMPLE_TAG,
&pending_req->sense_buffer[0]); &pending_req->sense_buffer[0]);
rc = core_tmr_alloc_req(se_cmd, tmr, act, GFP_KERNEL); rc = core_tmr_alloc_req(se_cmd, tmr, act, GFP_KERNEL);

5
include/scsi/scsi_tcq.h
View file

@ -6,11 +6,6 @@
#include <scsi/scsi_device.h> #include <scsi/scsi_device.h>
#include <scsi/scsi_host.h> #include <scsi/scsi_host.h>
#define MSG_SIMPLE_TAG 0x20
#define MSG_HEAD_TAG 0x21
#define MSG_ORDERED_TAG 0x22
#define MSG_ACA_TAG 0x24 /* unsupported */
#define SCSI_NO_TAG (-1) /* identify no tag in use */ #define SCSI_NO_TAG (-1) /* identify no tag in use */

6
include/target/target_core_base.h
View file

@ -476,6 +476,12 @@ struct se_dif_v1_tuple {
__be32 ref_tag; __be32 ref_tag;
}; };
/* for sam_task_attr */
#define TCM_SIMPLE_TAG 0x20
#define TCM_HEAD_TAG 0x21
#define TCM_ORDERED_TAG 0x22
#define TCM_ACA_TAG 0x24
struct se_cmd { struct se_cmd {
/* SAM response code being sent to initiator */ /* SAM response code being sent to initiator */
u8 scsi_status; u8 scsi_status;

8
include/trace/events/target.h
View file

@ -109,10 +109,10 @@
#define show_task_attribute_name(val) \ #define show_task_attribute_name(val) \
__print_symbolic(val, \ __print_symbolic(val, \
{ MSG_SIMPLE_TAG, "SIMPLE" }, \ { TCM_SIMPLE_TAG, "SIMPLE" }, \
{ MSG_HEAD_TAG, "HEAD" }, \ { TCM_HEAD_TAG, "HEAD" }, \
{ MSG_ORDERED_TAG, "ORDERED" }, \ { TCM_ORDERED_TAG, "ORDERED" }, \
{ MSG_ACA_TAG, "ACA" } ) { TCM_ACA_TAG, "ACA" } )
#define show_scsi_status_name(val) \ #define show_scsi_status_name(val) \
__print_symbolic(val, \ __print_symbolic(val, \