Lines Matching refs:cmd
40 sbc_emulate_readcapacity(struct se_cmd *cmd)
42 struct se_device *dev = cmd->se_dev;
43 unsigned char *cdb = cmd->t_task_cdb;
78 rbuf = transport_kmap_data_sg(cmd);
80 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
81 transport_kunmap_data_sg(cmd);
84 target_complete_cmd_with_length(cmd, GOOD, 8);
89 sbc_emulate_readcapacity_16(struct se_cmd *cmd)
91 struct se_device *dev = cmd->se_dev;
92 struct se_session *sess = cmd->se_sess;
134 rbuf = transport_kmap_data_sg(cmd);
136 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
137 transport_kunmap_data_sg(cmd);
140 target_complete_cmd_with_length(cmd, GOOD, 32);
144 sector_t sbc_get_write_same_sectors(struct se_cmd *cmd)
148 if (cmd->t_task_cdb[0] == WRITE_SAME)
149 num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]);
150 else if (cmd->t_task_cdb[0] == WRITE_SAME_16)
151 num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
153 num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
162 return cmd->se_dev->transport->get_blocks(cmd->se_dev) -
163 cmd->t_task_lba + 1;
168 sbc_emulate_noop(struct se_cmd *cmd)
170 target_complete_cmd(cmd, GOOD);
174 static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)
176 return cmd->se_dev->dev_attrib.block_size * sectors;
252 sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *ops)
254 unsigned int sectors = sbc_get_write_same_sectors(cmd);
262 if (sectors > cmd->se_dev->dev_attrib.max_write_same_len) {
264 sectors, cmd->se_dev->dev_attrib.max_write_same_len);
280 cmd->execute_cmd = ops->execute_write_same_unmap;
286 cmd->execute_cmd = ops->execute_write_same;
290 static sense_reason_t xdreadwrite_callback(struct se_cmd *cmd)
308 buf = kmalloc(cmd->data_length, GFP_KERNEL);
314 * Copy the scatterlist WRITE buffer located at cmd->t_data_sg
317 sg_copy_to_buffer(cmd->t_data_sg,
318 cmd->t_data_nents,
320 cmd->data_length);
324 * cmd->t_mem_bidi_list
328 for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) {
348 sbc_execute_rw(struct se_cmd *cmd)
350 return cmd->execute_rw(cmd, cmd->t_data_sg, cmd->t_data_nents,
351 cmd->data_direction);
354 static sense_reason_t compare_and_write_post(struct se_cmd *cmd)
356 struct se_device *dev = cmd->se_dev;
363 spin_lock_irq(&cmd->t_state_lock);
364 if ((cmd->transport_state & CMD_T_SENT) && !cmd->scsi_status)
365 cmd->se_cmd_flags |= SCF_COMPARE_AND_WRITE_POST;
366 spin_unlock_irq(&cmd->t_state_lock);
377 static sense_reason_t compare_and_write_callback(struct se_cmd *cmd)
379 struct se_device *dev = cmd->se_dev;
384 unsigned int nlbas = cmd->t_task_nolb;
394 if (!cmd->t_data_sg || !cmd->t_bidi_data_sg)
400 if (cmd->scsi_status) {
402 " 0x%02x\n", cmd->scsi_status);
406 buf = kzalloc(cmd->data_length, GFP_KERNEL);
413 write_sg = kmalloc(sizeof(struct scatterlist) * cmd->t_data_nents,
420 sg_init_table(write_sg, cmd->t_data_nents);
424 rc = sg_copy_to_buffer(cmd->t_data_sg, cmd->t_data_nents, buf,
425 cmd->data_length);
434 for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, i) {
458 len = cmd->t_task_nolb * block_size;
459 sg_miter_start(&m, cmd->t_data_sg, cmd->t_data_nents, SG_MITER_TO_SG);
483 cmd->t_data_sg_orig = cmd->t_data_sg;
484 cmd->t_data_sg = write_sg;
485 cmd->t_data_nents_orig = cmd->t_data_nents;
486 cmd->t_data_nents = 1;
488 cmd->sam_task_attr = MSG_HEAD_TAG;
489 cmd->transport_complete_callback = compare_and_write_post;
494 cmd->execute_cmd = sbc_execute_rw;
496 spin_lock_irq(&cmd->t_state_lock);
497 cmd->t_state = TRANSPORT_PROCESSING;
498 cmd->transport_state |= CMD_T_ACTIVE|CMD_T_BUSY|CMD_T_SENT;
499 spin_unlock_irq(&cmd->t_state_lock);
501 __target_execute_cmd(cmd);
522 sbc_compare_and_write(struct se_cmd *cmd)
524 struct se_device *dev = cmd->se_dev;
529 * comparision using SGLs at cmd->t_bidi_data_sg..
533 cmd->transport_complete_callback = NULL;
537 * Reset cmd->data_length to individual block_size in order to not
541 cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size;
543 ret = cmd->execute_rw(cmd, cmd->t_bidi_data_sg, cmd->t_bidi_data_nents,
546 cmd->transport_complete_callback = NULL;
560 bool is_write, struct se_cmd *cmd)
563 cmd->prot_op = protect ? TARGET_PROT_DOUT_PASS :
568 cmd->prot_checks = 0;
572 cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
574 cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG;
578 cmd->prot_checks = TARGET_DIF_CHECK_REFTAG;
581 cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
588 cmd->prot_op = protect ? TARGET_PROT_DIN_PASS :
594 cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
596 cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG;
600 cmd->prot_checks = TARGET_DIF_CHECK_REFTAG;
603 cmd->prot_checks = 0;
606 cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
618 sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb,
623 if ((!cmd->t_prot_sg || !cmd->t_prot_nents) && cmd->prot_pto)
628 cmd->reftag_seed = 0xffffffff;
634 cmd->reftag_seed = cmd->t_task_lba;
637 cmd->reftag_seed = cmd->t_task_lba;
645 is_write, cmd))
648 cmd->prot_type = dev->dev_attrib.pi_prot_type;
649 cmd->prot_length = dev->prot_length * sectors;
658 cmd->data_length = sectors * dev->dev_attrib.block_size;
662 __func__, cmd->prot_type, cmd->data_length, cmd->prot_length,
663 cmd->prot_op, cmd->prot_checks);
669 sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
671 struct se_device *dev = cmd->se_dev;
672 unsigned char *cdb = cmd->t_task_cdb;
680 cmd->t_task_lba = transport_lba_21(cdb);
681 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
682 cmd->execute_rw = ops->execute_rw;
683 cmd->execute_cmd = sbc_execute_rw;
687 cmd->t_task_lba = transport_lba_32(cdb);
689 if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
692 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
693 cmd->execute_rw = ops->execute_rw;
694 cmd->execute_cmd = sbc_execute_rw;
698 cmd->t_task_lba = transport_lba_32(cdb);
700 if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
703 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
704 cmd->execute_rw = ops->execute_rw;
705 cmd->execute_cmd = sbc_execute_rw;
709 cmd->t_task_lba = transport_lba_64(cdb);
711 if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
714 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
715 cmd->execute_rw = ops->execute_rw;
716 cmd->execute_cmd = sbc_execute_rw;
720 cmd->t_task_lba = transport_lba_21(cdb);
721 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
722 cmd->execute_rw = ops->execute_rw;
723 cmd->execute_cmd = sbc_execute_rw;
728 cmd->t_task_lba = transport_lba_32(cdb);
730 if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
734 cmd->se_cmd_flags |= SCF_FUA;
735 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
736 cmd->execute_rw = ops->execute_rw;
737 cmd->execute_cmd = sbc_execute_rw;
741 cmd->t_task_lba = transport_lba_32(cdb);
743 if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
747 cmd->se_cmd_flags |= SCF_FUA;
748 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
749 cmd->execute_rw = ops->execute_rw;
750 cmd->execute_cmd = sbc_execute_rw;
754 cmd->t_task_lba = transport_lba_64(cdb);
756 if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
760 cmd->se_cmd_flags |= SCF_FUA;
761 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
762 cmd->execute_rw = ops->execute_rw;
763 cmd->execute_cmd = sbc_execute_rw;
766 if (cmd->data_direction != DMA_TO_DEVICE ||
767 !(cmd->se_cmd_flags & SCF_BIDI))
771 cmd->t_task_lba = transport_lba_32(cdb);
772 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
777 cmd->execute_rw = ops->execute_rw;
778 cmd->execute_cmd = sbc_execute_rw;
779 cmd->transport_complete_callback = &xdreadwrite_callback;
781 cmd->se_cmd_flags |= SCF_FUA;
794 cmd->t_task_lba = transport_lba_64_ext(cdb);
795 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
801 cmd->execute_rw = ops->execute_rw;
802 cmd->execute_cmd = sbc_execute_rw;
803 cmd->transport_complete_callback = &xdreadwrite_callback;
805 cmd->se_cmd_flags |= SCF_FUA;
815 size = sbc_get_size(cmd, 1);
816 cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
818 ret = sbc_setup_write_same(cmd, &cdb[10], ops);
843 size = 2 * sbc_get_size(cmd, sectors);
844 cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
845 cmd->t_task_nolb = sectors;
846 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB | SCF_COMPARE_AND_WRITE;
847 cmd->execute_rw = ops->execute_rw;
848 cmd->execute_cmd = sbc_compare_and_write;
849 cmd->transport_complete_callback = compare_and_write_callback;
853 cmd->execute_cmd = sbc_emulate_readcapacity;
856 switch (cmd->t_task_cdb[1] & 0x1f) {
858 cmd->execute_cmd = sbc_emulate_readcapacity_16;
861 cmd->execute_cmd = target_emulate_report_referrals;
865 cmd->t_task_cdb[1] & 0x1f);
875 cmd->t_task_lba = transport_lba_32(cdb);
878 cmd->t_task_lba = transport_lba_64(cdb);
881 cmd->execute_cmd = ops->execute_sync_cache;
885 cmd->execute_cmd = sbc_emulate_noop;
892 cmd->execute_cmd = ops->execute_unmap;
901 size = sbc_get_size(cmd, 1);
902 cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
904 ret = sbc_setup_write_same(cmd, &cdb[1], ops);
915 size = sbc_get_size(cmd, 1);
916 cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
922 ret = sbc_setup_write_same(cmd, &cdb[1], ops);
929 cmd->t_task_lba = transport_lba_32(cdb);
930 cmd->execute_cmd = sbc_emulate_noop;
942 cmd->execute_cmd = sbc_emulate_noop;
945 ret = spc_parse_cdb(cmd, &size);
951 if (!cmd->execute_cmd)
954 if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
973 if (cmd->t_task_lba + sectors > end_lba) {
974 pr_err("cmd exceeds last lba %llu "
976 end_lba, cmd->t_task_lba, sectors);
980 if (!(cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE))
981 size = sbc_get_size(cmd, sectors);
984 return target_cmd_size_check(cmd, size);
995 sbc_execute_unmap(struct se_cmd *cmd,
1000 struct se_device *dev = cmd->se_dev;
1009 if (cmd->t_task_cdb[1])
1012 if (cmd->data_length == 0) {
1013 target_complete_cmd(cmd, SAM_STAT_GOOD);
1017 if (cmd->data_length < 8) {
1019 cmd->data_length);
1023 buf = transport_kmap_data_sg(cmd);
1030 size = cmd->data_length - 8;
1033 cmd->data_length, bd_dl);
1063 ret = do_unmap_fn(cmd, priv, lba, range);
1072 transport_kunmap_data_sg(cmd);
1074 target_complete_cmd(cmd, GOOD);
1080 sbc_dif_generate(struct se_cmd *cmd)
1082 struct se_device *dev = cmd->se_dev;
1084 struct scatterlist *dsg, *psg = cmd->t_prot_sg;
1085 sector_t sector = cmd->t_task_lba;
1089 for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
1159 sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read,
1162 struct se_device *dev = cmd->se_dev;
1170 for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) {
1200 sbc_dif_verify_write(struct se_cmd *cmd, sector_t start, unsigned int sectors,
1203 struct se_device *dev = cmd->se_dev;
1205 struct scatterlist *dsg, *psg = cmd->t_prot_sg;
1211 for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
1236 cmd->bad_sector = sector;
1248 sbc_dif_copy_prot(cmd, sectors, false, sg, sg_off);
1255 __sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors,
1258 struct se_device *dev = cmd->se_dev;
1266 for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
1297 cmd->bad_sector = sector;
1314 sbc_dif_read_strip(struct se_cmd *cmd)
1316 struct se_device *dev = cmd->se_dev;
1317 u32 sectors = cmd->prot_length / dev->prot_length;
1319 return __sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors, 0,
1320 cmd->t_prot_sg, 0);
1324 sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors,
1329 rc = __sbc_dif_verify_read(cmd, start, sectors, ei_lba, sg, sg_off);
1333 sbc_dif_copy_prot(cmd, sectors, true, sg, sg_off);