drivers/infiniband/ulp/isert/ib_isert.c

1060

data_len = cmd->se_cmd.data_length;

drivers/infiniband/ulp/isert/ib_isert.c

1063

cmd->se_cmd.se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC;

drivers/infiniband/ulp/isert/ib_isert.c

1077

sg_copy_from_buffer(cmd->se_cmd.t_data_sg, sg_nents,

drivers/infiniband/ulp/isert/ib_isert.c

1083

cmd->se_cmd.t_data_sg = &isert_cmd->sg;

drivers/infiniband/ulp/isert/ib_isert.c

1084

cmd->se_cmd.t_data_nents = 1;

drivers/infiniband/ulp/isert/ib_isert.c

1093

if (cmd->write_data_done == cmd->se_cmd.data_length) {

drivers/infiniband/ulp/isert/ib_isert.c

1106

target_put_sess_cmd(&cmd->se_cmd);

drivers/infiniband/ulp/isert/ib_isert.c

1139

cmd->se_cmd.data_length);

drivers/infiniband/ulp/isert/ib_isert.c

1142

sg_start = &cmd->se_cmd.t_data_sg[sg_off];

drivers/infiniband/ulp/isert/ib_isert.c

1406

struct se_cmd *se_cmd = &cmd->iscsit_cmd->se_cmd;

drivers/infiniband/ulp/isert/ib_isert.c

1407

enum dma_data_direction dir = target_reverse_dma_direction(se_cmd);

drivers/infiniband/ulp/isert/ib_isert.c

1412

if (isert_prot_cmd(conn, se_cmd)) {

drivers/infiniband/ulp/isert/ib_isert.c

1414

conn->cm_id->port_num, se_cmd->t_data_sg,

drivers/infiniband/ulp/isert/ib_isert.c

1415

se_cmd->t_data_nents, se_cmd->t_prot_sg,

drivers/infiniband/ulp/isert/ib_isert.c

1416

se_cmd->t_prot_nents, dir);

drivers/infiniband/ulp/isert/ib_isert.c

1419

se_cmd->t_data_sg, se_cmd->t_data_nents, dir);

drivers/infiniband/ulp/isert/ib_isert.c

1451

cmd->se_cmd.t_state == TRANSPORT_WRITE_PENDING) {

drivers/infiniband/ulp/isert/ib_isert.c

1452

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/infiniband/ulp/isert/ib_isert.c

1454

target_put_sess_cmd(se_cmd);

drivers/infiniband/ulp/isert/ib_isert.c

1459

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/infiniband/ulp/isert/ib_isert.c

1467

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/infiniband/ulp/isert/ib_isert.c

1487

if (cmd->se_cmd.se_tfo != NULL) {

drivers/infiniband/ulp/isert/ib_isert.c

1490

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/infiniband/ulp/isert/ib_isert.c

1527

isert_check_pi_status(struct se_cmd *se_cmd, struct ib_mr *sig_mr)

drivers/infiniband/ulp/isert/ib_isert.c

1540

u32 block_size = se_cmd->se_dev->dev_attrib.block_size + 8;

drivers/infiniband/ulp/isert/ib_isert.c

1544

se_cmd->pi_err = TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED;

drivers/infiniband/ulp/isert/ib_isert.c

1547

se_cmd->pi_err = TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;

drivers/infiniband/ulp/isert/ib_isert.c

1550

se_cmd->pi_err = TCM_LOGICAL_BLOCK_APP_TAG_CHECK_FAILED;

drivers/infiniband/ulp/isert/ib_isert.c

1555

se_cmd->sense_info = sec_offset_err + se_cmd->t_task_lba;

drivers/infiniband/ulp/isert/ib_isert.c

1560

(unsigned long long)se_cmd->sense_info,

drivers/infiniband/ulp/isert/ib_isert.c

1577

struct se_cmd *cmd = &isert_cmd->iscsit_cmd->se_cmd;

drivers/infiniband/ulp/isert/ib_isert.c

1620

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/infiniband/ulp/isert/ib_isert.c

1635

if (isert_prot_cmd(isert_conn, se_cmd))

drivers/infiniband/ulp/isert/ib_isert.c

1636

ret = isert_check_pi_status(se_cmd, isert_cmd->rw.reg->mr);

drivers/infiniband/ulp/isert/ib_isert.c

1652

transport_generic_request_failure(se_cmd, se_cmd->pi_err);

drivers/infiniband/ulp/isert/ib_isert.c

1654

target_execute_cmd(se_cmd);

drivers/infiniband/ulp/isert/ib_isert.c

1771

if (cmd->se_cmd.sense_buffer &&

drivers/infiniband/ulp/isert/ib_isert.c

1772

((cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||

drivers/infiniband/ulp/isert/ib_isert.c

1773

(cmd->se_cmd.se_cmd_flags & SCF_EMULATED_TASK_SENSE))) {

drivers/infiniband/ulp/isert/ib_isert.c

1779

put_unaligned_be16(cmd->se_cmd.scsi_sense_length,

drivers/infiniband/ulp/isert/ib_isert.c

1781

cmd->se_cmd.scsi_sense_length += sizeof(__be16);

drivers/infiniband/ulp/isert/ib_isert.c

1783

padding = -(cmd->se_cmd.scsi_sense_length) & 3;

drivers/infiniband/ulp/isert/ib_isert.c

1784

hton24(hdr->dlength, (u32)cmd->se_cmd.scsi_sense_length);

drivers/infiniband/ulp/isert/ib_isert.c

1785

pdu_len = cmd->se_cmd.scsi_sense_length + padding;

drivers/infiniband/ulp/isert/ib_isert.c

1978

isert_set_dif_domain(struct se_cmd *se_cmd, struct ib_sig_domain *domain)

drivers/infiniband/ulp/isert/ib_isert.c

1982

domain->sig.dif.pi_interval = se_cmd->se_dev->dev_attrib.block_size;

drivers/infiniband/ulp/isert/ib_isert.c

1983

domain->sig.dif.ref_tag = se_cmd->reftag_seed;

drivers/infiniband/ulp/isert/ib_isert.c

1992

if (se_cmd->prot_type == TARGET_DIF_TYPE1_PROT ||

drivers/infiniband/ulp/isert/ib_isert.c

1993

se_cmd->prot_type == TARGET_DIF_TYPE2_PROT)

drivers/infiniband/ulp/isert/ib_isert.c

1998

isert_set_sig_attrs(struct se_cmd *se_cmd, struct ib_sig_attrs *sig_attrs)

drivers/infiniband/ulp/isert/ib_isert.c

2002

switch (se_cmd->prot_op) {

drivers/infiniband/ulp/isert/ib_isert.c

2006

isert_set_dif_domain(se_cmd, &sig_attrs->wire);

drivers/infiniband/ulp/isert/ib_isert.c

2011

isert_set_dif_domain(se_cmd, &sig_attrs->mem);

drivers/infiniband/ulp/isert/ib_isert.c

2015

isert_set_dif_domain(se_cmd, &sig_attrs->wire);

drivers/infiniband/ulp/isert/ib_isert.c

2016

isert_set_dif_domain(se_cmd, &sig_attrs->mem);

drivers/infiniband/ulp/isert/ib_isert.c

2019

isert_err("Unsupported PI operation %d\n", se_cmd->prot_op);

drivers/infiniband/ulp/isert/ib_isert.c

2023

if (se_cmd->prot_checks & TARGET_DIF_CHECK_GUARD)

drivers/infiniband/ulp/isert/ib_isert.c

2025

if (se_cmd->prot_checks & TARGET_DIF_CHECK_APPTAG)

drivers/infiniband/ulp/isert/ib_isert.c

2027

if (se_cmd->prot_checks & TARGET_DIF_CHECK_REFTAG)

drivers/infiniband/ulp/isert/ib_isert.c

2037

struct se_cmd *se_cmd = &cmd->iscsit_cmd->se_cmd;

drivers/infiniband/ulp/isert/ib_isert.c

2038

enum dma_data_direction dir = target_reverse_dma_direction(se_cmd);

drivers/infiniband/ulp/isert/ib_isert.c

2057

if (isert_prot_cmd(conn, se_cmd)) {

drivers/infiniband/ulp/isert/ib_isert.c

2060

ret = isert_set_sig_attrs(se_cmd, &sig_attrs);

drivers/infiniband/ulp/isert/ib_isert.c

2066

se_cmd->t_data_sg, se_cmd->t_data_nents,

drivers/infiniband/ulp/isert/ib_isert.c

2067

se_cmd->t_prot_sg, se_cmd->t_prot_nents,

drivers/infiniband/ulp/isert/ib_isert.c

2071

se_cmd->t_data_sg, se_cmd->t_data_nents,

drivers/infiniband/ulp/isert/ib_isert.c

2092

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/infiniband/ulp/isert/ib_isert.c

2100

isert_cmd, se_cmd->data_length);

drivers/infiniband/ulp/isert/ib_isert.c

2102

if (isert_prot_cmd(isert_conn, se_cmd)) {

drivers/infiniband/ulp/isert/ib_isert.c

2137

isert_cmd, cmd->se_cmd.data_length, cmd->write_data_done);

drivers/infiniband/ulp/isert/ib_isert.c

2538

(cmd->write_data_done < cmd->se_cmd.data_length))

drivers/infiniband/ulp/isert/ib_isert.c

76

isert_prot_cmd(struct isert_conn *conn, struct se_cmd *cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

104

static void srpt_release_cmd(struct se_cmd *se_cmd);

drivers/infiniband/ulp/srpt/ib_srpt.c

106

static int srpt_queue_status(struct se_cmd *cmd);

drivers/infiniband/ulp/srpt/ib_srpt.c

1433

struct se_cmd *cmd = &ioctx->cmd;

drivers/infiniband/ulp/srpt/ib_srpt.c

1538

static int srpt_check_stop_free(struct se_cmd *cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

1556

struct se_cmd *cmd;

drivers/infiniband/ulp/srpt/ib_srpt.c

1650

struct se_cmd *cmd;

drivers/infiniband/ulp/srpt/ib_srpt.c

2802

static int srpt_write_pending(struct se_cmd *se_cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

2805

container_of(se_cmd, struct srpt_send_ioctx, cmd);

drivers/infiniband/ulp/srpt/ib_srpt.c

2869

static void srpt_queue_response(struct se_cmd *cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

2961

static int srpt_queue_data_in(struct se_cmd *cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

2967

static void srpt_queue_tm_rsp(struct se_cmd *cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

2978

static void srpt_aborted_task(struct se_cmd *cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

2987

static int srpt_queue_status(struct se_cmd *cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

3393

static void srpt_release_cmd(struct se_cmd *se_cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

3395

struct srpt_send_ioctx *ioctx = container_of(se_cmd,

drivers/infiniband/ulp/srpt/ib_srpt.c

3414

target_free_tag(se_cmd->se_sess, se_cmd);

drivers/infiniband/ulp/srpt/ib_srpt.c

3433

static int srpt_get_tcm_cmd_state(struct se_cmd *se_cmd)

drivers/infiniband/ulp/srpt/ib_srpt.c

3437

ioctx = container_of(se_cmd, struct srpt_send_ioctx, cmd);

drivers/infiniband/ulp/srpt/ib_srpt.h

225

struct se_cmd cmd;

drivers/scsi/elx/efct/efct_lio.c

1325

struct se_cmd *se_cmd = &io->tgt_io.cmd;

drivers/scsi/elx/efct/efct_lio.c

1381

rc = target_init_cmd(se_cmd, se_sess, &io->tgt_io.sense_buffer[0],

drivers/scsi/elx/efct/efct_lio.c

1385

efc_log_err(efct, "failed to init cmd se_cmd: %p\n", se_cmd);

drivers/scsi/elx/efct/efct_lio.c

1390

if (target_submit_prep(se_cmd, cdb, NULL, 0, NULL, 0,

drivers/scsi/elx/efct/efct_lio.c

1394

target_submit(se_cmd);

drivers/scsi/elx/efct/efct_lio.c

288

static int efct_lio_check_stop_free(struct se_cmd *se_cmd)

drivers/scsi/elx/efct/efct_lio.c

291

container_of(se_cmd, struct efct_scsi_tgt_io, cmd);

drivers/scsi/elx/efct/efct_lio.c

295

return target_put_sess_cmd(se_cmd);

drivers/scsi/elx/efct/efct_lio.c

308

efct_lio_aborted_task(struct se_cmd *se_cmd)

drivers/scsi/elx/efct/efct_lio.c

311

container_of(se_cmd, struct efct_scsi_tgt_io, cmd);

drivers/scsi/elx/efct/efct_lio.c

326

static void efct_lio_release_cmd(struct se_cmd *se_cmd)

drivers/scsi/elx/efct/efct_lio.c

329

container_of(se_cmd, struct efct_scsi_tgt_io, cmd);

drivers/scsi/elx/efct/efct_lio.c

353

static int efct_lio_get_cmd_state(struct se_cmd *cmd)

drivers/scsi/elx/efct/efct_lio.c

366

struct se_cmd *cmd = &ocp->cmd;

drivers/scsi/elx/efct/efct_lio.c

379

struct se_cmd *cmd = &ocp->cmd;

drivers/scsi/elx/efct/efct_lio.c

418

efct_lio_write_pending(struct se_cmd *cmd)

drivers/scsi/elx/efct/efct_lio.c

463

efct_lio_queue_data_in(struct se_cmd *cmd)

drivers/scsi/elx/efct/efct_lio.c

536

struct se_cmd *cmd = &io->tgt_io.cmd;

drivers/scsi/elx/efct/efct_lio.c

652

efct_lio_queue_status(struct se_cmd *cmd)

drivers/scsi/elx/efct/efct_lio.c

686

static void efct_lio_queue_tm_rsp(struct se_cmd *cmd)

drivers/scsi/elx/efct/efct_lio.h

107

struct se_cmd cmd;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1290

memset(&cmd->se_cmd, 0, sizeof(cmd->se_cmd));

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1906

if (cmd->se_cmd.transport_state & CMD_T_ABORTED &&

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

1907

!(cmd->se_cmd.transport_state & CMD_T_TAS)) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2717

cmd->se_cmd.tag = be64_to_cpu(srp->tag);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2725

target_submit_cmd(&cmd->se_cmd, nexus->se_sess, srp->cdb,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2782

cmd->se_cmd.se_tmr_req->response =

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2789

cmd->se_cmd.tag = be64_to_cpu(srp_tsk->tag);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2799

rc = target_submit_tmr(&cmd->se_cmd, nexus->se_sess, NULL,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2808

cmd->se_cmd.se_tmr_req->response =

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

2814

transport_send_check_condition_and_sense(&cmd->se_cmd, 0, 0);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3045

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3048

u8 rc = se_cmd->scsi_status;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3051

if (scsi_normalize_sense(se_cmd->sense_buffer,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3052

se_cmd->scsi_sense_length, &sshdr))

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3054

(se_cmd->residual_count == 0 ||

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3055

se_cmd->residual_count == se_cmd->data_length)) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3076

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3102

ibmvscsis_determine_resid(se_cmd, rsp);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3103

if (se_cmd->scsi_sense_length && se_cmd->sense_buffer) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3105

cpu_to_be32(se_cmd->scsi_sense_length);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3107

len += se_cmd->scsi_sense_length;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3108

memcpy(data, se_cmd->sense_buffer,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3109

se_cmd->scsi_sense_length);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3128

switch (se_cmd->se_tmr_req->response) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3693

static int ibmvscsis_check_stop_free(struct se_cmd *se_cmd)

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3695

return target_put_sess_cmd(se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3698

static void ibmvscsis_release_cmd(struct se_cmd *se_cmd)

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3700

struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3701

se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3711

static int ibmvscsis_write_pending(struct se_cmd *se_cmd)

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3713

struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3714

se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3741

target_execute_cmd(se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3745

static int ibmvscsis_queue_data_in(struct se_cmd *se_cmd)

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3747

struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3748

se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3758

se_cmd->scsi_sense_length = 18;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3759

memset(se_cmd->sense_buffer, 0, se_cmd->scsi_sense_length);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3761

scsi_build_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3772

static int ibmvscsis_queue_status(struct se_cmd *se_cmd)

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3774

struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3775

se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3779

dev_dbg(&vscsi->dev, "queue_status %p\n", se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3788

static void ibmvscsis_queue_tm_rsp(struct se_cmd *se_cmd)

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3790

struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3791

se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3800

se_cmd, (int)se_cmd->se_tmr_req->response);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3803

cmd->se_cmd.se_tmr_req->response == TMR_TASK_DOES_NOT_EXIST) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3806

if (tag_to_abort == cmd_itr->se_cmd.tag) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3820

static void ibmvscsis_aborted_task(struct se_cmd *se_cmd)

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3822

struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3823

se_cmd);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

3827

se_cmd, se_cmd->tag);

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

58

static void ibmvscsis_determine_resid(struct se_cmd *se_cmd,

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

61

u32 residual_count = se_cmd->residual_count;

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

66

if (se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

67

if (se_cmd->data_direction == DMA_TO_DEVICE) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

71

} else if (se_cmd->data_direction == DMA_FROM_DEVICE) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

76

} else if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

77

if (se_cmd->data_direction == DMA_TO_DEVICE) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c

81

} else if (se_cmd->data_direction == DMA_FROM_DEVICE) {

drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.h

157

struct se_cmd se_cmd;

drivers/scsi/ibmvscsi_tgt/libsrp.c

171

sg = cmd->se_cmd.t_data_sg;

drivers/scsi/ibmvscsi_tgt/libsrp.c

172

nsg = dma_map_sg(iue->target->dev, sg, cmd->se_cmd.t_data_nents,

drivers/scsi/ibmvscsi_tgt/libsrp.c

176

cmd->se_cmd.t_data_nents);

drivers/scsi/ibmvscsi_tgt/libsrp.c

179

len = min(cmd->se_cmd.data_length, be32_to_cpu(md->len));

drivers/scsi/ibmvscsi_tgt/libsrp.c

187

dma_unmap_sg(iue->target->dev, sg, cmd->se_cmd.t_data_nents,

drivers/scsi/ibmvscsi_tgt/libsrp.c

207

sg = cmd->se_cmd.t_data_sg;

drivers/scsi/ibmvscsi_tgt/libsrp.c

244

nsg = dma_map_sg(iue->target->dev, sg, cmd->se_cmd.t_data_nents,

drivers/scsi/ibmvscsi_tgt/libsrp.c

248

cmd->se_cmd.t_data_nents);

drivers/scsi/ibmvscsi_tgt/libsrp.c

252

len = min(cmd->se_cmd.data_length, be32_to_cpu(id->len));

drivers/scsi/ibmvscsi_tgt/libsrp.c

260

dma_unmap_sg(iue->target->dev, sg, cmd->se_cmd.t_data_nents,

drivers/scsi/ibmvscsi_tgt/libsrp.c

306

if (!cmd->se_cmd.t_data_nents)

drivers/scsi/qla2xxx/qla_target.c

1990

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

2077

mcmd->se_cmd.cpuid = h->cpuid;

drivers/scsi/qla2xxx/qla_target.c

2085

mcmd->unpacked_lun = abort_cmd->se_cmd.orig_fe_lun;

drivers/scsi/qla2xxx/qla_target.c

2089

mcmd->se_cmd.cpuid = abort_cmd->se_cmd.cpuid;

drivers/scsi/qla2xxx/qla_target.c

2095

queue_work_on(mcmd->se_cmd.cpuid, qla_tgt_wq, &mcmd->work);

drivers/scsi/qla2xxx/qla_target.c

2393

if (cmd->se_cmd.prot_op == TARGET_PROT_NORMAL) {

drivers/scsi/qla2xxx/qla_target.c

2404

if ((cmd->se_cmd.prot_op == TARGET_PROT_DIN_INSERT) ||

drivers/scsi/qla2xxx/qla_target.c

2405

(cmd->se_cmd.prot_op == TARGET_PROT_DOUT_STRIP)) {

drivers/scsi/qla2xxx/qla_target.c

2419

if ((cmd->se_cmd.prot_op == TARGET_PROT_DIN_INSERT) ||

drivers/scsi/qla2xxx/qla_target.c

2420

(cmd->se_cmd.prot_op == TARGET_PROT_DOUT_STRIP)) {

drivers/scsi/qla2xxx/qla_target.c

2694

cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,

drivers/scsi/qla2xxx/qla_target.c

2701

cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,

drivers/scsi/qla2xxx/qla_target.c

2708

cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,

drivers/scsi/qla2xxx/qla_target.c

2715

cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,

drivers/scsi/qla2xxx/qla_target.c

2730

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/qla2xxx/qla_target.c

2755

if (se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) {

drivers/scsi/qla2xxx/qla_target.c

2756

prm->residual = se_cmd->residual_count;

drivers/scsi/qla2xxx/qla_target.c

2759

prm->residual, se_cmd->tag,

drivers/scsi/qla2xxx/qla_target.c

2760

se_cmd->t_task_cdb ? se_cmd->t_task_cdb[0] : 0,

drivers/scsi/qla2xxx/qla_target.c

2763

} else if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {

drivers/scsi/qla2xxx/qla_target.c

2764

prm->residual = se_cmd->residual_count;

drivers/scsi/qla2xxx/qla_target.c

2767

prm->residual, se_cmd->tag, se_cmd->t_task_cdb ?

drivers/scsi/qla2xxx/qla_target.c

2768

se_cmd->t_task_cdb[0] : 0, cmd->bufflen, prm->rq_result);

drivers/scsi/qla2xxx/qla_target.c

2864

qlt_hba_err_chk_enabled(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/qla_target.c

2866

switch (se_cmd->prot_op) {

drivers/scsi/qla2xxx/qla_target.c

2887

qla_tgt_ref_mask_check(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/qla_target.c

2889

switch (se_cmd->prot_op) {

drivers/scsi/qla2xxx/qla_target.c

2910

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/qla2xxx/qla_target.c

2911

uint32_t lba = 0xffffffff & se_cmd->t_task_lba;

drivers/scsi/qla2xxx/qla_target.c

2926

if ((se_cmd->prot_type == TARGET_DIF_TYPE1_PROT) ||

drivers/scsi/qla2xxx/qla_target.c

2927

(se_cmd->prot_type == TARGET_DIF_TYPE2_PROT))

drivers/scsi/qla2xxx/qla_target.c

2929

else if (se_cmd->prot_type == TARGET_DIF_TYPE3_PROT)

drivers/scsi/qla2xxx/qla_target.c

2935

switch (se_cmd->prot_type) {

drivers/scsi/qla2xxx/qla_target.c

2955

if (!qla_tgt_ref_mask_check(se_cmd) ||

drivers/scsi/qla2xxx/qla_target.c

2972

if (!qla_tgt_ref_mask_check(se_cmd) ||

drivers/scsi/qla2xxx/qla_target.c

3006

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/qla2xxx/qla_target.c

3021

cmd->vp_idx, __func__, se_cmd, se_cmd->prot_op,

drivers/scsi/qla2xxx/qla_target.c

3022

prm->prot_sg, prm->prot_seg_cnt, se_cmd->t_task_lba);

drivers/scsi/qla2xxx/qla_target.c

3024

if ((se_cmd->prot_op == TARGET_PROT_DIN_INSERT) ||

drivers/scsi/qla2xxx/qla_target.c

3025

(se_cmd->prot_op == TARGET_PROT_DOUT_STRIP))

drivers/scsi/qla2xxx/qla_target.c

3032

switch (se_cmd->prot_op) {

drivers/scsi/qla2xxx/qla_target.c

3050

if (!qlt_hba_err_chk_enabled(se_cmd))

drivers/scsi/qla2xxx/qla_target.c

3054

if ((se_cmd->prot_type == TARGET_DIF_TYPE1_PROT) ||

drivers/scsi/qla2xxx/qla_target.c

3055

(se_cmd->prot_type == TARGET_DIF_TYPE2_PROT))

drivers/scsi/qla2xxx/qla_target.c

3057

else if (se_cmd->prot_type == TARGET_DIF_TYPE3_PROT)

drivers/scsi/qla2xxx/qla_target.c

3061

switch (se_cmd->prot_op) {

drivers/scsi/qla2xxx/qla_target.c

3220

&cmd->se_cmd, qpair->id);

drivers/scsi/qla2xxx/qla_target.c

3241

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

3264

if (cmd->se_cmd.prot_op && (xmit_type & QLA_TGT_XMIT_DATA))

drivers/scsi/qla2xxx/qla_target.c

3280

if (cmd->se_cmd.prot_op == TARGET_PROT_NORMAL)

drivers/scsi/qla2xxx/qla_target.c

3400

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

3421

if (cmd->se_cmd.prot_op)

drivers/scsi/qla2xxx/qla_target.c

3435

if (cmd->se_cmd.prot_op == TARGET_PROT_NORMAL)

drivers/scsi/qla2xxx/qla_target.c

3471

uint64_t lba = cmd->se_cmd.t_task_lba;

drivers/scsi/qla2xxx/qla_target.c

3652

vha->vp_idx, cmd->se_cmd.tag, __func__);

drivers/scsi/qla2xxx/qla_target.c

3660

vha->vp_idx, cmd->se_cmd.tag, __func__,

drivers/scsi/qla2xxx/qla_target.c

3672

vha->vp_idx, cmd->se_cmd.tag, __func__);

drivers/scsi/qla2xxx/qla_target.c

3720

vha->vp_idx, cmd->se_cmd.tag, cmd->state,

drivers/scsi/qla2xxx/qla_target.c

3874

vha->vp_idx, cmd->se_cmd.tag, cmd->state,

drivers/scsi/qla2xxx/qla_target.c

3905

__func__, &cmd->se_cmd,

drivers/scsi/qla2xxx/qla_target.c

3926

cmd->vha->vp_idx, cmd->se_cmd.tag,

drivers/scsi/qla2xxx/qla_target.c

3971

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

3980

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

3986

queue_work_on(cmd->se_cmd.cpuid, qla_tgt_wq, &tgt->srr_work);

drivers/scsi/qla2xxx/qla_target.c

4194

vha->vp_idx, cmd->se_cmd.tag, op,

drivers/scsi/qla2xxx/qla_target.c

4227

vha->vp_idx, cmd->se_cmd.tag, op,

drivers/scsi/qla2xxx/qla_target.c

4241

vha->vp_idx, cmd->se_cmd.tag, op,

drivers/scsi/qla2xxx/qla_target.c

4265

vha->vp_idx, cmd->se_cmd.tag, op, status,

drivers/scsi/qla2xxx/qla_target.c

4278

vha->vp_idx, cmd->se_cmd.tag, op, status,

drivers/scsi/qla2xxx/qla_target.c

4294

vha->vp_idx, cmd->se_cmd.tag, op, status,

drivers/scsi/qla2xxx/qla_target.c

4302

vha->vp_idx, cmd->se_cmd.tag, op, status,

drivers/scsi/qla2xxx/qla_target.c

4328

vha->vp_idx, cmd->se_cmd.tag,

drivers/scsi/qla2xxx/qla_target.c

4353

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

4358

vha->vp_idx, cmd->se_cmd.tag, cmd->state);

drivers/scsi/qla2xxx/qla_target.c

4426

cmd->se_cmd.tag = le32_to_cpu(atio->u.isp24.exchange_addr);

drivers/scsi/qla2xxx/qla_target.c

4589

cmd->se_cmd.cpuid = h->cpuid;

drivers/scsi/qla2xxx/qla_target.c

4736

queue_work_on(cmd->se_cmd.cpuid, qla_tgt_wq, &cmd->work);

drivers/scsi/qla2xxx/qla_target.c

4741

queue_work_on(cmd->se_cmd.cpuid, qla_tgt_wq,

drivers/scsi/qla2xxx/qla_target.c

4780

mcmd->se_cmd.cpuid = h->cpuid;

drivers/scsi/qla2xxx/qla_target.c

4792

mcmd->se_cmd.cpuid = h->cpuid;

drivers/scsi/qla2xxx/qla_target.c

4805

queue_work_on(mcmd->se_cmd.cpuid, qla_tgt_wq,

drivers/scsi/qla2xxx/qla_target.c

5361

vha->vp_idx, cmd->se_cmd.tag,

drivers/scsi/qla2xxx/qla_target.c

5443

vha->vp_idx, cmd->se_cmd.tag, cmd->cdb ? cmd->cdb[0] : 0);

drivers/scsi/qla2xxx/qla_target.c

5456

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

5477

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

5497

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

5512

vha->vp_idx, cmd->se_cmd.tag, cmd->state);

drivers/scsi/qla2xxx/qla_target.c

5521

vha->vp_idx, cmd->se_cmd.tag, cmd->state);

drivers/scsi/qla2xxx/qla_target.c

5592

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/qla2xxx/qla_target.c

5601

if (se_cmd->t_data_sg == NULL ||

drivers/scsi/qla2xxx/qla_target.c

5602

se_cmd->t_data_nents == 0 ||

drivers/scsi/qla2xxx/qla_target.c

5603

se_cmd->data_length == 0) {

drivers/scsi/qla2xxx/qla_target.c

5607

vha->vp_idx, cmd->se_cmd.tag, cmd->offset);

drivers/scsi/qla2xxx/qla_target.c

5614

vha->vp_idx, cmd->se_cmd.tag, cmd->offset);

drivers/scsi/qla2xxx/qla_target.c

5620

cmd->sg = se_cmd->t_data_sg;

drivers/scsi/qla2xxx/qla_target.c

5621

cmd->sg_cnt = se_cmd->t_data_nents;

drivers/scsi/qla2xxx/qla_target.c

5622

cmd->bufflen = se_cmd->data_length;

drivers/scsi/qla2xxx/qla_target.c

5647

vha->vp_idx, cmd->se_cmd.tag, __func__, cmd->sg,

drivers/scsi/qla2xxx/qla_target.c

5651

if (cmd->se_cmd.prot_op != TARGET_PROT_NORMAL) {

drivers/scsi/qla2xxx/qla_target.c

5654

vha->vp_idx, cmd->se_cmd.tag, __func__);

drivers/scsi/qla2xxx/qla_target.c

5661

vha->vp_idx, cmd->se_cmd.tag, __func__);

drivers/scsi/qla2xxx/qla_target.c

5683

vha->vp_idx, cmd->se_cmd.tag, offset);

drivers/scsi/qla2xxx/qla_target.c

5689

vha->vp_idx, cmd->se_cmd.tag, i, cmd->sg_cnt,

drivers/scsi/qla2xxx/qla_target.c

5714

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

5767

vha->vp_idx, cmd->se_cmd.tag, __func__, cmd->bufflen, bufflen);

drivers/scsi/qla2xxx/qla_target.c

5794

vha->vp_idx, cmd->se_cmd.tag, srr_rel_offs,

drivers/scsi/qla2xxx/qla_target.c

5815

vha->vp_idx, cmd->se_cmd.tag, cmd->offset,

drivers/scsi/qla2xxx/qla_target.c

5837

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/qla2xxx/qla_target.c

5861

vha->vp_idx, cmd->se_cmd.tag);

drivers/scsi/qla2xxx/qla_target.c

5894

vha->vp_idx, se_cmd->tag, op,

drivers/scsi/qla2xxx/qla_target.c

5902

vha->vp_idx, se_cmd->tag, op);

drivers/scsi/qla2xxx/qla_target.c

5908

vha->vp_idx, se_cmd->tag, op,

drivers/scsi/qla2xxx/qla_target.c

5909

se_cmd->scsi_status);

drivers/scsi/qla2xxx/qla_target.c

5918

vha->vp_idx, se_cmd->tag, op, cmd->bufflen,

drivers/scsi/qla2xxx/qla_target.c

5920

se_cmd->scsi_status);

drivers/scsi/qla2xxx/qla_target.c

5925

vha->vp_idx, se_cmd->tag, cmd->state);

drivers/scsi/qla2xxx/qla_target.c

5935

vha->vp_idx, se_cmd->tag);

drivers/scsi/qla2xxx/qla_target.c

5942

vha->vp_idx, se_cmd->tag);

drivers/scsi/qla2xxx/qla_target.c

5949

vha->vp_idx, se_cmd->tag, op);

drivers/scsi/qla2xxx/qla_target.c

5958

vha->vp_idx, se_cmd->tag, cmd->bufflen,

drivers/scsi/qla2xxx/qla_target.c

5967

vha->vp_idx, se_cmd->tag, op, cmd->bufflen,

drivers/scsi/qla2xxx/qla_target.c

5973

vha->vp_idx, se_cmd->tag, cmd->state);

drivers/scsi/qla2xxx/qla_target.c

5983

vha->vp_idx, se_cmd->tag);

drivers/scsi/qla2xxx/qla_target.c

5990

vha->vp_idx, se_cmd->tag, op);

drivers/scsi/qla2xxx/qla_target.c

6000

vha->vp_idx, se_cmd->tag);

drivers/scsi/qla2xxx/qla_target.c

6006

vha->vp_idx, se_cmd->tag, cmd->bufflen,

drivers/scsi/qla2xxx/qla_target.c

6015

vha->vp_idx, se_cmd->tag, op, srr_ui, cmd->state,

drivers/scsi/qla2xxx/qla_target.c

6027

if (qlt_xmit_response(cmd, xmit_type, se_cmd->scsi_status)) {

drivers/scsi/qla2xxx/qla_target.h

882

struct se_cmd se_cmd;

drivers/scsi/qla2xxx/qla_target.h

997

struct se_cmd se_cmd;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

240

transport_generic_free_cmd(&mcmd->se_cmd, 0);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

274

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

289

cmd->se_cmd.map_tag = tag;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

290

cmd->se_cmd.map_cpu = cpu;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

297

return target_get_sess_cmd(&cmd->se_cmd, true);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

302

target_put_sess_cmd(&cmd->se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

307

target_free_tag(cmd->sess->se_sess, &cmd->se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

332

static int tcm_qla2xxx_check_stop_free(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

336

if ((se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) == 0) {

drivers/scsi/qla2xxx/tcm_qla2xxx.c

337

cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

341

return target_put_sess_cmd(se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

347

static void tcm_qla2xxx_release_cmd(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

351

if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) {

drivers/scsi/qla2xxx/tcm_qla2xxx.c

352

struct qla_tgt_mgmt_cmd *mcmd = container_of(se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

353

struct qla_tgt_mgmt_cmd, se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

357

cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

393

static int tcm_qla2xxx_write_pending(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

395

struct qla_tgt_cmd *cmd = container_of(se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

396

struct qla_tgt_cmd, se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

405

cmd, kref_read(&cmd->se_cmd.cmd_kref),

drivers/scsi/qla2xxx/tcm_qla2xxx.c

406

cmd->se_cmd.transport_state,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

407

cmd->se_cmd.t_state,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

408

cmd->se_cmd.se_cmd_flags);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

409

transport_generic_request_failure(&cmd->se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

414

cmd->bufflen = se_cmd->data_length;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

415

cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

417

cmd->sg_cnt = se_cmd->t_data_nents;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

418

cmd->sg = se_cmd->t_data_sg;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

420

cmd->prot_sg_cnt = se_cmd->t_prot_nents;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

421

cmd->prot_sg = se_cmd->t_prot_sg;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

422

cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

423

se_cmd->pi_err = 0;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

432

static int tcm_qla2xxx_get_cmd_state(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

434

if (!(se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) {

drivers/scsi/qla2xxx/tcm_qla2xxx.c

435

struct qla_tgt_cmd *cmd = container_of(se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

436

struct qla_tgt_cmd, se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

450

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

463

if (se_cmd->cpuid != WORK_CPU_UNBOUND)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

492

rc = target_init_cmd(se_cmd, se_sess, &cmd->sense_buffer[0],

drivers/scsi/qla2xxx/tcm_qla2xxx.c

498

if (target_submit_prep(se_cmd, cdb, NULL, 0, NULL, 0, NULL, 0,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

502

target_submit(se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

517

transport_generic_request_failure(&cmd->se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

526

cmd->se_cmd.pi_err =

drivers/scsi/qla2xxx/tcm_qla2xxx.c

530

cmd->se_cmd.pi_err =

drivers/scsi/qla2xxx/tcm_qla2xxx.c

534

cmd->se_cmd.pi_err =

drivers/scsi/qla2xxx/tcm_qla2xxx.c

542

if (cmd->se_cmd.pi_err)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

543

transport_generic_request_failure(&cmd->se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

544

cmd->se_cmd.pi_err);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

546

transport_generic_request_failure(&cmd->se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

549

transport_generic_request_failure(&cmd->se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

555

return target_execute_cmd(&cmd->se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

577

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

579

if (!(se_cmd->prot_checks & TARGET_DIF_CHECK_GUARD))

drivers/scsi/qla2xxx/tcm_qla2xxx.c

582

if (!(se_cmd->prot_checks & TARGET_DIF_CHECK_APPTAG))

drivers/scsi/qla2xxx/tcm_qla2xxx.c

595

struct se_cmd *se_cmd = &mcmd->se_cmd;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

633

return target_submit_tmr(se_cmd, sess->se_sess, NULL, lun, mcmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

648

if (cmd->se_cmd.tag == tag)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

658

static int tcm_qla2xxx_queue_data_in(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

660

struct qla_tgt_cmd *cmd = container_of(se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

661

struct qla_tgt_cmd, se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

670

cmd, kref_read(&cmd->se_cmd.cmd_kref),

drivers/scsi/qla2xxx/tcm_qla2xxx.c

671

cmd->se_cmd.transport_state,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

672

cmd->se_cmd.t_state,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

673

cmd->se_cmd.se_cmd_flags);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

678

cmd->bufflen = se_cmd->data_length;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

679

cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

681

cmd->sg_cnt = se_cmd->t_data_nents;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

682

cmd->sg = se_cmd->t_data_sg;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

685

cmd->prot_sg_cnt = se_cmd->t_prot_nents;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

686

cmd->prot_sg = se_cmd->t_prot_sg;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

687

cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

688

se_cmd->pi_err = 0;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

694

se_cmd->scsi_status);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

697

static int tcm_qla2xxx_queue_status(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

699

struct qla_tgt_cmd *cmd = container_of(se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

700

struct qla_tgt_cmd, se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

711

cmd, kref_read(&cmd->se_cmd.cmd_kref),

drivers/scsi/qla2xxx/tcm_qla2xxx.c

712

cmd->se_cmd.transport_state, cmd->se_cmd.t_state,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

713

cmd->se_cmd.se_cmd_flags);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

716

cmd->bufflen = se_cmd->data_length;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

720

cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

723

if (se_cmd->data_direction == DMA_FROM_DEVICE) {

drivers/scsi/qla2xxx/tcm_qla2xxx.c

728

if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {

drivers/scsi/qla2xxx/tcm_qla2xxx.c

729

se_cmd->se_cmd_flags &= ~SCF_OVERFLOW_BIT;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

730

se_cmd->residual_count = 0;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

732

se_cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

733

se_cmd->residual_count += se_cmd->data_length;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

740

return qlt_xmit_response(cmd, xmit_type, se_cmd->scsi_status);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

743

static void tcm_qla2xxx_queue_tm_rsp(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

745

struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;

drivers/scsi/qla2xxx/tcm_qla2xxx.c

746

struct qla_tgt_mgmt_cmd *mcmd = container_of(se_cmd,

drivers/scsi/qla2xxx/tcm_qla2xxx.c

747

struct qla_tgt_mgmt_cmd, se_cmd);

drivers/scsi/qla2xxx/tcm_qla2xxx.c

777

static void tcm_qla2xxx_aborted_task(struct se_cmd *se_cmd)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

782

if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)

drivers/scsi/qla2xxx/tcm_qla2xxx.c

785

cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

245

ttinfo->sgl = cmd->se_cmd.t_data_sg;

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

246

ttinfo->nents = cmd->se_cmd.t_data_nents;

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

248

ret = cxgbit_ddp_reserve(csk, ttinfo, cmd->se_cmd.data_length);

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

251

csk, cmd, cmd->se_cmd.data_length, ttinfo->nents);

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

268

if (cmd->se_cmd.se_cmd_flags & SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC) {

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

281

cmd->se_cmd.data_length))

drivers/target/iscsi/cxgbit/cxgbit_target.c

1052

cmd->se_cmd.data_length);

drivers/target/iscsi/cxgbit/cxgbit_target.c

1058

sg_start = &cmd->se_cmd.t_data_sg[sg_off];

drivers/target/iscsi/cxgbit/cxgbit_target.c

1068

(cmd->se_cmd.data_length == (cmd->write_data_done + data_len))) {

drivers/target/iscsi/cxgbit/cxgbit_target.c

355

sg = &cmd->se_cmd.t_data_sg[data_offset / PAGE_SIZE];

drivers/target/iscsi/cxgbit/cxgbit_target.c

400

u32 data_length = cmd->se_cmd.data_length;

drivers/target/iscsi/cxgbit/cxgbit_target.c

403

bool task_sense = !!(cmd->se_cmd.se_cmd_flags &

drivers/target/iscsi/cxgbit/cxgbit_target.c

518

u32 data_length = cmd->se_cmd.data_length;

drivers/target/iscsi/cxgbit/cxgbit_target.c

879

if (cmd->se_cmd.se_cmd_flags & SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC) {

drivers/target/iscsi/cxgbit/cxgbit_target.c

889

cmd->se_cmd.t_data_sg = &ccmd->sg;

drivers/target/iscsi/cxgbit/cxgbit_target.c

890

cmd->se_cmd.t_data_nents = 1;

drivers/target/iscsi/cxgbit/cxgbit_target.c

894

struct scatterlist *sg = &cmd->se_cmd.t_data_sg[0];

drivers/target/iscsi/cxgbit/cxgbit_target.c

902

if (cmd->write_data_done == cmd->se_cmd.data_length) {

drivers/target/iscsi/cxgbit/cxgbit_target.c

940

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/iscsi/cxgbit/cxgbit_target.c

979

if (pdu_cb->dlen && (pdu_cb->dlen == cmd->se_cmd.data_length) &&

drivers/target/iscsi/cxgbit/cxgbit_target.c

981

cmd->se_cmd.se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC;

drivers/target/iscsi/iscsi_target.c

1181

__target_init_cmd(&cmd->se_cmd, &iscsi_ops,

drivers/target/iscsi/iscsi_target.c

1192

target_get_sess_cmd(&cmd->se_cmd, true);

drivers/target/iscsi/iscsi_target.c

1194

cmd->se_cmd.tag = (__force u32)cmd->init_task_tag;

drivers/target/iscsi/iscsi_target.c

1195

cmd->sense_reason = target_cmd_init_cdb(&cmd->se_cmd, cdb,

drivers/target/iscsi/iscsi_target.c

1210

cmd->sense_reason = transport_lookup_cmd_lun(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

1214

cmd->sense_reason = target_cmd_parse_cdb(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

1261

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

1277

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

1292

cmd->sense_reason = transport_generic_new_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

1311

u32 length = min(cmd->se_cmd.data_length - cmd->write_data_done,

drivers/target/iscsi/iscsi_target.c

1315

cmd->se_cmd.data_length, cmd->write_data_done,

drivers/target/iscsi/iscsi_target.c

1338

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

1444

struct se_cmd *se_cmd;

drivers/target/iscsi/iscsi_target.c

1467

se_cmd = &cmd->se_cmd;

drivers/target/iscsi/iscsi_target.c

1470

if ((be32_to_cpu(hdr->offset) + payload_length) > cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target.c

1473

cmd->se_cmd.data_length);

drivers/target/iscsi/iscsi_target.c

1483

transport_send_check_condition_and_sense(&cmd->se_cmd,

drivers/target/iscsi/iscsi_target.c

1494

WARN_ON(se_cmd->t_state != TRANSPORT_WRITE_PENDING);

drivers/target/iscsi/iscsi_target.c

1495

if (!(se_cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE))

drivers/target/iscsi/iscsi_target.c

1520

if (se_cmd->transport_state & CMD_T_ABORTED) {

drivers/target/iscsi/iscsi_target.c

1586

payload_length = min_t(u32, cmd->se_cmd.data_length,

drivers/target/iscsi/iscsi_target.c

1672

target_execute_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

2002

__target_init_cmd(&cmd->se_cmd, &iscsi_ops,

drivers/target/iscsi/iscsi_target.c

2008

target_get_sess_cmd(&cmd->se_cmd, true);

drivers/target/iscsi/iscsi_target.c

2023

ret = core_tmr_alloc_req(&cmd->se_cmd, cmd->tmr_req, tcm_function,

drivers/target/iscsi/iscsi_target.c

2029

cmd->tmr_req->se_tmr_req = cmd->se_cmd.se_tmr_req;

drivers/target/iscsi/iscsi_target.c

2038

se_tmr = cmd->se_cmd.se_tmr_req;

drivers/target/iscsi/iscsi_target.c

2044

ret = transport_lookup_tmr_lun(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

2107

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

2121

return transport_generic_handle_tmr(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

2132

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

2588

BUG_ON(cmd->write_data_done > cmd->se_cmd.data_length);

drivers/target/iscsi/iscsi_target.c

2589

rx_size = min(cmd->se_cmd.data_length - cmd->write_data_done, length);

drivers/target/iscsi/iscsi_target.c

2671

if (cmd->write_data_done == cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target.c

2772

if (cmd->se_cmd.se_cmd_flags & SCF_OVERFLOW_BIT) {

drivers/target/iscsi/iscsi_target.c

2774

hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);

drivers/target/iscsi/iscsi_target.c

2775

} else if (cmd->se_cmd.se_cmd_flags & SCF_UNDERFLOW_BIT) {

drivers/target/iscsi/iscsi_target.c

2777

hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);

drivers/target/iscsi/iscsi_target.c

2782

int_to_scsilun(cmd->se_cmd.orig_fe_lun,

drivers/target/iscsi/iscsi_target.c

2828

if ((datain.offset + datain.length) > cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target.c

2832

cmd->se_cmd.data_length);

drivers/target/iscsi/iscsi_target.c

2842

(cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE))

drivers/target/iscsi/iscsi_target.c

2862

eodr = (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ?

drivers/target/iscsi/iscsi_target.c

3068

int_to_scsilun(cmd->se_cmd.orig_fe_lun,

drivers/target/iscsi/iscsi_target.c

3136

if (new_data_end > cmd->se_cmd.data_length)

drivers/target/iscsi/iscsi_target.c

3137

xfer_len = cmd->se_cmd.data_length - offset;

drivers/target/iscsi/iscsi_target.c

3146

if (new_data_end > cmd->se_cmd.data_length)

drivers/target/iscsi/iscsi_target.c

3147

xfer_len = cmd->se_cmd.data_length - offset;

drivers/target/iscsi/iscsi_target.c

3159

if (cmd->r2t_offset == cmd->se_cmd.data_length)

drivers/target/iscsi/iscsi_target.c

3204

if (cmd->se_cmd.se_cmd_flags & SCF_OVERFLOW_BIT) {

drivers/target/iscsi/iscsi_target.c

3206

hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);

drivers/target/iscsi/iscsi_target.c

3207

} else if (cmd->se_cmd.se_cmd_flags & SCF_UNDERFLOW_BIT) {

drivers/target/iscsi/iscsi_target.c

3209

hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);

drivers/target/iscsi/iscsi_target.c

3212

hdr->cmd_status = cmd->se_cmd.scsi_status;

drivers/target/iscsi/iscsi_target.c

3222

cmd->init_task_tag, cmd->stat_sn, cmd->se_cmd.scsi_status,

drivers/target/iscsi/iscsi_target.c

3223

cmd->se_cmd.scsi_status, conn->cid);

drivers/target/iscsi/iscsi_target.c

3239

if (cmd->se_cmd.sense_buffer &&

drivers/target/iscsi/iscsi_target.c

3240

((cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||

drivers/target/iscsi/iscsi_target.c

3241

(cmd->se_cmd.se_cmd_flags & SCF_EMULATED_TASK_SENSE))) {

drivers/target/iscsi/iscsi_target.c

3242

put_unaligned_be16(cmd->se_cmd.scsi_sense_length, cmd->sense_buffer);

drivers/target/iscsi/iscsi_target.c

3243

cmd->se_cmd.scsi_sense_length += sizeof (__be16);

drivers/target/iscsi/iscsi_target.c

3245

padding = -(cmd->se_cmd.scsi_sense_length) & 3;

drivers/target/iscsi/iscsi_target.c

3246

hton24(hdr->dlength, (u32)cmd->se_cmd.scsi_sense_length);

drivers/target/iscsi/iscsi_target.c

3248

data_buf_len = cmd->se_cmd.scsi_sense_length + padding;

drivers/target/iscsi/iscsi_target.c

3252

cmd->se_cmd.scsi_sense_length, 0, padding);

drivers/target/iscsi/iscsi_target.c

3259

cmd->se_cmd.scsi_sense_length);

drivers/target/iscsi/iscsi_target.c

3287

struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;

drivers/target/iscsi/iscsi_target.c

4160

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/target/iscsi/iscsi_target.c

4162

if (!se_cmd->se_tfo)

drivers/target/iscsi/iscsi_target.c

4165

spin_lock_irq(&se_cmd->t_state_lock);

drivers/target/iscsi/iscsi_target.c

4166

if (se_cmd->transport_state & CMD_T_ABORTED) {

drivers/target/iscsi/iscsi_target.c

4167

if (!(se_cmd->transport_state & CMD_T_TAS))

drivers/target/iscsi/iscsi_target.c

4176

se_cmd->transport_state |= CMD_T_FABRIC_STOP;

drivers/target/iscsi/iscsi_target.c

4179

if (cmd->se_cmd.t_state == TRANSPORT_WRITE_PENDING) {

drivers/target/iscsi/iscsi_target.c

4184

spin_unlock_irq(&se_cmd->t_state_lock);

drivers/target/iscsi/iscsi_target.c

4185

target_complete_cmd(&cmd->se_cmd, SAM_STAT_TASK_ABORTED);

drivers/target/iscsi/iscsi_target.c

4188

spin_unlock_irq(&se_cmd->t_state_lock);

drivers/target/iscsi/iscsi_target.c

826

const bool do_put = cmd->se_cmd.se_tfo != NULL;

drivers/target/iscsi/iscsi_target.c

859

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target.c

895

if (ent >= cmd->se_cmd.t_data_nents) {

drivers/target/iscsi/iscsi_target.c

900

sg = &cmd->se_cmd.t_data_sg[ent];

drivers/target/iscsi/iscsi_target.c

930

for_each_sg(cmd->se_cmd.t_data_sg, sg,

drivers/target/iscsi/iscsi_target.c

931

cmd->se_cmd.t_data_nents, i) {

drivers/target/iscsi/iscsi_target.c

981

u32 iov_count = max(1UL, DIV_ROUND_UP(cmd->se_cmd.data_length, PAGE_SIZE));

drivers/target/iscsi/iscsi_target_configfs.c

1359

static int iscsi_get_cmd_state(struct se_cmd *se_cmd)

drivers/target/iscsi/iscsi_target_configfs.c

1361

struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);

drivers/target/iscsi/iscsi_target_configfs.c

1385

static int lio_queue_data_in(struct se_cmd *se_cmd)

drivers/target/iscsi/iscsi_target_configfs.c

1387

struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);

drivers/target/iscsi/iscsi_target_configfs.c

1394

static int lio_write_pending(struct se_cmd *se_cmd)

drivers/target/iscsi/iscsi_target_configfs.c

1396

struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);

drivers/target/iscsi/iscsi_target_configfs.c

1405

static int lio_queue_status(struct se_cmd *se_cmd)

drivers/target/iscsi/iscsi_target_configfs.c

1407

struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);

drivers/target/iscsi/iscsi_target_configfs.c

1412

if (cmd->se_cmd.scsi_status || cmd->sense_reason) {

drivers/target/iscsi/iscsi_target_configfs.c

1418

static void lio_queue_tm_rsp(struct se_cmd *se_cmd)

drivers/target/iscsi/iscsi_target_configfs.c

1420

struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);

drivers/target/iscsi/iscsi_target_configfs.c

1426

static void lio_aborted_task(struct se_cmd *se_cmd)

drivers/target/iscsi/iscsi_target_configfs.c

1428

struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);

drivers/target/iscsi/iscsi_target_configfs.c

1529

static int lio_check_stop_free(struct se_cmd *se_cmd)

drivers/target/iscsi/iscsi_target_configfs.c

1531

return target_put_sess_cmd(se_cmd);

drivers/target/iscsi/iscsi_target_configfs.c

1534

static void lio_release_cmd(struct se_cmd *se_cmd)

drivers/target/iscsi/iscsi_target_configfs.c

1536

struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);

drivers/target/iscsi/iscsi_target_configfs.c

1538

pr_debug("Entering lio_release_cmd for se_cmd: %p\n", se_cmd);

drivers/target/iscsi/iscsi_target_datain_values.c

103

read_data_left = (cmd->se_cmd.data_length - read_data_done);

drivers/target/iscsi/iscsi_target_datain_values.c

202

read_data_left = (cmd->se_cmd.data_length - read_data_done);

drivers/target/iscsi/iscsi_target_datain_values.c

221

cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_datain_values.c

222

datain->length = (cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_datain_values.c

254

if ((read_data_done + datain->length) == cmd->se_cmd.data_length)

drivers/target/iscsi/iscsi_target_datain_values.c

323

read_data_left = (cmd->se_cmd.data_length - read_data_done);

drivers/target/iscsi/iscsi_target_datain_values.c

334

if ((read_data_done + pdu->length) == cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_datain_values.c

423

read_data_left = (cmd->se_cmd.data_length - read_data_done);

drivers/target/iscsi/iscsi_target_datain_values.c

453

if ((read_data_done + pdu->length) == cmd->se_cmd.data_length)

drivers/target/iscsi/iscsi_target_erl0.c

157

transport_send_check_condition_and_sense(&cmd->se_cmd,

drivers/target/iscsi/iscsi_target_erl0.c

175

if ((first_burst_len != cmd->se_cmd.data_length) &&

drivers/target/iscsi/iscsi_target_erl0.c

181

cmd->se_cmd.data_length);

drivers/target/iscsi/iscsi_target_erl0.c

182

transport_send_check_condition_and_sense(&cmd->se_cmd,

drivers/target/iscsi/iscsi_target_erl0.c

194

if (first_burst_len == cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_erl0.c

197

" error.\n", cmd->init_task_tag, cmd->se_cmd.data_length);

drivers/target/iscsi/iscsi_target_erl0.c

288

cmd->se_cmd.data_length)) {

drivers/target/iscsi/iscsi_target_erl0.c

313

cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_erl0.c

41

cmd->seq_end_offset = min(cmd->se_cmd.data_length,

drivers/target/iscsi/iscsi_target_erl0.c

51

cmd->seq_end_offset = (cmd->se_cmd.data_length >

drivers/target/iscsi/iscsi_target_erl0.c

54

conn->sess->sess_ops->MaxBurstLength) : cmd->se_cmd.data_length;

drivers/target/iscsi/iscsi_target_erl0.c

59

cmd->se_cmd.data_length) ? cmd->se_cmd.data_length :

drivers/target/iscsi/iscsi_target_erl0.c

635

if (cmd->write_data_done == cmd->se_cmd.data_length)

drivers/target/iscsi/iscsi_target_erl1.c

1061

cmd->se_cmd.data_length) ?

drivers/target/iscsi/iscsi_target_erl1.c

1062

cmd->se_cmd.data_length :

drivers/target/iscsi/iscsi_target_erl1.c

1139

cmd->next_burst_len)) > cmd->se_cmd.data_length)

drivers/target/iscsi/iscsi_target_erl1.c

1140

pdu_length = (cmd->se_cmd.data_length -

drivers/target/iscsi/iscsi_target_erl1.c

381

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/target/iscsi/iscsi_target_erl1.c

383

if (!(se_cmd->transport_state & CMD_T_COMPLETE)) {

drivers/target/iscsi/iscsi_target_erl1.c

888

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/target/iscsi/iscsi_target_erl1.c

911

if (cmd->se_cmd.transport_state & CMD_T_ABORTED)

drivers/target/iscsi/iscsi_target_erl1.c

913

return transport_send_check_condition_and_sense(se_cmd,

drivers/target/iscsi/iscsi_target_erl1.c

923

target_execute_cmd(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target_erl1.c

930

if (cmd->se_cmd.transport_state & CMD_T_ABORTED)

drivers/target/iscsi/iscsi_target_erl1.c

945

if (cmd->se_cmd.transport_state & CMD_T_ABORTED)

drivers/target/iscsi/iscsi_target_erl1.c

950

return target_submit(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target_erl1.c

958

if (cmd->se_cmd.se_tmr_req->response) {

drivers/target/iscsi/iscsi_target_erl1.c

966

return transport_generic_handle_tmr(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target_erl2.c

346

transport_wait_for_tasks(&cmd->se_cmd);

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

213

if (cmd->se_cmd.data_direction == DMA_TO_DEVICE)

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

224

unsolicited_data_length = min(cmd->se_cmd.data_length,

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

227

while (offset < cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

240

if ((offset + mdsl) >= cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

242

(cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

243

offset += (cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

262

if ((offset + mdsl) >= cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

263

offset += (cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

296

if (cmd->se_cmd.data_direction == DMA_TO_DEVICE)

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

310

unsolicited_data_length = min(cmd->se_cmd.data_length,

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

313

while (offset < cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

347

if ((offset + mdsl) >= cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

351

(cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

357

(cmd->se_cmd.data_length - offset));

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

360

(cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

361

offset += (cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

399

if ((offset + mdsl) >= cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

402

pdu[i].length = (cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

408

(cmd->se_cmd.data_length - offset));

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

410

offset += (cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_tmr.c

113

struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;

drivers/target/iscsi/iscsi_target_tmr.c

158

if (ref_lun != ref_cmd->se_cmd.orig_fe_lun) {

drivers/target/iscsi/iscsi_target_tmr.c

161

ref_lun, ref_cmd->se_cmd.orig_fe_lun);

drivers/target/iscsi/iscsi_target_tmr.c

234

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/target/iscsi/iscsi_target_tmr.c

253

if (!(cmd->se_cmd.transport_state & CMD_T_SENT)) {

drivers/target/iscsi/iscsi_target_tmr.c

256

cmd->init_task_tag, cmd->se_cmd.t_state);

drivers/target/iscsi/iscsi_target_tmr.c

257

target_execute_cmd(se_cmd);

drivers/target/iscsi/iscsi_target_tmr.c

276

cmd->se_cmd.data_length) {

drivers/target/iscsi/iscsi_target_tmr.c

278

length = (cmd->se_cmd.data_length - offset);

drivers/target/iscsi/iscsi_target_tmr.c

305

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/target/iscsi/iscsi_target_tmr.c

318

if (!(cmd->se_cmd.transport_state & CMD_T_SENT)) {

drivers/target/iscsi/iscsi_target_tmr.c

321

cmd->se_cmd.t_state);

drivers/target/iscsi/iscsi_target_tmr.c

322

target_submit(se_cmd);

drivers/target/iscsi/iscsi_target_tmr.c

326

if (!(se_cmd->transport_state & CMD_T_COMPLETE)) {

drivers/target/iscsi/iscsi_target_tmr.c

329

cmd->se_cmd.t_state);

drivers/target/iscsi/iscsi_target_tmr.c

37

struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;

drivers/target/iscsi/iscsi_target_tmr.c

390

if (cmd->se_cmd.se_cmd_flags & SCF_SENT_CHECK_CONDITION) {

drivers/target/iscsi/iscsi_target_tmr.c

458

struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;

drivers/target/iscsi/iscsi_target_tmr.c

788

if (ref_cmd->se_cmd.se_cmd_flags & SCF_SENT_CHECK_CONDITION)

drivers/target/iscsi/iscsi_target_util.c

171

cmd->se_cmd.map_tag = tag;

drivers/target/iscsi/iscsi_target_util.c

172

cmd->se_cmd.map_cpu = cpu;

drivers/target/iscsi/iscsi_target_util.c

656

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/target/iscsi/iscsi_target_util.c

675

target_free_tag(sess->se_sess, se_cmd);

drivers/target/iscsi/iscsi_target_util.c

703

struct se_cmd *se_cmd = cmd->se_cmd.se_tfo ? &cmd->se_cmd : NULL;

drivers/target/iscsi/iscsi_target_util.c

709

if (se_cmd) {

drivers/target/iscsi/iscsi_target_util.c

710

rc = transport_generic_free_cmd(se_cmd, shutdown);

drivers/target/iscsi/iscsi_target_util.c

711

if (!rc && shutdown && se_cmd->se_sess) {

drivers/target/iscsi/iscsi_target_util.c

713

target_put_sess_cmd(se_cmd);

drivers/target/loopback/tcm_loop.c

104

struct se_cmd *se_cmd = &tl_cmd->tl_se_cmd;

drivers/target/loopback/tcm_loop.c

138

se_cmd->prot_pto = true;

drivers/target/loopback/tcm_loop.c

147

se_cmd->tag = tl_cmd->sc_cmd_tag;

drivers/target/loopback/tcm_loop.c

148

target_init_cmd(se_cmd, tl_nexus->se_sess, &tl_cmd->tl_sense_buf[0],

drivers/target/loopback/tcm_loop.c

152

if (target_submit_prep(se_cmd, sc->cmnd, scsi_sglist(sc),

drivers/target/loopback/tcm_loop.c

158

target_submit(se_cmd);

drivers/target/loopback/tcm_loop.c

194

struct se_cmd *se_cmd;

drivers/target/loopback/tcm_loop.c

215

se_cmd = &tl_cmd->tl_se_cmd;

drivers/target/loopback/tcm_loop.c

218

rc = target_submit_tmr(se_cmd, se_sess, tl_cmd->tl_sense_buf, lun,

drivers/target/loopback/tcm_loop.c

224

ret = se_cmd->se_tmr_req->response;

drivers/target/loopback/tcm_loop.c

225

target_put_sess_cmd(se_cmd);

drivers/target/loopback/tcm_loop.c

277

struct se_cmd *se_cmd = &tl_cmd->tl_se_cmd;

drivers/target/loopback/tcm_loop.c

279

flush_work(&se_cmd->work);

drivers/target/loopback/tcm_loop.c

47

static int tcm_loop_queue_status(struct se_cmd *se_cmd);

drivers/target/loopback/tcm_loop.c

530

static int tcm_loop_get_cmd_state(struct se_cmd *se_cmd)

drivers/target/loopback/tcm_loop.c

532

struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,

drivers/target/loopback/tcm_loop.c

538

static int tcm_loop_write_pending(struct se_cmd *se_cmd)

drivers/target/loopback/tcm_loop.c

549

target_execute_cmd(se_cmd);

drivers/target/loopback/tcm_loop.c

554

struct se_cmd *se_cmd, u8 scsi_status)

drivers/target/loopback/tcm_loop.c

556

struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,

drivers/target/loopback/tcm_loop.c

563

if (se_cmd->sense_buffer &&

drivers/target/loopback/tcm_loop.c

564

((se_cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||

drivers/target/loopback/tcm_loop.c

565

(se_cmd->se_cmd_flags & SCF_EMULATED_TASK_SENSE))) {

drivers/target/loopback/tcm_loop.c

567

memcpy(sc->sense_buffer, se_cmd->sense_buffer,

drivers/target/loopback/tcm_loop.c

574

if ((se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) ||

drivers/target/loopback/tcm_loop.c

575

(se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT))

drivers/target/loopback/tcm_loop.c

576

scsi_set_resid(sc, se_cmd->residual_count);

drivers/target/loopback/tcm_loop.c

580

static int tcm_loop_queue_data_in(struct se_cmd *se_cmd)

drivers/target/loopback/tcm_loop.c

582

return tcm_loop_queue_data_or_status(__func__, se_cmd, SAM_STAT_GOOD);

drivers/target/loopback/tcm_loop.c

585

static int tcm_loop_queue_status(struct se_cmd *se_cmd)

drivers/target/loopback/tcm_loop.c

588

se_cmd, se_cmd->scsi_status);

drivers/target/loopback/tcm_loop.c

591

static void tcm_loop_queue_tm_rsp(struct se_cmd *se_cmd)

drivers/target/loopback/tcm_loop.c

593

struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,

drivers/target/loopback/tcm_loop.c

600

static void tcm_loop_aborted_task(struct se_cmd *se_cmd)

drivers/target/loopback/tcm_loop.c

61

static int tcm_loop_check_stop_free(struct se_cmd *se_cmd)

drivers/target/loopback/tcm_loop.c

63

return transport_generic_free_cmd(se_cmd, 0);

drivers/target/loopback/tcm_loop.c

66

static void tcm_loop_release_cmd(struct se_cmd *se_cmd)

drivers/target/loopback/tcm_loop.c

68

struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,

drivers/target/loopback/tcm_loop.c

72

if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)

drivers/target/loopback/tcm_loop.h

18

struct se_cmd tl_se_cmd;

drivers/target/sbp/sbp_target.c

1219

req->se_cmd.tag = req->orb_pointer;

drivers/target/sbp/sbp_target.c

1220

target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,

drivers/target/sbp/sbp_target.c

1249

if (req->se_cmd.data_direction == DMA_FROM_DEVICE) {

drivers/target/sbp/sbp_target.c

1282

length = req->se_cmd.data_length;

drivers/target/sbp/sbp_target.c

1285

sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents,

drivers/target/sbp/sbp_target.c

1350

target_put_sess_cmd(&req->se_cmd);

drivers/target/sbp/sbp_target.c

1356

struct se_cmd *se_cmd = &req->se_cmd;

drivers/target/sbp/sbp_target.c

1360

WARN_ON(se_cmd->scsi_sense_length < 18);

drivers/target/sbp/sbp_target.c

1386

status[0] |= se_cmd->scsi_status & 0x3f;/* status */

drivers/target/sbp/sbp_target.c

1423

struct se_cmd *se_cmd = &req->se_cmd;

drivers/target/sbp/sbp_target.c

1425

if (se_cmd->scsi_sense_length) {

drivers/target/sbp/sbp_target.c

1440

struct se_cmd *se_cmd = &req->se_cmd;

drivers/target/sbp/sbp_target.c

1441

struct se_session *se_sess = se_cmd->se_sess;

drivers/target/sbp/sbp_target.c

1446

target_free_tag(se_sess, se_cmd);

drivers/target/sbp/sbp_target.c

1689

static void sbp_release_cmd(struct se_cmd *se_cmd)

drivers/target/sbp/sbp_target.c

1691

struct sbp_target_request *req = container_of(se_cmd,

drivers/target/sbp/sbp_target.c

1692

struct sbp_target_request, se_cmd);

drivers/target/sbp/sbp_target.c

1697

static int sbp_write_pending(struct se_cmd *se_cmd)

drivers/target/sbp/sbp_target.c

1699

struct sbp_target_request *req = container_of(se_cmd,

drivers/target/sbp/sbp_target.c

1700

struct sbp_target_request, se_cmd);

drivers/target/sbp/sbp_target.c

1716

target_execute_cmd(se_cmd);

drivers/target/sbp/sbp_target.c

1720

static int sbp_queue_data_in(struct se_cmd *se_cmd)

drivers/target/sbp/sbp_target.c

1722

struct sbp_target_request *req = container_of(se_cmd,

drivers/target/sbp/sbp_target.c

1723

struct sbp_target_request, se_cmd);

drivers/target/sbp/sbp_target.c

1744

static int sbp_queue_status(struct se_cmd *se_cmd)

drivers/target/sbp/sbp_target.c

1746

struct sbp_target_request *req = container_of(se_cmd,

drivers/target/sbp/sbp_target.c

1747

struct sbp_target_request, se_cmd);

drivers/target/sbp/sbp_target.c

1752

static void sbp_queue_tm_rsp(struct se_cmd *se_cmd)

drivers/target/sbp/sbp_target.c

1756

static void sbp_aborted_task(struct se_cmd *se_cmd)

drivers/target/sbp/sbp_target.c

1761

static int sbp_check_stop_free(struct se_cmd *se_cmd)

drivers/target/sbp/sbp_target.c

1763

struct sbp_target_request *req = container_of(se_cmd,

drivers/target/sbp/sbp_target.c

1764

struct sbp_target_request, se_cmd);

drivers/target/sbp/sbp_target.c

1766

return transport_generic_free_cmd(&req->se_cmd, 0);

drivers/target/sbp/sbp_target.c

922

req->se_cmd.map_tag = tag;

drivers/target/sbp/sbp_target.c

923

req->se_cmd.map_cpu = cpu;

drivers/target/sbp/sbp_target.c

924

req->se_cmd.tag = next_orb;

drivers/target/sbp/sbp_target.h

217

struct se_cmd se_cmd;

drivers/target/target_core_alua.c

136

target_emulate_report_target_port_groups(struct se_cmd *cmd)

drivers/target/target_core_alua.c

271

target_emulate_set_target_port_groups(struct se_cmd *cmd)

drivers/target/target_core_alua.c

435

struct se_cmd *cmd,

drivers/target/target_core_alua.c

449

struct se_cmd *cmd,

drivers/target/target_core_alua.c

519

struct se_cmd *cmd,

drivers/target/target_core_alua.c

56

target_emulate_report_referrals(struct se_cmd *cmd)

drivers/target/target_core_alua.c

572

struct se_cmd *cmd,

drivers/target/target_core_alua.c

609

struct se_cmd *cmd,

drivers/target/target_core_alua.c

644

target_alua_state_check(struct se_cmd *cmd)

drivers/target/target_core_alua.c

836

struct se_cmd *cmd)

drivers/target/target_core_alua.h

149

extern sense_reason_t target_alua_state_check(struct se_cmd *cmd);

drivers/target/target_core_alua.h

85

extern sense_reason_t target_emulate_report_target_port_groups(struct se_cmd *);

drivers/target/target_core_alua.h

86

extern sense_reason_t target_emulate_set_target_port_groups(struct se_cmd *);

drivers/target/target_core_alua.h

87

extern sense_reason_t target_emulate_report_referrals(struct se_cmd *);

drivers/target/target_core_alua.h

88

extern int core_alua_check_nonop_delay(struct se_cmd *);

drivers/target/target_core_configfs.c

354

static int target_default_get_cmd_state(struct se_cmd *se_cmd)

drivers/target/target_core_device.c

101

se_cmd->se_tfo->fabric_name,

drivers/target/target_core_device.c

102

se_cmd->orig_fe_lun,

drivers/target/target_core_device.c

110

if ((se_cmd->data_direction != DMA_FROM_DEVICE) &&

drivers/target/target_core_device.c

111

(se_cmd->data_direction != DMA_NONE))

drivers/target/target_core_device.c

1127

passthrough_parse_cdb(struct se_cmd *cmd,

drivers/target/target_core_device.c

1128

sense_reason_t (*exec_cmd)(struct se_cmd *cmd))

drivers/target/target_core_device.c

118

se_cmd->se_lun = se_sess->se_tpg->tpg_virt_lun0;

drivers/target/target_core_device.c

119

se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;

drivers/target/target_core_device.c

120

se_cmd->lun_ref_active = true;

drivers/target/target_core_device.c

128

se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev);

drivers/target/target_core_device.c

129

this_cpu_inc(se_cmd->se_dev->stats->total_cmds);

drivers/target/target_core_device.c

131

if (se_cmd->data_direction == DMA_TO_DEVICE)

drivers/target/target_core_device.c

132

this_cpu_add(se_cmd->se_dev->stats->write_bytes,

drivers/target/target_core_device.c

133

se_cmd->data_length);

drivers/target/target_core_device.c

134

else if (se_cmd->data_direction == DMA_FROM_DEVICE)

drivers/target/target_core_device.c

135

this_cpu_add(se_cmd->se_dev->stats->read_bytes,

drivers/target/target_core_device.c

136

se_cmd->data_length);

drivers/target/target_core_device.c

142

int transport_lookup_tmr_lun(struct se_cmd *se_cmd)

drivers/target/target_core_device.c

146

struct se_session *se_sess = se_cmd->se_sess;

drivers/target/target_core_device.c

148

struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;

drivers/target/target_core_device.c

151

deve = target_nacl_find_deve(nacl, se_cmd->orig_fe_lun);

drivers/target/target_core_device.c

160

se_cmd->se_lun = se_lun;

drivers/target/target_core_device.c

161

se_cmd->pr_res_key = deve->pr_res_key;

drivers/target/target_core_device.c

162

se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;

drivers/target/target_core_device.c

163

se_cmd->lun_ref_active = true;

drivers/target/target_core_device.c

171

se_cmd->se_tfo->fabric_name,

drivers/target/target_core_device.c

172

se_cmd->orig_fe_lun,

drivers/target/target_core_device.c

176

se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev);

drivers/target/target_core_device.c

183

bool target_lun_is_rdonly(struct se_cmd *cmd)

drivers/target/target_core_device.c

47

transport_lookup_cmd_lun(struct se_cmd *se_cmd)

drivers/target/target_core_device.c

50

struct se_session *se_sess = se_cmd->se_sess;

drivers/target/target_core_device.c

56

deve = target_nacl_find_deve(nacl, se_cmd->orig_fe_lun);

drivers/target/target_core_device.c

60

if (se_cmd->data_direction == DMA_TO_DEVICE)

drivers/target/target_core_device.c

62

se_cmd->data_length);

drivers/target/target_core_device.c

63

else if (se_cmd->data_direction == DMA_FROM_DEVICE)

drivers/target/target_core_device.c

65

se_cmd->data_length);

drivers/target/target_core_device.c

67

if ((se_cmd->data_direction == DMA_TO_DEVICE) &&

drivers/target/target_core_device.c

71

se_cmd->se_tfo->fabric_name,

drivers/target/target_core_device.c

72

se_cmd->orig_fe_lun);

drivers/target/target_core_device.c

84

se_cmd->se_lun = se_lun;

drivers/target/target_core_device.c

85

se_cmd->pr_res_key = deve->pr_res_key;

drivers/target/target_core_device.c

86

se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;

drivers/target/target_core_device.c

87

se_cmd->lun_ref_active = true;

drivers/target/target_core_device.c

98

if (se_cmd->orig_fe_lun != 0) {

drivers/target/target_core_file.c

246

struct se_cmd *cmd;

drivers/target/target_core_file.c

266

fd_execute_rw_aio(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,

drivers/target/target_core_file.c

312

static int fd_do_rw(struct se_cmd *cmd, struct file *fd,

drivers/target/target_core_file.c

383

fd_execute_sync_cache(struct se_cmd *cmd)

drivers/target/target_core_file.c

428

fd_execute_write_same(struct se_cmd *cmd)

drivers/target/target_core_file.c

514

fd_do_prot_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)

drivers/target/target_core_file.c

533

fd_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)

drivers/target/target_core_file.c

584

fd_execute_rw_buffered(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,

drivers/target/target_core_file.c

668

fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,

drivers/target/target_core_file.c

907

fd_parse_cdb(struct se_cmd *cmd)

drivers/target/target_core_iblock.c

1050

static sense_reason_t iblock_pr_read_reservation(struct se_cmd *cmd,

drivers/target/target_core_iblock.c

1091

static sense_reason_t iblock_execute_pr_in(struct se_cmd *cmd, u8 sa,

drivers/target/target_core_iblock.c

1164

iblock_parse_cdb(struct se_cmd *cmd)

drivers/target/target_core_iblock.c

315

static void iblock_complete_cmd(struct se_cmd *cmd, blk_status_t blk_status)

drivers/target/target_core_iblock.c

336

struct se_cmd *cmd = bio->bi_private;

drivers/target/target_core_iblock.c

354

static struct bio *iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num,

drivers/target/target_core_iblock.c

394

struct se_cmd *cmd = bio->bi_private;

drivers/target/target_core_iblock.c

414

iblock_execute_sync_cache(struct se_cmd *cmd)

drivers/target/target_core_iblock.c

437

iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)

drivers/target/target_core_iblock.c

456

iblock_execute_zero_out(struct block_device *bdev, struct se_cmd *cmd)

drivers/target/target_core_iblock.c

489

iblock_execute_write_same(struct se_cmd *cmd)

drivers/target/target_core_iblock.c

688

iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio,

drivers/target/target_core_iblock.c

742

iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,

drivers/target/target_core_iblock.c

862

static sense_reason_t iblock_execute_pr_out(struct se_cmd *cmd, u8 sa, u64 key,

drivers/target/target_core_iblock.c

981

static sense_reason_t iblock_pr_read_keys(struct se_cmd *cmd,

drivers/target/target_core_internal.h

117

struct list_head *, struct se_cmd *);

drivers/target/target_core_internal.h

143

unsigned char *transport_dump_cmd_direction(struct se_cmd *);

drivers/target/target_core_internal.h

152

sense_reason_t target_cmd_size_check(struct se_cmd *cmd, unsigned int size);

drivers/target/target_core_internal.h

157

void __target_execute_cmd(struct se_cmd *, bool);

drivers/target/target_core_pr.c

119

static int target_check_scsi2_reservation_conflict(struct se_cmd *cmd)

drivers/target/target_core_pr.c

1464

struct se_cmd *cmd,

drivers/target/target_core_pr.c

201

target_scsi2_reservation_release(struct se_cmd *cmd)

drivers/target/target_core_pr.c

2038

core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,

drivers/target/target_core_pr.c

2263

core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)

drivers/target/target_core_pr.c

2417

core_scsi3_emulate_pro_reserve(struct se_cmd *cmd, int type, int scope,

drivers/target/target_core_pr.c

242

target_scsi2_reservation_reserve(struct se_cmd *cmd)

drivers/target/target_core_pr.c

2503

core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,

drivers/target/target_core_pr.c

2660

core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)

drivers/target/target_core_pr.c

2812

core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,

drivers/target/target_core_pr.c

311

static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,

drivers/target/target_core_pr.c

3122

core_scsi3_emulate_pro_preempt(struct se_cmd *cmd, int type, int scope,

drivers/target/target_core_pr.c

3143

core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,

drivers/target/target_core_pr.c

3546

target_try_pr_out_pt(struct se_cmd *cmd, u8 sa, u64 res_key, u64 sa_res_key,

drivers/target/target_core_pr.c

3580

target_scsi3_emulate_pr_out(struct se_cmd *cmd)

drivers/target/target_core_pr.c

3738

core_scsi3_pri_read_keys(struct se_cmd *cmd)

drivers/target/target_core_pr.c

3792

core_scsi3_pri_read_reservation(struct se_cmd *cmd)

drivers/target/target_core_pr.c

3869

core_scsi3_pri_report_capabilities(struct se_cmd *cmd)

drivers/target/target_core_pr.c

3928

core_scsi3_pri_read_full_status(struct se_cmd *cmd)

drivers/target/target_core_pr.c

4084

static sense_reason_t target_try_pr_in_pt(struct se_cmd *cmd, u8 sa)

drivers/target/target_core_pr.c

4117

target_scsi3_emulate_pr_in(struct se_cmd *cmd)

drivers/target/target_core_pr.c

4169

target_check_reservation(struct se_cmd *cmd)

drivers/target/target_core_pr.c

565

target_scsi3_pr_reservation_check(struct se_cmd *cmd)

drivers/target/target_core_pr.c

87

target_scsi2_reservation_check(struct se_cmd *cmd)

drivers/target/target_core_pr.h

62

extern sense_reason_t target_scsi2_reservation_release(struct se_cmd *);

drivers/target/target_core_pr.h

63

extern sense_reason_t target_scsi2_reservation_reserve(struct se_cmd *);

drivers/target/target_core_pr.h

76

extern sense_reason_t target_scsi3_emulate_pr_in(struct se_cmd *);

drivers/target/target_core_pr.h

77

extern sense_reason_t target_scsi3_emulate_pr_out(struct se_cmd *);

drivers/target/target_core_pr.h

78

extern sense_reason_t target_check_reservation(struct se_cmd *);

drivers/target/target_core_pscsi.c

1008

struct se_cmd *cmd = req->end_io_data;

drivers/target/target_core_pscsi.c

41

static sense_reason_t pscsi_execute_cmd(struct se_cmd *cmd);

drivers/target/target_core_pscsi.c

588

static void pscsi_complete_cmd(struct se_cmd *cmd, u8 scsi_status,

drivers/target/target_core_pscsi.c

824

pscsi_map_sg(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,

drivers/target/target_core_pscsi.c

924

pscsi_parse_cdb(struct se_cmd *cmd)

drivers/target/target_core_pscsi.c

933

pscsi_execute_cmd(struct se_cmd *cmd)

drivers/target/target_core_rd.c

378

static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, bool is_read)

drivers/target/target_core_rd.c

416

rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,

drivers/target/target_core_rd.c

650

rd_parse_cdb(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

1129

sbc_execute_unmap(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

1213

sbc_dif_generate(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

1281

sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt,

drivers/target/target_core_sbc.c

1321

void sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read,

drivers/target/target_core_sbc.c

1367

sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors,

drivers/target/target_core_sbc.c

138

sbc_emulate_startstop(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

169

sector_t sbc_get_write_same_sectors(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

193

sbc_execute_write_same_unmap(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

210

sbc_emulate_noop(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

216

static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)

drivers/target/target_core_sbc.c

274

sbc_setup_write_same(struct se_cmd *cmd, unsigned char flags,

drivers/target/target_core_sbc.c

28

sbc_check_prot(struct se_device *, struct se_cmd *, unsigned char, u32, bool);

drivers/target/target_core_sbc.c

29

static sense_reason_t sbc_execute_unmap(struct se_cmd *cmd);

drivers/target/target_core_sbc.c

32

sbc_emulate_readcapacity(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

342

sbc_execute_rw(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

350

static sense_reason_t compare_and_write_post(struct se_cmd *cmd, bool success,

drivers/target/target_core_sbc.c

436

static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool success,

drivers/target/target_core_sbc.c

568

sbc_compare_and_write(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

607

bool is_write, struct se_cmd *cmd)

drivers/target/target_core_sbc.c

667

sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,

drivers/target/target_core_sbc.c

745

sbc_check_dpofua(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb)

drivers/target/target_core_sbc.c

75

sbc_emulate_readcapacity_16(struct se_cmd *cmd)

drivers/target/target_core_sbc.c

768

sbc_check_atomic(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb)

drivers/target/target_core_sbc.c

811

sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)

drivers/target/target_core_spc.c

1039

static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)

drivers/target/target_core_spc.c

1164

static sense_reason_t spc_emulate_modeselect(struct se_cmd *cmd)

drivers/target/target_core_spc.c

1225

static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)

drivers/target/target_core_spc.c

1258

sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)

drivers/target/target_core_spc.c

1327

spc_emulate_testunitready(struct se_cmd *cmd)

drivers/target/target_core_spc.c

1449

struct se_cmd *cmd)

drivers/target/target_core_spc.c

1477

struct se_cmd *cmd)

drivers/target/target_core_spc.c

1495

struct se_cmd *cmd)

drivers/target/target_core_spc.c

1536

struct se_cmd *cmd)

drivers/target/target_core_spc.c

1582

struct se_cmd *cmd)

drivers/target/target_core_spc.c

160

spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

1705

struct se_cmd *cmd)

drivers/target/target_core_spc.c

1923

struct se_cmd *cmd)

drivers/target/target_core_spc.c

1985

struct se_cmd *cmd)

drivers/target/target_core_spc.c

2018

struct se_cmd *cmd)

drivers/target/target_core_spc.c

2166

spc_rsoc_get_descr(struct se_cmd *cmd, const struct target_opcode_descriptor **opcode)

drivers/target/target_core_spc.c

224

spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

2252

spc_emulate_report_supp_op_codes(struct se_cmd *cmd)

drivers/target/target_core_spc.c

2323

spc_fill_pd_text_id_info(struct se_cmd *cmd, u8 *cdb)

drivers/target/target_core_spc.c

2372

spc_emulate_report_id_info(struct se_cmd *cmd)

drivers/target/target_core_spc.c

2389

spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)

drivers/target/target_core_spc.c

469

spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

511

spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

627

spc_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

640

spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

704

spc_emulate_evpd_b3(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

717

spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);

drivers/target/target_core_spc.c

721

sense_reason_t (*emulate)(struct se_cmd *, unsigned char *);

drivers/target/target_core_spc.c

735

spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

75

spc_emulate_inquiry_std(struct se_cmd *cmd, unsigned char *buf)

drivers/target/target_core_spc.c

754

spc_emulate_inquiry(struct se_cmd *cmd)

drivers/target/target_core_spc.c

810

static int spc_modesense_rwrecovery(struct se_cmd *cmd, u8 pc, u8 *p)

drivers/target/target_core_spc.c

823

static int spc_modesense_control(struct se_cmd *cmd, u8 pc, u8 *p)

drivers/target/target_core_spc.c

946

static int spc_modesense_caching(struct se_cmd *cmd, u8 pc, u8 *p)

drivers/target/target_core_spc.c

965

static int spc_modesense_informational_exceptions(struct se_cmd *cmd, u8 pc, unsigned char *p)

drivers/target/target_core_spc.c

981

int (*emulate)(struct se_cmd *, u8, unsigned char *);

drivers/target/target_core_tmr.c

100

spin_unlock(&se_cmd->t_state_lock);

drivers/target/target_core_tmr.c

102

return kref_get_unless_zero(&se_cmd->cmd_kref);

drivers/target/target_core_tmr.c

111

struct se_cmd *se_cmd, *next;

drivers/target/target_core_tmr.c

121

list_for_each_entry_safe(se_cmd, next, &dev->queues[i].state_list,

drivers/target/target_core_tmr.c

123

if (se_sess != se_cmd->se_sess)

drivers/target/target_core_tmr.c

130

if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)

drivers/target/target_core_tmr.c

133

ref_tag = se_cmd->tag;

drivers/target/target_core_tmr.c

138

se_cmd->se_tfo->fabric_name, ref_tag);

drivers/target/target_core_tmr.c

141

rc = __target_check_io_state(se_cmd, se_sess, 0);

drivers/target/target_core_tmr.c

146

list_move_tail(&se_cmd->state_list, &aborted_list);

drivers/target/target_core_tmr.c

147

se_cmd->state_active = false;

drivers/target/target_core_tmr.c

154

list_del_init(&se_cmd->state_list);

drivers/target/target_core_tmr.c

155

target_put_cmd_and_wait(se_cmd);

drivers/target/target_core_tmr.c

183

struct se_cmd *cmd;

drivers/target/target_core_tmr.c

267

struct se_cmd *prout_cmd,

drivers/target/target_core_tmr.c

27

struct se_cmd *se_cmd,

drivers/target/target_core_tmr.c

274

struct se_cmd *cmd, *next;

drivers/target/target_core_tmr.c

342

cmd = list_entry(drain_task_list.next, struct se_cmd, state_list);

drivers/target/target_core_tmr.c

358

struct se_cmd *prout_cmd)

drivers/target/target_core_tmr.c

40

se_cmd->se_cmd_flags |= SCF_SCSI_TMR_CDB;

drivers/target/target_core_tmr.c

41

se_cmd->se_tmr_req = tmr;

drivers/target/target_core_tmr.c

42

tmr->task_cmd = se_cmd;

drivers/target/target_core_tmr.c

57

struct se_cmd *cmd)

drivers/target/target_core_tmr.c

71

static bool __target_check_io_state(struct se_cmd *se_cmd,

drivers/target/target_core_tmr.c

74

struct se_session *sess = se_cmd->se_sess;

drivers/target/target_core_tmr.c

88

spin_lock(&se_cmd->t_state_lock);

drivers/target/target_core_tmr.c

89

if (se_cmd->transport_state & (CMD_T_COMPLETE | CMD_T_FABRIC_STOP)) {

drivers/target/target_core_tmr.c

91

" fabric stop, skipping\n", se_cmd->tag);

drivers/target/target_core_tmr.c

92

spin_unlock(&se_cmd->t_state_lock);

drivers/target/target_core_tmr.c

95

se_cmd->transport_state |= CMD_T_ABORTED;

drivers/target/target_core_tmr.c

97

if ((tmr_sess != se_cmd->se_sess) && tas)

drivers/target/target_core_tmr.c

98

se_cmd->transport_state |= CMD_T_TAS;

drivers/target/target_core_transport.c

1000

static void transport_complete_qf(struct se_cmd *cmd);

drivers/target/target_core_transport.c

1007

struct se_cmd *cmd, *cmd_tmp;

drivers/target/target_core_transport.c

1031

unsigned char *transport_dump_cmd_direction(struct se_cmd *cmd)

drivers/target/target_core_transport.c

1324

target_check_max_data_sg_nents(struct se_cmd *cmd, struct se_device *dev,

drivers/target/target_core_transport.c

1386

target_cmd_size_check(struct se_cmd *cmd, unsigned int size)

drivers/target/target_core_transport.c

1448

void __target_init_cmd(struct se_cmd *cmd,

drivers/target/target_core_transport.c

1483

transport_check_alloc_task_attr(struct se_cmd *cmd)

drivers/target/target_core_transport.c

1504

target_cmd_init_cdb(struct se_cmd *cmd, unsigned char *cdb, gfp_t gfp)

drivers/target/target_core_transport.c

1556

target_cmd_parse_cdb(struct se_cmd *cmd)

drivers/target/target_core_transport.c

1585

static int __target_submit(struct se_cmd *cmd)

drivers/target/target_core_transport.c

1647

transport_generic_map_mem_to_cmd(struct se_cmd *cmd, struct scatterlist *sgl,

drivers/target/target_core_transport.c

1694

int target_init_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,

drivers/target/target_core_transport.c

1702

BUG_ON(se_cmd->se_tfo || se_cmd->se_sess);

drivers/target/target_core_transport.c

1705

se_cmd->se_cmd_flags |= SCF_USE_CPUID;

drivers/target/target_core_transport.c

1710

se_cmd->se_cmd_flags |= SCF_BIDI;

drivers/target/target_core_transport.c

1713

se_cmd->unknown_data_length = 1;

drivers/target/target_core_transport.c

1719

__target_init_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, data_length,

drivers/target/target_core_transport.c

1728

return target_get_sess_cmd(se_cmd, flags & TARGET_SCF_ACK_KREF);

drivers/target/target_core_transport.c

1751

int target_submit_prep(struct se_cmd *se_cmd, unsigned char *cdb,

drivers/target/target_core_transport.c

1759

rc = target_cmd_init_cdb(se_cmd, cdb, gfp);

drivers/target/target_core_transport.c

1766

rc = transport_lookup_cmd_lun(se_cmd);

drivers/target/target_core_transport.c

1770

rc = target_cmd_parse_cdb(se_cmd);

drivers/target/target_core_transport.c

1779

se_cmd->t_prot_sg = sgl_prot;

drivers/target/target_core_transport.c

1780

se_cmd->t_prot_nents = sgl_prot_count;

drivers/target/target_core_transport.c

1781

se_cmd->se_cmd_flags |= SCF_PASSTHROUGH_PROT_SG_TO_MEM_NOALLOC;

drivers/target/target_core_transport.c

1792

rc = transport_generic_map_mem_to_cmd(se_cmd, sgl, sgl_count,

drivers/target/target_core_transport.c

1801

transport_send_check_condition_and_sense(se_cmd, rc, 0);

drivers/target/target_core_transport.c

1802

target_put_sess_cmd(se_cmd);

drivers/target/target_core_transport.c

1806

transport_generic_request_failure(se_cmd, rc);

drivers/target/target_core_transport.c

1836

void target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,

drivers/target/target_core_transport.c

1842

rc = target_init_cmd(se_cmd, se_sess, sense, unpacked_lun, data_length,

drivers/target/target_core_transport.c

1848

if (target_submit_prep(se_cmd, cdb, NULL, 0, NULL, 0, NULL, 0,

drivers/target/target_core_transport.c

1852

target_submit(se_cmd);

drivers/target/target_core_transport.c

1889

struct se_cmd *se_cmd, *next_cmd;

drivers/target/target_core_transport.c

1900

llist_for_each_entry_safe(se_cmd, next_cmd, cmd_list, se_cmd_list) {

drivers/target/target_core_transport.c

1902

se_dev = se_cmd->se_dev;

drivers/target/target_core_transport.c

1906

__target_submit(se_cmd);

drivers/target/target_core_transport.c

1917

static void target_queue_submission(struct se_cmd *se_cmd)

drivers/target/target_core_transport.c

1919

struct se_device *se_dev = se_cmd->se_dev;

drivers/target/target_core_transport.c

1920

int cpu = se_cmd->cpuid;

drivers/target/target_core_transport.c

1924

llist_add(&se_cmd->se_cmd_list, &sq->cmd_list);

drivers/target/target_core_transport.c

1935

int target_submit(struct se_cmd *se_cmd)

drivers/target/target_core_transport.c

1937

const struct target_core_fabric_ops *tfo = se_cmd->se_sess->se_tpg->se_tpg_tfo;

drivers/target/target_core_transport.c

1938

struct se_dev_attrib *da = &se_cmd->se_dev->dev_attrib;

drivers/target/target_core_transport.c

1950

return __target_submit(se_cmd);

drivers/target/target_core_transport.c

1952

target_queue_submission(se_cmd);

drivers/target/target_core_transport.c

1959

struct se_cmd *se_cmd = container_of(work, struct se_cmd, work);

drivers/target/target_core_transport.c

1961

se_cmd->se_tmr_req->response = TMR_LUN_DOES_NOT_EXIST;

drivers/target/target_core_transport.c

1962

se_cmd->se_tfo->queue_tm_rsp(se_cmd);

drivers/target/target_core_transport.c

1964

transport_lun_remove_cmd(se_cmd);

drivers/target/target_core_transport.c

1965

transport_cmd_check_stop_to_fabric(se_cmd);

drivers/target/target_core_transport.c

1985

int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,

drivers/target/target_core_transport.c

1996

__target_init_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess,

drivers/target/target_core_transport.c

2003

ret = core_tmr_alloc_req(se_cmd, fabric_tmr_ptr, tm_type, gfp);

drivers/target/target_core_transport.c

2008

se_cmd->se_tmr_req->ref_task_tag = tag;

drivers/target/target_core_transport.c

2011

ret = target_get_sess_cmd(se_cmd, flags & TARGET_SCF_ACK_KREF);

drivers/target/target_core_transport.c

2013

core_tmr_release_req(se_cmd->se_tmr_req);

drivers/target/target_core_transport.c

2017

ret = transport_lookup_tmr_lun(se_cmd);

drivers/target/target_core_transport.c

2021

transport_generic_handle_tmr(se_cmd);

drivers/target/target_core_transport.c

2029

INIT_WORK(&se_cmd->work, target_complete_tmr_failure);

drivers/target/target_core_transport.c

2030

schedule_work(&se_cmd->work);

drivers/target/target_core_transport.c

2038

void transport_generic_request_failure(struct se_cmd *cmd,

drivers/target/target_core_transport.c

2143

void __target_execute_cmd(struct se_cmd *cmd, bool do_checks)

drivers/target/target_core_transport.c

2184

static int target_write_prot_action(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2219

static bool target_handle_task_attr(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2281

void target_execute_cmd(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2318

struct se_cmd *cmd;

drivers/target/target_core_transport.c

2330

struct se_cmd, se_delayed_node);

drivers/target/target_core_transport.c

2345

static void transport_complete_ordered_sync(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2370

static void transport_complete_task_attr(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2398

static void transport_complete_qf(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2466

static void transport_handle_queue_full(struct se_cmd *cmd, struct se_device *dev,

drivers/target/target_core_transport.c

2493

static bool target_read_prot_action(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2523

struct se_cmd *cmd = container_of(work, struct se_cmd, work);

drivers/target/target_core_transport.c

2675

static inline void transport_reset_sgl_orig(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2691

static inline void transport_free_pages(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2724

void *transport_kmap_data_sg(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2761

void transport_kunmap_data_sg(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2792

transport_generic_new_cmd(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2893

static void transport_write_pending_qf(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2919

__transport_wait_for_tasks(struct se_cmd *, bool, bool *, bool *,

drivers/target/target_core_transport.c

2922

static void target_wait_free_cmd(struct se_cmd *cmd, bool *aborted, bool *tas)

drivers/target/target_core_transport.c

2935

void target_put_cmd_and_wait(struct se_cmd *cmd)

drivers/target/target_core_transport.c

2968

int transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks)

drivers/target/target_core_transport.c

3006

int target_get_sess_cmd(struct se_cmd *se_cmd, bool ack_kref)

drivers/target/target_core_transport.c

3016

kref_get(&se_cmd->cmd_kref);

drivers/target/target_core_transport.c

3017

se_cmd->se_cmd_flags |= SCF_ACK_KREF;

drivers/target/target_core_transport.c

3024

if (se_cmd->cmd_cnt) {

drivers/target/target_core_transport.c

3025

if (!percpu_ref_tryget_live(&se_cmd->cmd_cnt->refcnt))

drivers/target/target_core_transport.c

3029

target_put_sess_cmd(se_cmd);

drivers/target/target_core_transport.c

3035

static void target_free_cmd_mem(struct se_cmd *cmd)

drivers/target/target_core_transport.c

3047

struct se_cmd *se_cmd = container_of(kref, struct se_cmd, cmd_kref);

drivers/target/target_core_transport.c

3048

struct target_cmd_counter *cmd_cnt = se_cmd->cmd_cnt;

drivers/target/target_core_transport.c

3049

struct completion *free_compl = se_cmd->free_compl;

drivers/target/target_core_transport.c

3050

struct completion *abrt_compl = se_cmd->abrt_compl;

drivers/target/target_core_transport.c

3052

target_free_cmd_mem(se_cmd);

drivers/target/target_core_transport.c

3053

se_cmd->se_tfo->release_cmd(se_cmd);

drivers/target/target_core_transport.c

3070

int target_put_sess_cmd(struct se_cmd *se_cmd)

drivers/target/target_core_transport.c

3072

return kref_put(&se_cmd->cmd_kref, target_release_cmd_kref);

drivers/target/target_core_transport.c

3155

void target_show_cmd(const char *pfx, struct se_cmd *cmd)

drivers/target/target_core_transport.c

3253

__transport_wait_for_tasks(struct se_cmd *cmd, bool fabric_stop,

drivers/target/target_core_transport.c

3306

bool transport_wait_for_tasks(struct se_cmd *cmd)

drivers/target/target_core_transport.c

3507

static void translate_sense_reason(struct se_cmd *cmd, sense_reason_t reason)

drivers/target/target_core_transport.c

3545

transport_send_check_condition_and_sense(struct se_cmd *cmd,

drivers/target/target_core_transport.c

3574

int target_send_busy(struct se_cmd *cmd)

drivers/target/target_core_transport.c

3586

struct se_cmd *cmd = container_of(work, struct se_cmd, work);

drivers/target/target_core_transport.c

3639

struct se_cmd *cmd)

drivers/target/target_core_transport.c

54

static void transport_complete_task_attr(struct se_cmd *cmd);

drivers/target/target_core_transport.c

55

static void translate_sense_reason(struct se_cmd *cmd, sense_reason_t reason);

drivers/target/target_core_transport.c

56

static void transport_handle_queue_full(struct se_cmd *cmd,

drivers/target/target_core_transport.c

696

static void target_remove_from_state_list(struct se_cmd *cmd)

drivers/target/target_core_transport.c

712

static void target_remove_from_tmr_list(struct se_cmd *cmd)

drivers/target/target_core_transport.c

734

static int transport_cmd_check_stop_to_fabric(struct se_cmd *cmd)

drivers/target/target_core_transport.c

765

static void transport_lun_remove_cmd(struct se_cmd *cmd)

drivers/target/target_core_transport.c

786

struct se_cmd *cmd = container_of(work, struct se_cmd, work);

drivers/target/target_core_transport.c

795

static unsigned char *transport_get_sense_buffer(struct se_cmd *cmd)

drivers/target/target_core_transport.c

814

void transport_copy_sense_to_cmd(struct se_cmd *cmd, unsigned char *sense)

drivers/target/target_core_transport.c

832

static void target_handle_abort(struct se_cmd *cmd)

drivers/target/target_core_transport.c

880

struct se_cmd *cmd = container_of(work, struct se_cmd, work);

drivers/target/target_core_transport.c

885

static bool target_cmd_interrupted(struct se_cmd *cmd)

drivers/target/target_core_transport.c

906

void target_complete_cmd_with_sense(struct se_cmd *cmd, u8 scsi_status,

drivers/target/target_core_transport.c

948

void target_complete_cmd(struct se_cmd *cmd, u8 scsi_status)

drivers/target/target_core_transport.c

956

void target_set_cmd_data_length(struct se_cmd *cmd, int length)

drivers/target/target_core_transport.c

971

void target_complete_cmd_with_length(struct se_cmd *cmd, u8 scsi_status, int length)

drivers/target/target_core_transport.c

982

static void target_add_to_state_list(struct se_cmd *cmd)

drivers/target/target_core_transport.c

999

static void transport_write_pending_qf(struct se_cmd *cmd);

drivers/target/target_core_ua.c

193

bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u8 *asc,

drivers/target/target_core_ua.c

26

target_scsi3_ua_check(struct se_cmd *cmd)

drivers/target/target_core_ua.c

267

struct se_cmd *cmd,

drivers/target/target_core_ua.h

36

extern sense_reason_t target_scsi3_ua_check(struct se_cmd *);

drivers/target/target_core_ua.h

40

extern bool core_scsi3_ua_for_check_condition(struct se_cmd *, u8 *, u8 *,

drivers/target/target_core_ua.h

42

extern int core_scsi3_ua_clear_for_request_sense(struct se_cmd *,

drivers/target/target_core_user.c

1015

struct se_cmd *se_cmd = tcmu_cmd->se_cmd;

drivers/target/target_core_user.c

1098

if (se_cmd->data_direction == DMA_TO_DEVICE ||

drivers/target/target_core_user.c

1099

se_cmd->se_cmd_flags & SCF_BIDI)

drivers/target/target_core_user.c

1102

tcmu_setup_iovs(udev, tcmu_cmd, &iov, se_cmd->data_length);

drivers/target/target_core_user.c

1107

if (se_cmd->se_cmd_flags & SCF_BIDI) {

drivers/target/target_core_user.c

1121

memcpy((void *) mb + cdb_off, se_cmd->t_task_cdb, scsi_command_size(se_cmd->t_task_cdb));

drivers/target/target_core_user.c

1203

tcmu_queue_cmd(struct se_cmd *se_cmd)

drivers/target/target_core_user.c

1205

struct se_device *se_dev = se_cmd->se_dev;

drivers/target/target_core_user.c

1211

tcmu_cmd = tcmu_alloc_cmd(se_cmd);

drivers/target/target_core_user.c

1216

if (!(se_cmd->transport_state & CMD_T_ABORTED))

drivers/target/target_core_user.c

1221

se_cmd->priv = tcmu_cmd;

drivers/target/target_core_user.c

1261

struct se_cmd *se_cmd;

drivers/target/target_core_user.c

1268

list_for_each_entry(se_cmd, cmd_list, state_list) {

drivers/target/target_core_user.c

1270

if (!se_cmd->priv)

drivers/target/target_core_user.c

1272

cmd = se_cmd->priv;

drivers/target/target_core_user.c

1283

se_cmd->priv = NULL;

drivers/target/target_core_user.c

1284

target_complete_cmd(se_cmd, SAM_STAT_TASK_ABORTED);

drivers/target/target_core_user.c

1305

list_for_each_entry(se_cmd, cmd_list, state_list) {

drivers/target/target_core_user.c

1306

if (!se_cmd->priv)

drivers/target/target_core_user.c

1308

cmd = se_cmd->priv;

drivers/target/target_core_user.c

1323

struct se_cmd *se_cmd = cmd->se_cmd;

drivers/target/target_core_user.c

1334

WARN_ON_ONCE(se_cmd);

drivers/target/target_core_user.c

1351

cmd->se_cmd);

drivers/target/target_core_user.c

1356

read_len = se_cmd->data_length;

drivers/target/target_core_user.c

1357

if (se_cmd->data_direction == DMA_FROM_DEVICE &&

drivers/target/target_core_user.c

1365

transport_copy_sense_to_cmd(se_cmd, entry->rsp.sense_buffer);

drivers/target/target_core_user.c

1369

se_cmd->se_cmd_flags |= SCF_TREAT_READ_AS_NORMAL;

drivers/target/target_core_user.c

1371

if (se_cmd->se_cmd_flags & SCF_BIDI) {

drivers/target/target_core_user.c

1374

} else if (se_cmd->data_direction == DMA_FROM_DEVICE) {

drivers/target/target_core_user.c

1376

} else if (se_cmd->data_direction == DMA_TO_DEVICE) {

drivers/target/target_core_user.c

1378

} else if (se_cmd->data_direction != DMA_NONE) {

drivers/target/target_core_user.c

1380

se_cmd->data_direction);

drivers/target/target_core_user.c

1384

se_cmd->priv = NULL;

drivers/target/target_core_user.c

1387

target_complete_cmd_with_length(cmd->se_cmd,

drivers/target/target_core_user.c

1390

target_complete_cmd(cmd->se_cmd, entry->rsp.scsi_status);

drivers/target/target_core_user.c

1520

struct se_cmd *se_cmd;

drivers/target/target_core_user.c

1527

se_cmd = cmd->se_cmd;

drivers/target/target_core_user.c

1528

se_cmd->priv = NULL;

drivers/target/target_core_user.c

1529

cmd->se_cmd = NULL;

drivers/target/target_core_user.c

1534

target_complete_cmd(se_cmd, SAM_STAT_CHECK_CONDITION);

drivers/target/target_core_user.c

1539

struct se_cmd *se_cmd;

drivers/target/target_core_user.c

1548

se_cmd = cmd->se_cmd;

drivers/target/target_core_user.c

1551

se_cmd->priv = NULL;

drivers/target/target_core_user.c

1552

target_complete_cmd(se_cmd, SAM_STAT_TASK_SET_FULL);

drivers/target/target_core_user.c

177

struct se_cmd *se_cmd;

drivers/target/target_core_user.c

1778

tcmu_cmd->se_cmd->priv = NULL;

drivers/target/target_core_user.c

1779

target_complete_cmd(tcmu_cmd->se_cmd, SAM_STAT_BUSY);

drivers/target/target_core_user.c

1792

tcmu_cmd->se_cmd->priv = NULL;

drivers/target/target_core_user.c

1793

target_complete_cmd(tcmu_cmd->se_cmd,

drivers/target/target_core_user.c

2381

WARN_ON(!cmd->se_cmd);

drivers/target/target_core_user.c

2383

cmd->se_cmd->priv = NULL;

drivers/target/target_core_user.c

2389

target_complete_cmd(cmd->se_cmd, SAM_STAT_BUSY);

drivers/target/target_core_user.c

2392

target_complete_cmd(cmd->se_cmd,

drivers/target/target_core_user.c

2668

tcmu_parse_cdb(struct se_cmd *cmd)

drivers/target/target_core_user.c

581

struct se_cmd *se_cmd = cmd->se_cmd;

drivers/target/target_core_user.c

584

cmd->dbi_cnt = DIV_ROUND_UP(se_cmd->data_length, blk_size);

drivers/target/target_core_user.c

586

if (se_cmd->se_cmd_flags & SCF_BIDI) {

drivers/target/target_core_user.c

587

BUG_ON(!(se_cmd->t_bidi_data_sg && se_cmd->t_bidi_data_nents));

drivers/target/target_core_user.c

588

for (i = 0, len = 0; i < se_cmd->t_bidi_data_nents; i++)

drivers/target/target_core_user.c

589

len += se_cmd->t_bidi_data_sg[i].length;

drivers/target/target_core_user.c

633

static struct tcmu_cmd *tcmu_alloc_cmd(struct se_cmd *se_cmd)

drivers/target/target_core_user.c

635

struct se_device *se_dev = se_cmd->se_dev;

drivers/target/target_core_user.c

644

tcmu_cmd->se_cmd = se_cmd;

drivers/target/target_core_user.c

777

struct se_cmd *se_cmd = tcmu_cmd->se_cmd;

drivers/target/target_core_user.c

779

tcmu_copy_data(udev, tcmu_cmd, TCMU_SG_TO_DATA_AREA, se_cmd->t_data_sg,

drivers/target/target_core_user.c

780

se_cmd->t_data_nents, iov, se_cmd->data_length);

drivers/target/target_core_user.c

786

struct se_cmd *se_cmd = tcmu_cmd->se_cmd;

drivers/target/target_core_user.c

791

data_sg = se_cmd->t_data_sg;

drivers/target/target_core_user.c

792

data_nents = se_cmd->t_data_nents;

drivers/target/target_core_user.c

802

data_sg = se_cmd->t_bidi_data_sg;

drivers/target/target_core_user.c

803

data_nents = se_cmd->t_bidi_data_nents;

drivers/target/target_core_user.c

880

iov_cnt = tcmu_get_empty_blocks(udev, cmd, cmd->se_cmd->data_length);

drivers/target/target_core_user.c

903

struct se_cmd *se_cmd = tcmu_cmd->se_cmd;

drivers/target/target_core_user.c

907

round_up(scsi_command_size(se_cmd->t_task_cdb),

drivers/target/target_core_xcopy.c

1001

transport_kunmap_data_sg(se_cmd);

drivers/target/target_core_xcopy.c

1002

target_complete_cmd(se_cmd, SAM_STAT_GOOD);

drivers/target/target_core_xcopy.c

1007

sense_reason_t target_do_receive_copy_results(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

1009

unsigned char *cdb = &se_cmd->t_task_cdb[0];

drivers/target/target_core_xcopy.c

1011

struct se_device *dev = se_cmd->se_dev;

drivers/target/target_core_xcopy.c

1020

" 0x%02x, AL: %u\n", sa, list_id, se_cmd->data_length);

drivers/target/target_core_xcopy.c

1030

rc = target_rcr_operating_parameters(se_cmd);

drivers/target/target_core_xcopy.c

116

static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op *xop,

drivers/target/target_core_xcopy.c

176

xop->src_dev = se_cmd->se_dev;

drivers/target/target_core_xcopy.c

193

xop->dst_dev = se_cmd->se_dev;

drivers/target/target_core_xcopy.c

202

static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,

drivers/target/target_core_xcopy.c

206

struct se_device *local_dev = se_cmd->se_dev;

drivers/target/target_core_xcopy.c

242

rc = target_xcopy_parse_tiddesc_e4(se_cmd, xop,

drivers/target/target_core_xcopy.c

260

rc = target_xcopy_locate_se_dev_e4(se_cmd->se_sess,

drivers/target/target_core_xcopy.c

266

rc = target_xcopy_locate_se_dev_e4(se_cmd->se_sess,

drivers/target/target_core_xcopy.c

392

struct se_cmd se_cmd;

drivers/target/target_core_xcopy.c

401

static int xcopy_pt_get_cmd_state(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

416

static void xcopy_pt_release_cmd(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

418

struct xcopy_pt_cmd *xpt_cmd = container_of(se_cmd,

drivers/target/target_core_xcopy.c

419

struct xcopy_pt_cmd, se_cmd);

drivers/target/target_core_xcopy.c

425

static int xcopy_pt_check_stop_free(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

427

struct xcopy_pt_cmd *xpt_cmd = container_of(se_cmd,

drivers/target/target_core_xcopy.c

428

struct xcopy_pt_cmd, se_cmd);

drivers/target/target_core_xcopy.c

434

static int xcopy_pt_write_pending(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

439

static int xcopy_pt_queue_data_in(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

444

static int xcopy_pt_queue_status(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

518

struct se_cmd *cmd = &xpt_cmd->se_cmd;

drivers/target/target_core_xcopy.c

552

struct se_cmd *se_cmd = &xpt_cmd->se_cmd;

drivers/target/target_core_xcopy.c

555

sense_rc = transport_generic_new_cmd(se_cmd);

drivers/target/target_core_xcopy.c

559

if (se_cmd->data_direction == DMA_TO_DEVICE)

drivers/target/target_core_xcopy.c

560

target_execute_cmd(se_cmd);

drivers/target/target_core_xcopy.c

565

se_cmd->scsi_status);

drivers/target/target_core_xcopy.c

567

return (se_cmd->scsi_status) ? -EINVAL : 0;

drivers/target/target_core_xcopy.c

571

struct se_cmd *ec_cmd,

drivers/target/target_core_xcopy.c

578

struct se_cmd *se_cmd = &xpt_cmd.se_cmd;

drivers/target/target_core_xcopy.c

594

__target_init_cmd(se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, src_bytes,

drivers/target/target_core_xcopy.c

600

ec_cmd->scsi_status = se_cmd->scsi_status;

drivers/target/target_core_xcopy.c

609

ec_cmd->scsi_status = se_cmd->scsi_status;

drivers/target/target_core_xcopy.c

611

transport_generic_free_cmd(se_cmd, 0);

drivers/target/target_core_xcopy.c

616

struct se_cmd *ec_cmd,

drivers/target/target_core_xcopy.c

623

struct se_cmd *se_cmd = &xpt_cmd.se_cmd;

drivers/target/target_core_xcopy.c

639

__target_init_cmd(se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, dst_bytes,

drivers/target/target_core_xcopy.c

645

ec_cmd->scsi_status = se_cmd->scsi_status;

drivers/target/target_core_xcopy.c

651

ec_cmd->scsi_status = se_cmd->scsi_status;

drivers/target/target_core_xcopy.c

653

transport_generic_free_cmd(se_cmd, 0);

drivers/target/target_core_xcopy.c

660

struct se_cmd *ec_cmd = xop->xop_se_cmd;

drivers/target/target_core_xcopy.c

789

struct se_cmd *se_cmd = xop->xop_se_cmd;

drivers/target/target_core_xcopy.c

796

p = transport_kmap_data_sg(se_cmd);

drivers/target/target_core_xcopy.c

823

if (se_cmd->data_length < (XCOPY_HDR_LEN + tdll + sdll + inline_dl)) {

drivers/target/target_core_xcopy.c

826

se_cmd->data_length, tdll, sdll, inline_dl);

drivers/target/target_core_xcopy.c

848

rc = target_xcopy_parse_target_descriptors(se_cmd, xop, &p[16], tdll, &ret);

drivers/target/target_core_xcopy.c

865

transport_kunmap_data_sg(se_cmd);

drivers/target/target_core_xcopy.c

870

transport_kunmap_data_sg(se_cmd);

drivers/target/target_core_xcopy.c

874

sense_reason_t target_do_xcopy(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

876

struct se_device *dev = se_cmd->se_dev;

drivers/target/target_core_xcopy.c

885

sa = se_cmd->t_task_cdb[1] & 0x1f;

drivers/target/target_core_xcopy.c

891

if (se_cmd->data_length == 0) {

drivers/target/target_core_xcopy.c

892

target_complete_cmd(se_cmd, SAM_STAT_GOOD);

drivers/target/target_core_xcopy.c

895

if (se_cmd->data_length < XCOPY_HDR_LEN) {

drivers/target/target_core_xcopy.c

897

se_cmd->data_length, XCOPY_HDR_LEN);

drivers/target/target_core_xcopy.c

904

xop->xop_se_cmd = se_cmd;

drivers/target/target_core_xcopy.c

917

static sense_reason_t target_rcr_operating_parameters(struct se_cmd *se_cmd)

drivers/target/target_core_xcopy.c

921

p = transport_kmap_data_sg(se_cmd);

drivers/target/target_core_xcopy.c

928

if (se_cmd->data_length < 54) {

drivers/target/target_core_xcopy.c

930

" too small: %u\n", se_cmd->data_length);

drivers/target/target_core_xcopy.c

931

transport_kunmap_data_sg(se_cmd);

drivers/target/target_core_xcopy.h

24

struct se_cmd *xop_se_cmd;

drivers/target/target_core_xcopy.h

67

extern sense_reason_t target_do_xcopy(struct se_cmd *);

drivers/target/target_core_xcopy.h

68

extern sense_reason_t target_do_receive_copy_results(struct se_cmd *);

drivers/target/tcm_fc/tcm_fc.h

109

struct se_cmd se_cmd; /* Local TCM I/O descriptor */

drivers/target/tcm_fc/tcm_fc.h

144

int ft_check_stop_free(struct se_cmd *);

drivers/target/tcm_fc/tcm_fc.h

145

void ft_release_cmd(struct se_cmd *);

drivers/target/tcm_fc/tcm_fc.h

146

int ft_queue_status(struct se_cmd *);

drivers/target/tcm_fc/tcm_fc.h

147

int ft_queue_data_in(struct se_cmd *);

drivers/target/tcm_fc/tcm_fc.h

148

int ft_write_pending(struct se_cmd *);

drivers/target/tcm_fc/tcm_fc.h

149

void ft_queue_tm_resp(struct se_cmd *);

drivers/target/tcm_fc/tcm_fc.h

150

void ft_aborted_task(struct se_cmd *);

drivers/target/tcm_fc/tfc_cmd.c

100

int ft_queue_status(struct se_cmd *se_cmd)

drivers/target/tcm_fc/tfc_cmd.c

102

struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

115

len = sizeof(*fcp) + se_cmd->scsi_sense_length;

drivers/target/tcm_fc/tfc_cmd.c

118

se_cmd->scsi_status = SAM_STAT_TASK_SET_FULL;

drivers/target/tcm_fc/tfc_cmd.c

124

fcp->resp.fr_status = se_cmd->scsi_status;

drivers/target/tcm_fc/tfc_cmd.c

126

len = se_cmd->scsi_sense_length;

drivers/target/tcm_fc/tfc_cmd.c

130

memcpy((fcp + 1), se_cmd->sense_buffer, len);

drivers/target/tcm_fc/tfc_cmd.c

137

if (se_cmd->se_cmd_flags & (SCF_OVERFLOW_BIT | SCF_UNDERFLOW_BIT)) {

drivers/target/tcm_fc/tfc_cmd.c

138

if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT)

drivers/target/tcm_fc/tfc_cmd.c

142

fcp->ext.fr_resid = cpu_to_be32(se_cmd->residual_count);

drivers/target/tcm_fc/tfc_cmd.c

161

se_cmd->scsi_status = SAM_STAT_TASK_SET_FULL;

drivers/target/tcm_fc/tfc_cmd.c

170

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

177

int ft_write_pending(struct se_cmd *se_cmd)

drivers/target/tcm_fc/tfc_cmd.c

179

struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

199

txrdy->ft_burst_len = htonl(se_cmd->data_length);

drivers/target/tcm_fc/tfc_cmd.c

215

if ((se_cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) &&

drivers/target/tcm_fc/tfc_cmd.c

217

se_cmd->t_data_sg,

drivers/target/tcm_fc/tfc_cmd.c

218

se_cmd->t_data_nents))

drivers/target/tcm_fc/tfc_cmd.c

255

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/target/tcm_fc/tfc_cmd.c

35

struct se_cmd *se_cmd;

drivers/target/tcm_fc/tfc_cmd.c

365

rc = target_submit_tmr(&cmd->se_cmd, cmd->sess->se_sess,

drivers/target/tcm_fc/tfc_cmd.c

375

void ft_queue_tm_resp(struct se_cmd *se_cmd)

drivers/target/tcm_fc/tfc_cmd.c

377

struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

378

struct se_tmr_req *tmr = se_cmd->se_tmr_req;

drivers/target/tcm_fc/tfc_cmd.c

39

se_cmd = &cmd->se_cmd;

drivers/target/tcm_fc/tfc_cmd.c

407

target_put_sess_cmd(&cmd->se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

41

caller, cmd, cmd->sess, cmd->seq, se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

410

void ft_aborted_task(struct se_cmd *se_cmd)

drivers/target/tcm_fc/tfc_cmd.c

434

cmd->se_cmd.map_tag = tag;

drivers/target/tcm_fc/tfc_cmd.c

435

cmd->se_cmd.map_cpu = cpu;

drivers/target/tcm_fc/tfc_cmd.c

439

target_free_tag(se_sess, &cmd->se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

44

caller, cmd, se_cmd->t_data_nents,

drivers/target/tcm_fc/tfc_cmd.c

45

se_cmd->data_length, se_cmd->se_cmd_flags);

drivers/target/tcm_fc/tfc_cmd.c

47

for_each_sg(se_cmd->t_data_sg, sg, se_cmd->t_data_nents, count)

drivers/target/tcm_fc/tfc_cmd.c

540

cmd->se_cmd.tag = fc_seq_exch(cmd->seq)->rxid;

drivers/target/tcm_fc/tfc_cmd.c

546

if (target_init_cmd(&cmd->se_cmd, cmd->sess->se_sess,

drivers/target/tcm_fc/tfc_cmd.c

552

if (target_submit_prep(&cmd->se_cmd, fcp->fc_cdb, NULL, 0, NULL, 0,

drivers/target/tcm_fc/tfc_cmd.c

556

target_submit(&cmd->se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

81

target_free_tag(sess->se_sess, &cmd->se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

85

void ft_release_cmd(struct se_cmd *se_cmd)

drivers/target/tcm_fc/tfc_cmd.c

87

struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);

drivers/target/tcm_fc/tfc_cmd.c

92

int ft_check_stop_free(struct se_cmd *se_cmd)

drivers/target/tcm_fc/tfc_cmd.c

94

return transport_generic_free_cmd(se_cmd, 0);

drivers/target/tcm_fc/tfc_io.c

177

se_cmd->scsi_status = SAM_STAT_TASK_SET_FULL;

drivers/target/tcm_fc/tfc_io.c

182

return ft_queue_status(se_cmd);

drivers/target/tcm_fc/tfc_io.c

189

target_execute_cmd(&cmd->se_cmd);

drivers/target/tcm_fc/tfc_io.c

197

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/target/tcm_fc/tfc_io.c

236

se_cmd->t_data_sg, se_cmd->t_data_nents);

drivers/target/tcm_fc/tfc_io.c

266

if (rel_off >= se_cmd->data_length)

drivers/target/tcm_fc/tfc_io.c

268

if (frame_len + rel_off > se_cmd->data_length)

drivers/target/tcm_fc/tfc_io.c

269

frame_len = se_cmd->data_length - rel_off;

drivers/target/tcm_fc/tfc_io.c

274

BUG_ON(frame_len && !se_cmd->t_data_sg);

drivers/target/tcm_fc/tfc_io.c

276

sg = se_cmd->t_data_sg;

drivers/target/tcm_fc/tfc_io.c

315

if (cmd->write_data_len == se_cmd->data_length) {

drivers/target/tcm_fc/tfc_io.c

41

int ft_queue_data_in(struct se_cmd *se_cmd)

drivers/target/tcm_fc/tfc_io.c

43

struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);

drivers/target/tcm_fc/tfc_io.c

67

if (se_cmd->scsi_status == SAM_STAT_TASK_SET_FULL)

drivers/target/tcm_fc/tfc_io.c

74

remaining = se_cmd->data_length;

drivers/target/tcm_fc/tfc_io.c

79

BUG_ON(remaining && !se_cmd->t_data_sg);

drivers/target/tcm_fc/tfc_io.c

81

sg = se_cmd->t_data_sg;

drivers/target/tcm_remote/tcm_remote.c

42

static int tcm_remote_dummy_cmd_fn(struct se_cmd *se_cmd)

drivers/target/tcm_remote/tcm_remote.c

47

static void tcm_remote_dummy_cmd_void_fn(struct se_cmd *se_cmd)

drivers/usb/gadget/function/f_tcm.c

1080

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

1085

struct uas_stream *stream = &cmd->fu->stream[se_cmd->map_tag];

drivers/usb/gadget/function/f_tcm.c

1088

target_put_sess_cmd(se_cmd);

drivers/usb/gadget/function/f_tcm.c

1089

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/usb/gadget/function/f_tcm.c

1099

sg_copy_from_buffer(se_cmd->t_data_sg,

drivers/usb/gadget/function/f_tcm.c

1100

se_cmd->t_data_nents,

drivers/usb/gadget/function/f_tcm.c

1102

se_cmd->data_length);

drivers/usb/gadget/function/f_tcm.c

1110

target_put_sess_cmd(se_cmd);

drivers/usb/gadget/function/f_tcm.c

1119

transport_send_check_condition_and_sense(se_cmd,

drivers/usb/gadget/function/f_tcm.c

1125

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

1130

cmd->data_buf = kmalloc(se_cmd->data_length, GFP_ATOMIC);

drivers/usb/gadget/function/f_tcm.c

1137

req->num_sgs = se_cmd->t_data_nents;

drivers/usb/gadget/function/f_tcm.c

1138

req->sg = se_cmd->t_data_sg;

drivers/usb/gadget/function/f_tcm.c

1144

req->length = se_cmd->data_length;

drivers/usb/gadget/function/f_tcm.c

1151

static int usbg_send_status_response(struct se_cmd *se_cmd)

drivers/usb/gadget/function/f_tcm.c

1153

struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,

drivers/usb/gadget/function/f_tcm.c

1154

se_cmd);

drivers/usb/gadget/function/f_tcm.c

1163

static int usbg_send_write_request(struct se_cmd *se_cmd)

drivers/usb/gadget/function/f_tcm.c

1165

struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,

drivers/usb/gadget/function/f_tcm.c

1166

se_cmd);

drivers/usb/gadget/function/f_tcm.c

1175

static int usbg_send_read_response(struct se_cmd *se_cmd)

drivers/usb/gadget/function/f_tcm.c

1177

struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,

drivers/usb/gadget/function/f_tcm.c

1178

se_cmd);

drivers/usb/gadget/function/f_tcm.c

1187

static void usbg_aborted_task(struct se_cmd *se_cmd);

drivers/usb/gadget/function/f_tcm.c

1192

struct se_cmd *se_cmd;

drivers/usb/gadget/function/f_tcm.c

1195

se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

1198

target_submit_tmr(se_cmd, se_sess,

drivers/usb/gadget/function/f_tcm.c

1206

struct se_cmd *se_cmd;

drivers/usb/gadget/function/f_tcm.c

1217

target_execute_cmd(&cmd->se_cmd);

drivers/usb/gadget/function/f_tcm.c

1222

se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

1236

target_submit_cmd(se_cmd, tv_nexus->tvn_se_sess, cmd->cmd_buf,

drivers/usb/gadget/function/f_tcm.c

1243

__target_init_cmd(se_cmd,

drivers/usb/gadget/function/f_tcm.c

1248

transport_send_check_condition_and_sense(se_cmd,

drivers/usb/gadget/function/f_tcm.c

1326

cmd->se_cmd.map_tag,

drivers/usb/gadget/function/f_tcm.c

1327

cmd->se_cmd.map_cpu);

drivers/usb/gadget/function/f_tcm.c

1334

usbg_aborted_task(&active_cmd->se_cmd);

drivers/usb/gadget/function/f_tcm.c

1356

cmd->se_cmd.map_tag = tag;

drivers/usb/gadget/function/f_tcm.c

1357

cmd->se_cmd.map_cpu = cpu;

drivers/usb/gadget/function/f_tcm.c

1358

cmd->se_cmd.cpuid = cpu;

drivers/usb/gadget/function/f_tcm.c

1359

cmd->se_cmd.tag = cmd->tag = scsi_tag;

drivers/usb/gadget/function/f_tcm.c

1365

static void usbg_release_cmd(struct se_cmd *);

drivers/usb/gadget/function/f_tcm.c

1395

cmd->se_cmd.tag = scsi_tag;

drivers/usb/gadget/function/f_tcm.c

1425

stream = &fu->stream[cmd->se_cmd.map_tag];

drivers/usb/gadget/function/f_tcm.c

1438

target_free_tag(tv_nexus->tvn_se_sess, &cmd->se_cmd);

drivers/usb/gadget/function/f_tcm.c

1473

struct se_cmd *se_cmd;

drivers/usb/gadget/function/f_tcm.c

1485

target_execute_cmd(&cmd->se_cmd);

drivers/usb/gadget/function/f_tcm.c

1490

se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

1504

target_submit_cmd(se_cmd, tv_nexus->tvn_se_sess,

drivers/usb/gadget/function/f_tcm.c

1510

__target_init_cmd(se_cmd,

drivers/usb/gadget/function/f_tcm.c

1515

transport_send_check_condition_and_sense(se_cmd,

drivers/usb/gadget/function/f_tcm.c

154

if (cmd->se_cmd.scsi_status == SAM_STAT_GOOD) {

drivers/usb/gadget/function/f_tcm.c

1559

cmd->se_cmd.tag = le32_to_cpu(cmd->bot_tag);

drivers/usb/gadget/function/f_tcm.c

1591

static void usbg_release_cmd(struct se_cmd *se_cmd)

drivers/usb/gadget/function/f_tcm.c

1593

struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,

drivers/usb/gadget/function/f_tcm.c

1594

se_cmd);

drivers/usb/gadget/function/f_tcm.c

1595

struct se_session *se_sess = se_cmd->se_sess;

drivers/usb/gadget/function/f_tcm.c

1599

target_free_tag(se_sess, se_cmd);

drivers/usb/gadget/function/f_tcm.c

1602

static void usbg_queue_tm_rsp(struct se_cmd *se_cmd)

drivers/usb/gadget/function/f_tcm.c

1604

struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd, se_cmd);

drivers/usb/gadget/function/f_tcm.c

1609

static void usbg_aborted_task(struct se_cmd *se_cmd)

drivers/usb/gadget/function/f_tcm.c

1611

struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd, se_cmd);

drivers/usb/gadget/function/f_tcm.c

1614

struct uas_stream *stream = &fu->stream[se_cmd->map_tag];

drivers/usb/gadget/function/f_tcm.c

2001

static int usbg_check_stop_free(struct se_cmd *se_cmd)

drivers/usb/gadget/function/f_tcm.c

2003

return target_put_sess_cmd(se_cmd);

drivers/usb/gadget/function/f_tcm.c

202

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/usb/gadget/function/f_tcm.c

212

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

223

cmd->data_buf = kmalloc(se_cmd->data_length, GFP_ATOMIC);

drivers/usb/gadget/function/f_tcm.c

227

sg_copy_to_buffer(se_cmd->t_data_sg,

drivers/usb/gadget/function/f_tcm.c

228

se_cmd->t_data_nents,

drivers/usb/gadget/function/f_tcm.c

230

se_cmd->data_length);

drivers/usb/gadget/function/f_tcm.c

235

fu->bot_req_in->num_sgs = se_cmd->t_data_nents;

drivers/usb/gadget/function/f_tcm.c

236

fu->bot_req_in->sg = se_cmd->t_data_sg;

drivers/usb/gadget/function/f_tcm.c

240

fu->bot_req_in->length = se_cmd->data_length;

drivers/usb/gadget/function/f_tcm.c

559

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

562

struct uas_stream *stream = &fu->stream[se_cmd->map_tag];

drivers/usb/gadget/function/f_tcm.c

565

cmd->data_buf = kmalloc(se_cmd->data_length, GFP_ATOMIC);

drivers/usb/gadget/function/f_tcm.c

569

sg_copy_to_buffer(se_cmd->t_data_sg,

drivers/usb/gadget/function/f_tcm.c

570

se_cmd->t_data_nents,

drivers/usb/gadget/function/f_tcm.c

572

se_cmd->data_length);

drivers/usb/gadget/function/f_tcm.c

577

stream->req_in->num_sgs = se_cmd->t_data_nents;

drivers/usb/gadget/function/f_tcm.c

578

stream->req_in->sg = se_cmd->t_data_sg;

drivers/usb/gadget/function/f_tcm.c

584

stream->req_in->length = se_cmd->data_length;

drivers/usb/gadget/function/f_tcm.c

593

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

595

struct uas_stream *stream = &cmd->fu->stream[se_cmd->map_tag];

drivers/usb/gadget/function/f_tcm.c

604

iu->len = cpu_to_be16(se_cmd->scsi_sense_length);

drivers/usb/gadget/function/f_tcm.c

605

iu->status = se_cmd->scsi_status;

drivers/usb/gadget/function/f_tcm.c

609

stream->req_status->length = se_cmd->scsi_sense_length + 16;

drivers/usb/gadget/function/f_tcm.c

616

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

618

struct uas_stream *stream = &cmd->fu->stream[se_cmd->map_tag];

drivers/usb/gadget/function/f_tcm.c

628

tcm_to_uasp_response(se_cmd->se_tmr_req->response);

drivers/usb/gadget/function/f_tcm.c

65

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/usb/gadget/function/f_tcm.c

666

static void usbg_release_cmd(struct se_cmd *se_cmd);

drivers/usb/gadget/function/f_tcm.c

673

struct uas_stream *stream = &fu->stream[cmd->se_cmd.map_tag];

drivers/usb/gadget/function/f_tcm.c

730

cmd->se_cmd.map_tag,

drivers/usb/gadget/function/f_tcm.c

731

cmd->se_cmd.map_cpu);

drivers/usb/gadget/function/f_tcm.c

733

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/usb/gadget/function/f_tcm.c

747

transport_generic_free_cmd(&cmd->se_cmd, 0);

drivers/usb/gadget/function/f_tcm.c

753

struct uas_stream *stream = &fu->stream[cmd->se_cmd.map_tag];

drivers/usb/gadget/function/f_tcm.c

765

struct uas_stream *stream = &fu->stream[cmd->se_cmd.map_tag];

drivers/usb/gadget/function/f_tcm.c

777

struct uas_stream *stream = &fu->stream[cmd->se_cmd.map_tag];

drivers/usb/gadget/function/f_tcm.c

820

struct se_cmd *se_cmd = &cmd->se_cmd;

drivers/usb/gadget/function/f_tcm.c

821

struct uas_stream *stream = &fu->stream[se_cmd->map_tag];

drivers/usb/gadget/function/tcm.h

75

struct se_cmd se_cmd;

drivers/vhost/scsi.c

1047

struct se_cmd *se_cmd = &cmd->tvc_se_cmd;

drivers/vhost/scsi.c

1057

se_cmd->prot_pto = true;

drivers/vhost/scsi.c

1062

se_cmd->tag = 0;

drivers/vhost/scsi.c

1063

target_init_cmd(se_cmd, nexus->tvn_se_sess, &cmd->tvc_sense_buf[0],

drivers/vhost/scsi.c

1067

if (target_submit_prep(se_cmd, cdb, sg_ptr,

drivers/vhost/scsi.c

1072

target_submit(se_cmd);

drivers/vhost/scsi.c

133

struct se_cmd tvc_se_cmd;

drivers/vhost/scsi.c

1628

if (target_submit_tmr(&tmf->se_cmd, tpg->tpg_nexus->tvn_se_sess, NULL,

drivers/vhost/scsi.c

263

struct se_cmd se_cmd;

drivers/vhost/scsi.c

416

static void vhost_scsi_release_cmd_res(struct se_cmd *se_cmd)

drivers/vhost/scsi.c

418

struct vhost_scsi_cmd *tv_cmd = container_of(se_cmd,

drivers/vhost/scsi.c

454

sbitmap_clear_bit(&svq->scsi_tags, se_cmd->map_tag);

drivers/vhost/scsi.c

480

static void vhost_scsi_release_cmd(struct se_cmd *se_cmd)

drivers/vhost/scsi.c

482

if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) {

drivers/vhost/scsi.c

483

struct vhost_scsi_tmf *tmf = container_of(se_cmd,

drivers/vhost/scsi.c

484

struct vhost_scsi_tmf, se_cmd);

drivers/vhost/scsi.c

488

struct vhost_scsi_cmd *cmd = container_of(se_cmd,

drivers/vhost/scsi.c

499

static int vhost_scsi_write_pending(struct se_cmd *se_cmd)

drivers/vhost/scsi.c

502

target_execute_cmd(se_cmd);

drivers/vhost/scsi.c

506

static int vhost_scsi_queue_data_in(struct se_cmd *se_cmd)

drivers/vhost/scsi.c

508

transport_generic_free_cmd(se_cmd, 0);

drivers/vhost/scsi.c

512

static int vhost_scsi_queue_status(struct se_cmd *se_cmd)

drivers/vhost/scsi.c

514

transport_generic_free_cmd(se_cmd, 0);

drivers/vhost/scsi.c

518

static void vhost_scsi_queue_tm_rsp(struct se_cmd *se_cmd)

drivers/vhost/scsi.c

520

struct vhost_scsi_tmf *tmf = container_of(se_cmd, struct vhost_scsi_tmf,

drivers/vhost/scsi.c

521

se_cmd);

drivers/vhost/scsi.c

523

tmf->scsi_resp = se_cmd->se_tmr_req->response;

drivers/vhost/scsi.c

524

transport_generic_free_cmd(&tmf->se_cmd, 0);

drivers/vhost/scsi.c

527

static void vhost_scsi_aborted_task(struct se_cmd *se_cmd)

drivers/vhost/scsi.c

564

static int vhost_scsi_check_stop_free(struct se_cmd *se_cmd)

drivers/vhost/scsi.c

566

return target_put_sess_cmd(se_cmd);

drivers/vhost/scsi.c

693

struct se_cmd *se_cmd;

drivers/vhost/scsi.c

703

se_cmd = &cmd->tvc_se_cmd;

drivers/vhost/scsi.c

706

cmd, se_cmd->residual_count, se_cmd->scsi_status);

drivers/vhost/scsi.c

713

se_cmd->residual_count);

drivers/vhost/scsi.c

715

v_rsp.status = se_cmd->scsi_status;

drivers/vhost/scsi.c

717

se_cmd->scsi_sense_length);

drivers/vhost/scsi.c

719

se_cmd->scsi_sense_length);

drivers/vhost/scsi.c

735

vhost_scsi_release_cmd_res(se_cmd);

drivers/xen/xen-scsiback.c

135

struct se_cmd se_cmd;

drivers/xen/xen-scsiback.c

1409

static int scsiback_check_stop_free(struct se_cmd *se_cmd)

drivers/xen/xen-scsiback.c

1411

return transport_generic_free_cmd(se_cmd, 0);

drivers/xen/xen-scsiback.c

1414

static void scsiback_release_cmd(struct se_cmd *se_cmd)

drivers/xen/xen-scsiback.c

1416

target_free_tag(se_cmd->se_sess, se_cmd);

drivers/xen/xen-scsiback.c

1419

static int scsiback_write_pending(struct se_cmd *se_cmd)

drivers/xen/xen-scsiback.c

1422

target_execute_cmd(se_cmd);

drivers/xen/xen-scsiback.c

1427

static int scsiback_queue_data_in(struct se_cmd *se_cmd)

drivers/xen/xen-scsiback.c

1429

struct vscsibk_pend *pending_req = container_of(se_cmd,

drivers/xen/xen-scsiback.c

1430

struct vscsibk_pend, se_cmd);

drivers/xen/xen-scsiback.c

1437

static int scsiback_queue_status(struct se_cmd *se_cmd)

drivers/xen/xen-scsiback.c

1439

struct vscsibk_pend *pending_req = container_of(se_cmd,

drivers/xen/xen-scsiback.c

1440

struct vscsibk_pend, se_cmd);

drivers/xen/xen-scsiback.c

1442

if (se_cmd->sense_buffer &&

drivers/xen/xen-scsiback.c

1443

((se_cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||

drivers/xen/xen-scsiback.c

1444

(se_cmd->se_cmd_flags & SCF_EMULATED_TASK_SENSE)))

drivers/xen/xen-scsiback.c

1447

pending_req->result = se_cmd->scsi_status;

drivers/xen/xen-scsiback.c

1453

static void scsiback_queue_tm_rsp(struct se_cmd *se_cmd)

drivers/xen/xen-scsiback.c

1455

struct vscsibk_pend *pending_req = container_of(se_cmd,

drivers/xen/xen-scsiback.c

1456

struct vscsibk_pend, se_cmd);

drivers/xen/xen-scsiback.c

1461

static void scsiback_aborted_task(struct se_cmd *se_cmd)

drivers/xen/xen-scsiback.c

404

resid = pending_req->se_cmd.residual_count;

drivers/xen/xen-scsiback.c

418

target_put_sess_cmd(&pending_req->se_cmd);

drivers/xen/xen-scsiback.c

423

struct se_cmd *se_cmd = &pending_req->se_cmd;

drivers/xen/xen-scsiback.c

427

se_cmd->tag = pending_req->rqid;

drivers/xen/xen-scsiback.c

428

target_init_cmd(se_cmd, sess, pending_req->sense_buffer,

drivers/xen/xen-scsiback.c

432

if (target_submit_prep(se_cmd, pending_req->cmnd, pending_req->sgl,

drivers/xen/xen-scsiback.c

436

target_submit(se_cmd);

drivers/xen/xen-scsiback.c

619

struct se_cmd *se_cmd = &pending_req->se_cmd;

drivers/xen/xen-scsiback.c

625

rc = target_submit_tmr(&pending_req->se_cmd, nexus->tvn_se_sess,

drivers/xen/xen-scsiback.c

634

err = (se_cmd->se_tmr_req->response == TMR_FUNCTION_COMPLETE) ?

drivers/xen/xen-scsiback.c

638

transport_generic_free_cmd(&pending_req->se_cmd, 0);

drivers/xen/xen-scsiback.c

688

req->se_cmd.map_tag = tag;

drivers/xen/xen-scsiback.c

689

req->se_cmd.map_cpu = cpu;

drivers/xen/xen-scsiback.c

797

transport_generic_free_cmd(&pending_req->se_cmd, 0);

drivers/xen/xen-scsiback.c

813

transport_generic_free_cmd(&pending_req->se_cmd, 0);

include/target/iscsi/iscsi_target_core.h

487

struct se_cmd se_cmd;

include/target/target_core_backend.h

100

void sbc_dif_copy_prot(struct se_cmd *, unsigned int, bool,

include/target/target_core_backend.h

112

void *transport_kmap_data_sg(struct se_cmd *);

include/target/target_core_backend.h

113

void transport_kunmap_data_sg(struct se_cmd *);

include/target/target_core_backend.h

115

sense_reason_t transport_generic_map_mem_to_cmd(struct se_cmd *,

include/target/target_core_backend.h

118

bool target_lun_is_rdonly(struct se_cmd *);

include/target/target_core_backend.h

119

sense_reason_t passthrough_parse_cdb(struct se_cmd *cmd,

include/target/target_core_backend.h

120

sense_reason_t (*exec_cmd)(struct se_cmd *cmd));

include/target/target_core_backend.h

45

sense_reason_t (*parse_cdb)(struct se_cmd *cmd);

include/target/target_core_backend.h

55

unsigned char *(*get_sense_buffer)(struct se_cmd *);

include/target/target_core_backend.h

66

sense_reason_t (*execute_rw)(struct se_cmd *cmd, struct scatterlist *,

include/target/target_core_backend.h

68

sense_reason_t (*execute_sync_cache)(struct se_cmd *cmd);

include/target/target_core_backend.h

69

sense_reason_t (*execute_write_same)(struct se_cmd *cmd);

include/target/target_core_backend.h

70

sense_reason_t (*execute_unmap)(struct se_cmd *cmd,

include/target/target_core_backend.h

72

sense_reason_t (*execute_pr_out)(struct se_cmd *cmd, u8 sa, u64 key,

include/target/target_core_backend.h

74

sense_reason_t (*execute_pr_in)(struct se_cmd *cmd, u8 sa,

include/target/target_core_backend.h

81

void target_complete_cmd(struct se_cmd *, u8);

include/target/target_core_backend.h

82

void target_set_cmd_data_length(struct se_cmd *, int);

include/target/target_core_backend.h

83

void target_complete_cmd_with_sense(struct se_cmd *, u8, sense_reason_t);

include/target/target_core_backend.h

84

void target_complete_cmd_with_length(struct se_cmd *, u8, int);

include/target/target_core_backend.h

86

void transport_copy_sense_to_cmd(struct se_cmd *, unsigned char *);

include/target/target_core_backend.h

88

sense_reason_t spc_parse_cdb(struct se_cmd *cmd, unsigned int *size);

include/target/target_core_backend.h

89

sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd);

include/target/target_core_backend.h

90

sense_reason_t spc_emulate_inquiry_std(struct se_cmd *, unsigned char *);

include/target/target_core_backend.h

91

sense_reason_t spc_emulate_evpd_83(struct se_cmd *, unsigned char *);

include/target/target_core_backend.h

93

sense_reason_t sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops);

include/target/target_core_backend.h

96

sector_t sbc_get_write_same_sectors(struct se_cmd *cmd);

include/target/target_core_backend.h

97

void sbc_dif_generate(struct se_cmd *);

include/target/target_core_backend.h

98

sense_reason_t sbc_dif_verify(struct se_cmd *, sector_t, unsigned int,

include/target/target_core_base.h

1036

static inline void target_free_tag(struct se_session *sess, struct se_cmd *cmd)

include/target/target_core_base.h

253

struct se_cmd;

include/target/target_core_base.h

431

struct se_cmd *task_cmd;

include/target/target_core_base.h

518

sense_reason_t (*execute_cmd)(struct se_cmd *);

include/target/target_core_base.h

519

sense_reason_t (*transport_complete_callback)(struct se_cmd *, bool, int *);

include/target/target_core_base.h

912

struct se_cmd *cmd);

include/target/target_core_fabric.h

166

void __target_init_cmd(struct se_cmd *cmd,

include/target/target_core_fabric.h

171

int target_init_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,

include/target/target_core_fabric.h

174

int target_submit_prep(struct se_cmd *se_cmd, unsigned char *cdb,

include/target/target_core_fabric.h

178

int target_submit(struct se_cmd *se_cmd);

include/target/target_core_fabric.h

179

sense_reason_t transport_lookup_cmd_lun(struct se_cmd *);

include/target/target_core_fabric.h

180

sense_reason_t target_cmd_init_cdb(struct se_cmd *se_cmd, unsigned char *cdb,

include/target/target_core_fabric.h

182

sense_reason_t target_cmd_parse_cdb(struct se_cmd *);

include/target/target_core_fabric.h

183

void target_submit_cmd(struct se_cmd *, struct se_session *, unsigned char *,

include/target/target_core_fabric.h

186

int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,

include/target/target_core_fabric.h

190

sense_reason_t transport_generic_new_cmd(struct se_cmd *);

include/target/target_core_fabric.h

192

void target_put_cmd_and_wait(struct se_cmd *cmd);

include/target/target_core_fabric.h

193

void target_execute_cmd(struct se_cmd *cmd);

include/target/target_core_fabric.h

195

int transport_generic_free_cmd(struct se_cmd *, int);

include/target/target_core_fabric.h

197

bool transport_wait_for_tasks(struct se_cmd *);

include/target/target_core_fabric.h

198

int transport_send_check_condition_and_sense(struct se_cmd *,

include/target/target_core_fabric.h

200

int target_send_busy(struct se_cmd *cmd);

include/target/target_core_fabric.h

201

int target_get_sess_cmd(struct se_cmd *, bool);

include/target/target_core_fabric.h

202

int target_put_sess_cmd(struct se_cmd *);

include/target/target_core_fabric.h

205

void target_show_cmd(const char *pfx, struct se_cmd *cmd);

include/target/target_core_fabric.h

207

int core_tmr_alloc_req(struct se_cmd *, void *, u8, gfp_t);

include/target/target_core_fabric.h

209

int transport_generic_handle_tmr(struct se_cmd *);

include/target/target_core_fabric.h

210

void transport_generic_request_failure(struct se_cmd *, sense_reason_t);

include/target/target_core_fabric.h

211

int transport_lookup_tmr_lun(struct se_cmd *);

include/target/target_core_fabric.h

240

target_reverse_dma_direction(struct se_cmd *se_cmd)

include/target/target_core_fabric.h

242

if (se_cmd->se_cmd_flags & SCF_BIDI)

include/target/target_core_fabric.h

245

switch (se_cmd->data_direction) {

include/target/target_core_fabric.h

66

int (*check_stop_free)(struct se_cmd *);

include/target/target_core_fabric.h

67

void (*release_cmd)(struct se_cmd *);

include/target/target_core_fabric.h

76

int (*write_pending)(struct se_cmd *);

include/target/target_core_fabric.h

78

int (*get_cmd_state)(struct se_cmd *);

include/target/target_core_fabric.h

79

int (*queue_data_in)(struct se_cmd *);

include/target/target_core_fabric.h

80

int (*queue_status)(struct se_cmd *);

include/target/target_core_fabric.h

81

void (*queue_tm_rsp)(struct se_cmd *);

include/target/target_core_fabric.h

82

void (*aborted_task)(struct se_cmd *);

include/trace/events/target.h

134

TP_PROTO(struct se_cmd *cmd),

include/trace/events/target.h

171

TP_PROTO(struct se_cmd *cmd),