Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * SCSI Block Commands (SBC) parsing and emulation.
0004  *
0005  * (c) Copyright 2002-2013 Datera, Inc.
0006  *
0007  * Nicholas A. Bellinger <nab@kernel.org>
0008  */
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/ratelimit.h>
0013 #include <linux/crc-t10dif.h>
0014 #include <linux/t10-pi.h>
0015 #include <asm/unaligned.h>
0016 #include <scsi/scsi_proto.h>
0017 #include <scsi/scsi_tcq.h>
0018 
0019 #include <target/target_core_base.h>
0020 #include <target/target_core_backend.h>
0021 #include <target/target_core_fabric.h>
0022 
0023 #include "target_core_internal.h"
0024 #include "target_core_ua.h"
0025 #include "target_core_alua.h"
0026 
0027 static sense_reason_t
0028 sbc_check_prot(struct se_device *, struct se_cmd *, unsigned char, u32, bool);
0029 static sense_reason_t sbc_execute_unmap(struct se_cmd *cmd);
0030 
0031 static sense_reason_t
0032 sbc_emulate_readcapacity(struct se_cmd *cmd)
0033 {
0034     struct se_device *dev = cmd->se_dev;
0035     unsigned char *cdb = cmd->t_task_cdb;
0036     unsigned long long blocks_long = dev->transport->get_blocks(dev);
0037     unsigned char *rbuf;
0038     unsigned char buf[8];
0039     u32 blocks;
0040 
0041     /*
0042      * SBC-2 says:
0043      *   If the PMI bit is set to zero and the LOGICAL BLOCK
0044      *   ADDRESS field is not set to zero, the device server shall
0045      *   terminate the command with CHECK CONDITION status with
0046      *   the sense key set to ILLEGAL REQUEST and the additional
0047      *   sense code set to INVALID FIELD IN CDB.
0048      *
0049      * In SBC-3, these fields are obsolete, but some SCSI
0050      * compliance tests actually check this, so we might as well
0051      * follow SBC-2.
0052      */
0053     if (!(cdb[8] & 1) && !!(cdb[2] | cdb[3] | cdb[4] | cdb[5]))
0054         return TCM_INVALID_CDB_FIELD;
0055 
0056     if (blocks_long >= 0x00000000ffffffff)
0057         blocks = 0xffffffff;
0058     else
0059         blocks = (u32)blocks_long;
0060 
0061     put_unaligned_be32(blocks, &buf[0]);
0062     put_unaligned_be32(dev->dev_attrib.block_size, &buf[4]);
0063 
0064     rbuf = transport_kmap_data_sg(cmd);
0065     if (rbuf) {
0066         memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
0067         transport_kunmap_data_sg(cmd);
0068     }
0069 
0070     target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, 8);
0071     return 0;
0072 }
0073 
0074 static sense_reason_t
0075 sbc_emulate_readcapacity_16(struct se_cmd *cmd)
0076 {
0077     struct se_device *dev = cmd->se_dev;
0078     struct se_session *sess = cmd->se_sess;
0079     int pi_prot_type = dev->dev_attrib.pi_prot_type;
0080 
0081     unsigned char *rbuf;
0082     unsigned char buf[32];
0083     unsigned long long blocks = dev->transport->get_blocks(dev);
0084 
0085     memset(buf, 0, sizeof(buf));
0086     put_unaligned_be64(blocks, &buf[0]);
0087     put_unaligned_be32(dev->dev_attrib.block_size, &buf[8]);
0088     /*
0089      * Set P_TYPE and PROT_EN bits for DIF support
0090      */
0091     if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
0092         /*
0093          * Only override a device's pi_prot_type if no T10-PI is
0094          * available, and sess_prot_type has been explicitly enabled.
0095          */
0096         if (!pi_prot_type)
0097             pi_prot_type = sess->sess_prot_type;
0098 
0099         if (pi_prot_type)
0100             buf[12] = (pi_prot_type - 1) << 1 | 0x1;
0101     }
0102 
0103     if (dev->transport->get_lbppbe)
0104         buf[13] = dev->transport->get_lbppbe(dev) & 0x0f;
0105 
0106     if (dev->transport->get_alignment_offset_lbas) {
0107         u16 lalba = dev->transport->get_alignment_offset_lbas(dev);
0108 
0109         put_unaligned_be16(lalba, &buf[14]);
0110     }
0111 
0112     /*
0113      * Set Thin Provisioning Enable bit following sbc3r22 in section
0114      * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled.
0115      */
0116     if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws) {
0117         buf[14] |= 0x80;
0118 
0119         /*
0120          * LBPRZ signifies that zeroes will be read back from an LBA after
0121          * an UNMAP or WRITE SAME w/ unmap bit (sbc3r36 5.16.2)
0122          */
0123         if (dev->dev_attrib.unmap_zeroes_data)
0124             buf[14] |= 0x40;
0125     }
0126 
0127     rbuf = transport_kmap_data_sg(cmd);
0128     if (rbuf) {
0129         memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
0130         transport_kunmap_data_sg(cmd);
0131     }
0132 
0133     target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, 32);
0134     return 0;
0135 }
0136 
0137 static sense_reason_t
0138 sbc_emulate_startstop(struct se_cmd *cmd)
0139 {
0140     unsigned char *cdb = cmd->t_task_cdb;
0141 
0142     /*
0143      * See sbc3r36 section 5.25
0144      * Immediate bit should be set since there is nothing to complete
0145      * POWER CONDITION MODIFIER 0h
0146      */
0147     if (!(cdb[1] & 1) || cdb[2] || cdb[3])
0148         return TCM_INVALID_CDB_FIELD;
0149 
0150     /*
0151      * See sbc3r36 section 5.25
0152      * POWER CONDITION 0h START_VALID - process START and LOEJ
0153      */
0154     if (cdb[4] >> 4 & 0xf)
0155         return TCM_INVALID_CDB_FIELD;
0156 
0157     /*
0158      * See sbc3r36 section 5.25
0159      * LOEJ 0h - nothing to load or unload
0160      * START 1h - we are ready
0161      */
0162     if (!(cdb[4] & 1) || (cdb[4] & 2) || (cdb[4] & 4))
0163         return TCM_INVALID_CDB_FIELD;
0164 
0165     target_complete_cmd(cmd, SAM_STAT_GOOD);
0166     return 0;
0167 }
0168 
0169 sector_t sbc_get_write_same_sectors(struct se_cmd *cmd)
0170 {
0171     u32 num_blocks;
0172 
0173     if (cmd->t_task_cdb[0] == WRITE_SAME)
0174         num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]);
0175     else if (cmd->t_task_cdb[0] == WRITE_SAME_16)
0176         num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
0177     else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */
0178         num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
0179 
0180     /*
0181      * Use the explicit range when non zero is supplied, otherwise calculate
0182      * the remaining range based on ->get_blocks() - starting LBA.
0183      */
0184     if (num_blocks)
0185         return num_blocks;
0186 
0187     return cmd->se_dev->transport->get_blocks(cmd->se_dev) -
0188         cmd->t_task_lba + 1;
0189 }
0190 EXPORT_SYMBOL(sbc_get_write_same_sectors);
0191 
0192 static sense_reason_t
0193 sbc_execute_write_same_unmap(struct se_cmd *cmd)
0194 {
0195     struct sbc_ops *ops = cmd->protocol_data;
0196     sector_t nolb = sbc_get_write_same_sectors(cmd);
0197     sense_reason_t ret;
0198 
0199     if (nolb) {
0200         ret = ops->execute_unmap(cmd, cmd->t_task_lba, nolb);
0201         if (ret)
0202             return ret;
0203     }
0204 
0205     target_complete_cmd(cmd, SAM_STAT_GOOD);
0206     return 0;
0207 }
0208 
0209 static sense_reason_t
0210 sbc_emulate_noop(struct se_cmd *cmd)
0211 {
0212     target_complete_cmd(cmd, SAM_STAT_GOOD);
0213     return 0;
0214 }
0215 
0216 static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)
0217 {
0218     return cmd->se_dev->dev_attrib.block_size * sectors;
0219 }
0220 
0221 static inline u32 transport_get_sectors_6(unsigned char *cdb)
0222 {
0223     /*
0224      * Use 8-bit sector value.  SBC-3 says:
0225      *
0226      *   A TRANSFER LENGTH field set to zero specifies that 256
0227      *   logical blocks shall be written.  Any other value
0228      *   specifies the number of logical blocks that shall be
0229      *   written.
0230      */
0231     return cdb[4] ? : 256;
0232 }
0233 
0234 static inline u32 transport_get_sectors_10(unsigned char *cdb)
0235 {
0236     return get_unaligned_be16(&cdb[7]);
0237 }
0238 
0239 static inline u32 transport_get_sectors_12(unsigned char *cdb)
0240 {
0241     return get_unaligned_be32(&cdb[6]);
0242 }
0243 
0244 static inline u32 transport_get_sectors_16(unsigned char *cdb)
0245 {
0246     return get_unaligned_be32(&cdb[10]);
0247 }
0248 
0249 /*
0250  * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants
0251  */
0252 static inline u32 transport_get_sectors_32(unsigned char *cdb)
0253 {
0254     return get_unaligned_be32(&cdb[28]);
0255 
0256 }
0257 
0258 static inline u32 transport_lba_21(unsigned char *cdb)
0259 {
0260     return get_unaligned_be24(&cdb[1]) & 0x1fffff;
0261 }
0262 
0263 static inline u32 transport_lba_32(unsigned char *cdb)
0264 {
0265     return get_unaligned_be32(&cdb[2]);
0266 }
0267 
0268 static inline unsigned long long transport_lba_64(unsigned char *cdb)
0269 {
0270     return get_unaligned_be64(&cdb[2]);
0271 }
0272 
0273 /*
0274  * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs
0275  */
0276 static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
0277 {
0278     return get_unaligned_be64(&cdb[12]);
0279 }
0280 
0281 static sense_reason_t
0282 sbc_setup_write_same(struct se_cmd *cmd, unsigned char flags, struct sbc_ops *ops)
0283 {
0284     struct se_device *dev = cmd->se_dev;
0285     sector_t end_lba = dev->transport->get_blocks(dev) + 1;
0286     unsigned int sectors = sbc_get_write_same_sectors(cmd);
0287     sense_reason_t ret;
0288 
0289     if ((flags & 0x04) || (flags & 0x02)) {
0290         pr_err("WRITE_SAME PBDATA and LBDATA"
0291             " bits not supported for Block Discard"
0292             " Emulation\n");
0293         return TCM_UNSUPPORTED_SCSI_OPCODE;
0294     }
0295     if (sectors > cmd->se_dev->dev_attrib.max_write_same_len) {
0296         pr_warn("WRITE_SAME sectors: %u exceeds max_write_same_len: %u\n",
0297             sectors, cmd->se_dev->dev_attrib.max_write_same_len);
0298         return TCM_INVALID_CDB_FIELD;
0299     }
0300     /*
0301      * Sanity check for LBA wrap and request past end of device.
0302      */
0303     if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
0304         ((cmd->t_task_lba + sectors) > end_lba)) {
0305         pr_err("WRITE_SAME exceeds last lba %llu (lba %llu, sectors %u)\n",
0306                (unsigned long long)end_lba, cmd->t_task_lba, sectors);
0307         return TCM_ADDRESS_OUT_OF_RANGE;
0308     }
0309 
0310     /* We always have ANC_SUP == 0 so setting ANCHOR is always an error */
0311     if (flags & 0x10) {
0312         pr_warn("WRITE SAME with ANCHOR not supported\n");
0313         return TCM_INVALID_CDB_FIELD;
0314     }
0315 
0316     if (flags & 0x01) {
0317         pr_warn("WRITE SAME with NDOB not supported\n");
0318         return TCM_INVALID_CDB_FIELD;
0319     }
0320 
0321     /*
0322      * Special case for WRITE_SAME w/ UNMAP=1 that ends up getting
0323      * translated into block discard requests within backend code.
0324      */
0325     if (flags & 0x08) {
0326         if (!ops->execute_unmap)
0327             return TCM_UNSUPPORTED_SCSI_OPCODE;
0328 
0329         if (!dev->dev_attrib.emulate_tpws) {
0330             pr_err("Got WRITE_SAME w/ UNMAP=1, but backend device"
0331                    " has emulate_tpws disabled\n");
0332             return TCM_UNSUPPORTED_SCSI_OPCODE;
0333         }
0334         cmd->execute_cmd = sbc_execute_write_same_unmap;
0335         return 0;
0336     }
0337     if (!ops->execute_write_same)
0338         return TCM_UNSUPPORTED_SCSI_OPCODE;
0339 
0340     ret = sbc_check_prot(dev, cmd, flags >> 5, sectors, true);
0341     if (ret)
0342         return ret;
0343 
0344     cmd->execute_cmd = ops->execute_write_same;
0345     return 0;
0346 }
0347 
0348 static sense_reason_t
0349 sbc_execute_rw(struct se_cmd *cmd)
0350 {
0351     struct sbc_ops *ops = cmd->protocol_data;
0352 
0353     return ops->execute_rw(cmd, cmd->t_data_sg, cmd->t_data_nents,
0354                    cmd->data_direction);
0355 }
0356 
0357 static sense_reason_t compare_and_write_post(struct se_cmd *cmd, bool success,
0358                          int *post_ret)
0359 {
0360     struct se_device *dev = cmd->se_dev;
0361     sense_reason_t ret = TCM_NO_SENSE;
0362 
0363     spin_lock_irq(&cmd->t_state_lock);
0364     if (success) {
0365         *post_ret = 1;
0366 
0367         if (cmd->scsi_status == SAM_STAT_CHECK_CONDITION)
0368             ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
0369     }
0370     spin_unlock_irq(&cmd->t_state_lock);
0371 
0372     /*
0373      * Unlock ->caw_sem originally obtained during sbc_compare_and_write()
0374      * before the original READ I/O submission.
0375      */
0376     up(&dev->caw_sem);
0377 
0378     return ret;
0379 }
0380 
0381 /*
0382  * compare @cmp_len bytes of @read_sgl with @cmp_sgl. On miscompare, fill
0383  * @miscmp_off and return TCM_MISCOMPARE_VERIFY.
0384  */
0385 static sense_reason_t
0386 compare_and_write_do_cmp(struct scatterlist *read_sgl, unsigned int read_nents,
0387              struct scatterlist *cmp_sgl, unsigned int cmp_nents,
0388              unsigned int cmp_len, unsigned int *miscmp_off)
0389 {
0390     unsigned char *buf = NULL;
0391     struct scatterlist *sg;
0392     sense_reason_t ret;
0393     unsigned int offset;
0394     size_t rc;
0395     int sg_cnt;
0396 
0397     buf = kzalloc(cmp_len, GFP_KERNEL);
0398     if (!buf) {
0399         ret = TCM_OUT_OF_RESOURCES;
0400         goto out;
0401     }
0402 
0403     rc = sg_copy_to_buffer(cmp_sgl, cmp_nents, buf, cmp_len);
0404     if (!rc) {
0405         pr_err("sg_copy_to_buffer() failed for compare_and_write\n");
0406         ret = TCM_OUT_OF_RESOURCES;
0407         goto out;
0408     }
0409     /*
0410      * Compare SCSI READ payload against verify payload
0411      */
0412     offset = 0;
0413     ret = TCM_NO_SENSE;
0414     for_each_sg(read_sgl, sg, read_nents, sg_cnt) {
0415         unsigned int len = min(sg->length, cmp_len);
0416         unsigned char *addr = kmap_atomic(sg_page(sg));
0417 
0418         if (memcmp(addr, buf + offset, len)) {
0419             unsigned int i;
0420 
0421             for (i = 0; i < len && addr[i] == buf[offset + i]; i++)
0422                 ;
0423             *miscmp_off = offset + i;
0424             pr_warn("Detected MISCOMPARE at offset %u\n",
0425                 *miscmp_off);
0426             ret = TCM_MISCOMPARE_VERIFY;
0427         }
0428         kunmap_atomic(addr);
0429         if (ret != TCM_NO_SENSE)
0430             goto out;
0431 
0432         offset += len;
0433         cmp_len -= len;
0434         if (!cmp_len)
0435             break;
0436     }
0437     pr_debug("COMPARE AND WRITE read data matches compare data\n");
0438 out:
0439     kfree(buf);
0440     return ret;
0441 }
0442 
0443 static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool success,
0444                          int *post_ret)
0445 {
0446     struct se_device *dev = cmd->se_dev;
0447     struct sg_table write_tbl = { };
0448     struct scatterlist *write_sg;
0449     struct sg_mapping_iter m;
0450     unsigned int len;
0451     unsigned int block_size = dev->dev_attrib.block_size;
0452     unsigned int compare_len = (cmd->t_task_nolb * block_size);
0453     unsigned int miscmp_off = 0;
0454     sense_reason_t ret = TCM_NO_SENSE;
0455     int i;
0456 
0457     /*
0458      * Handle early failure in transport_generic_request_failure(),
0459      * which will not have taken ->caw_sem yet..
0460      */
0461     if (!success && (!cmd->t_data_sg || !cmd->t_bidi_data_sg))
0462         return TCM_NO_SENSE;
0463     /*
0464      * Handle special case for zero-length COMPARE_AND_WRITE
0465      */
0466     if (!cmd->data_length)
0467         goto out;
0468     /*
0469      * Immediately exit + release dev->caw_sem if command has already
0470      * been failed with a non-zero SCSI status.
0471      */
0472     if (cmd->scsi_status) {
0473         pr_debug("compare_and_write_callback: non zero scsi_status:"
0474             " 0x%02x\n", cmd->scsi_status);
0475         *post_ret = 1;
0476         if (cmd->scsi_status == SAM_STAT_CHECK_CONDITION)
0477             ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
0478         goto out;
0479     }
0480 
0481     ret = compare_and_write_do_cmp(cmd->t_bidi_data_sg,
0482                        cmd->t_bidi_data_nents,
0483                        cmd->t_data_sg,
0484                        cmd->t_data_nents,
0485                        compare_len,
0486                        &miscmp_off);
0487     if (ret == TCM_MISCOMPARE_VERIFY) {
0488         /*
0489          * SBC-4 r15: 5.3 COMPARE AND WRITE command
0490          * In the sense data (see 4.18 and SPC-5) the offset from the
0491          * start of the Data-Out Buffer to the first byte of data that
0492          * was not equal shall be reported in the INFORMATION field.
0493          */
0494         cmd->sense_info = miscmp_off;
0495         goto out;
0496     } else if (ret)
0497         goto out;
0498 
0499     if (sg_alloc_table(&write_tbl, cmd->t_data_nents, GFP_KERNEL) < 0) {
0500         pr_err("Unable to allocate compare_and_write sg\n");
0501         ret = TCM_OUT_OF_RESOURCES;
0502         goto out;
0503     }
0504     write_sg = write_tbl.sgl;
0505 
0506     i = 0;
0507     len = compare_len;
0508     sg_miter_start(&m, cmd->t_data_sg, cmd->t_data_nents, SG_MITER_TO_SG);
0509     /*
0510      * Currently assumes NoLB=1 and SGLs are PAGE_SIZE..
0511      */
0512     while (len) {
0513         sg_miter_next(&m);
0514 
0515         if (block_size < PAGE_SIZE) {
0516             sg_set_page(&write_sg[i], m.page, block_size,
0517                     m.piter.sg->offset + block_size);
0518         } else {
0519             sg_miter_next(&m);
0520             sg_set_page(&write_sg[i], m.page, block_size,
0521                     m.piter.sg->offset);
0522         }
0523         len -= block_size;
0524         i++;
0525     }
0526     sg_miter_stop(&m);
0527     /*
0528      * Save the original SGL + nents values before updating to new
0529      * assignments, to be released in transport_free_pages() ->
0530      * transport_reset_sgl_orig()
0531      */
0532     cmd->t_data_sg_orig = cmd->t_data_sg;
0533     cmd->t_data_sg = write_sg;
0534     cmd->t_data_nents_orig = cmd->t_data_nents;
0535     cmd->t_data_nents = 1;
0536 
0537     cmd->sam_task_attr = TCM_HEAD_TAG;
0538     cmd->transport_complete_callback = compare_and_write_post;
0539     /*
0540      * Now reset ->execute_cmd() to the normal sbc_execute_rw() handler
0541      * for submitting the adjusted SGL to write instance user-data.
0542      */
0543     cmd->execute_cmd = sbc_execute_rw;
0544 
0545     spin_lock_irq(&cmd->t_state_lock);
0546     cmd->t_state = TRANSPORT_PROCESSING;
0547     cmd->transport_state |= CMD_T_ACTIVE | CMD_T_SENT;
0548     spin_unlock_irq(&cmd->t_state_lock);
0549 
0550     __target_execute_cmd(cmd, false);
0551 
0552     return ret;
0553 
0554 out:
0555     /*
0556      * In the MISCOMPARE or failure case, unlock ->caw_sem obtained in
0557      * sbc_compare_and_write() before the original READ I/O submission.
0558      */
0559     up(&dev->caw_sem);
0560     sg_free_table(&write_tbl);
0561     return ret;
0562 }
0563 
0564 static sense_reason_t
0565 sbc_compare_and_write(struct se_cmd *cmd)
0566 {
0567     struct sbc_ops *ops = cmd->protocol_data;
0568     struct se_device *dev = cmd->se_dev;
0569     sense_reason_t ret;
0570     int rc;
0571     /*
0572      * Submit the READ first for COMPARE_AND_WRITE to perform the
0573      * comparision using SGLs at cmd->t_bidi_data_sg..
0574      */
0575     rc = down_interruptible(&dev->caw_sem);
0576     if (rc != 0) {
0577         cmd->transport_complete_callback = NULL;
0578         return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
0579     }
0580     /*
0581      * Reset cmd->data_length to individual block_size in order to not
0582      * confuse backend drivers that depend on this value matching the
0583      * size of the I/O being submitted.
0584      */
0585     cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size;
0586 
0587     ret = ops->execute_rw(cmd, cmd->t_bidi_data_sg, cmd->t_bidi_data_nents,
0588                   DMA_FROM_DEVICE);
0589     if (ret) {
0590         cmd->transport_complete_callback = NULL;
0591         up(&dev->caw_sem);
0592         return ret;
0593     }
0594     /*
0595      * Unlock of dev->caw_sem to occur in compare_and_write_callback()
0596      * upon MISCOMPARE, or in compare_and_write_done() upon completion
0597      * of WRITE instance user-data.
0598      */
0599     return TCM_NO_SENSE;
0600 }
0601 
0602 static int
0603 sbc_set_prot_op_checks(u8 protect, bool fabric_prot, enum target_prot_type prot_type,
0604                bool is_write, struct se_cmd *cmd)
0605 {
0606     if (is_write) {
0607         cmd->prot_op = fabric_prot ? TARGET_PROT_DOUT_STRIP :
0608                    protect ? TARGET_PROT_DOUT_PASS :
0609                    TARGET_PROT_DOUT_INSERT;
0610         switch (protect) {
0611         case 0x0:
0612         case 0x3:
0613             cmd->prot_checks = 0;
0614             break;
0615         case 0x1:
0616         case 0x5:
0617             cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
0618             if (prot_type == TARGET_DIF_TYPE1_PROT)
0619                 cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG;
0620             break;
0621         case 0x2:
0622             if (prot_type == TARGET_DIF_TYPE1_PROT)
0623                 cmd->prot_checks = TARGET_DIF_CHECK_REFTAG;
0624             break;
0625         case 0x4:
0626             cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
0627             break;
0628         default:
0629             pr_err("Unsupported protect field %d\n", protect);
0630             return -EINVAL;
0631         }
0632     } else {
0633         cmd->prot_op = fabric_prot ? TARGET_PROT_DIN_INSERT :
0634                    protect ? TARGET_PROT_DIN_PASS :
0635                    TARGET_PROT_DIN_STRIP;
0636         switch (protect) {
0637         case 0x0:
0638         case 0x1:
0639         case 0x5:
0640             cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
0641             if (prot_type == TARGET_DIF_TYPE1_PROT)
0642                 cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG;
0643             break;
0644         case 0x2:
0645             if (prot_type == TARGET_DIF_TYPE1_PROT)
0646                 cmd->prot_checks = TARGET_DIF_CHECK_REFTAG;
0647             break;
0648         case 0x3:
0649             cmd->prot_checks = 0;
0650             break;
0651         case 0x4:
0652             cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
0653             break;
0654         default:
0655             pr_err("Unsupported protect field %d\n", protect);
0656             return -EINVAL;
0657         }
0658     }
0659 
0660     return 0;
0661 }
0662 
0663 static sense_reason_t
0664 sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,
0665            u32 sectors, bool is_write)
0666 {
0667     int sp_ops = cmd->se_sess->sup_prot_ops;
0668     int pi_prot_type = dev->dev_attrib.pi_prot_type;
0669     bool fabric_prot = false;
0670 
0671     if (!cmd->t_prot_sg || !cmd->t_prot_nents) {
0672         if (unlikely(protect &&
0673             !dev->dev_attrib.pi_prot_type && !cmd->se_sess->sess_prot_type)) {
0674             pr_err("CDB contains protect bit, but device + fabric does"
0675                    " not advertise PROTECT=1 feature bit\n");
0676             return TCM_INVALID_CDB_FIELD;
0677         }
0678         if (cmd->prot_pto)
0679             return TCM_NO_SENSE;
0680     }
0681 
0682     switch (dev->dev_attrib.pi_prot_type) {
0683     case TARGET_DIF_TYPE3_PROT:
0684         cmd->reftag_seed = 0xffffffff;
0685         break;
0686     case TARGET_DIF_TYPE2_PROT:
0687         if (protect)
0688             return TCM_INVALID_CDB_FIELD;
0689 
0690         cmd->reftag_seed = cmd->t_task_lba;
0691         break;
0692     case TARGET_DIF_TYPE1_PROT:
0693         cmd->reftag_seed = cmd->t_task_lba;
0694         break;
0695     case TARGET_DIF_TYPE0_PROT:
0696         /*
0697          * See if the fabric supports T10-PI, and the session has been
0698          * configured to allow export PROTECT=1 feature bit with backend
0699          * devices that don't support T10-PI.
0700          */
0701         fabric_prot = is_write ?
0702                   !!(sp_ops & (TARGET_PROT_DOUT_PASS | TARGET_PROT_DOUT_STRIP)) :
0703                   !!(sp_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DIN_INSERT));
0704 
0705         if (fabric_prot && cmd->se_sess->sess_prot_type) {
0706             pi_prot_type = cmd->se_sess->sess_prot_type;
0707             break;
0708         }
0709         if (!protect)
0710             return TCM_NO_SENSE;
0711         fallthrough;
0712     default:
0713         pr_err("Unable to determine pi_prot_type for CDB: 0x%02x "
0714                "PROTECT: 0x%02x\n", cmd->t_task_cdb[0], protect);
0715         return TCM_INVALID_CDB_FIELD;
0716     }
0717 
0718     if (sbc_set_prot_op_checks(protect, fabric_prot, pi_prot_type, is_write, cmd))
0719         return TCM_INVALID_CDB_FIELD;
0720 
0721     cmd->prot_type = pi_prot_type;
0722     cmd->prot_length = dev->prot_length * sectors;
0723 
0724     /**
0725      * In case protection information exists over the wire
0726      * we modify command data length to describe pure data.
0727      * The actual transfer length is data length + protection
0728      * length
0729      **/
0730     if (protect)
0731         cmd->data_length = sectors * dev->dev_attrib.block_size;
0732 
0733     pr_debug("%s: prot_type=%d, data_length=%d, prot_length=%d "
0734          "prot_op=%d prot_checks=%d\n",
0735          __func__, cmd->prot_type, cmd->data_length, cmd->prot_length,
0736          cmd->prot_op, cmd->prot_checks);
0737 
0738     return TCM_NO_SENSE;
0739 }
0740 
0741 static int
0742 sbc_check_dpofua(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb)
0743 {
0744     if (cdb[1] & 0x10) {
0745         /* see explanation in spc_emulate_modesense */
0746         if (!target_check_fua(dev)) {
0747             pr_err("Got CDB: 0x%02x with DPO bit set, but device"
0748                    " does not advertise support for DPO\n", cdb[0]);
0749             return -EINVAL;
0750         }
0751     }
0752     if (cdb[1] & 0x8) {
0753         if (!target_check_fua(dev)) {
0754             pr_err("Got CDB: 0x%02x with FUA bit set, but device"
0755                    " does not advertise support for FUA write\n",
0756                    cdb[0]);
0757             return -EINVAL;
0758         }
0759         cmd->se_cmd_flags |= SCF_FUA;
0760     }
0761     return 0;
0762 }
0763 
0764 sense_reason_t
0765 sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
0766 {
0767     struct se_device *dev = cmd->se_dev;
0768     unsigned char *cdb = cmd->t_task_cdb;
0769     unsigned int size;
0770     u32 sectors = 0;
0771     sense_reason_t ret;
0772 
0773     cmd->protocol_data = ops;
0774 
0775     switch (cdb[0]) {
0776     case READ_6:
0777         sectors = transport_get_sectors_6(cdb);
0778         cmd->t_task_lba = transport_lba_21(cdb);
0779         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
0780         cmd->execute_cmd = sbc_execute_rw;
0781         break;
0782     case READ_10:
0783         sectors = transport_get_sectors_10(cdb);
0784         cmd->t_task_lba = transport_lba_32(cdb);
0785 
0786         if (sbc_check_dpofua(dev, cmd, cdb))
0787             return TCM_INVALID_CDB_FIELD;
0788 
0789         ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, false);
0790         if (ret)
0791             return ret;
0792 
0793         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
0794         cmd->execute_cmd = sbc_execute_rw;
0795         break;
0796     case READ_12:
0797         sectors = transport_get_sectors_12(cdb);
0798         cmd->t_task_lba = transport_lba_32(cdb);
0799 
0800         if (sbc_check_dpofua(dev, cmd, cdb))
0801             return TCM_INVALID_CDB_FIELD;
0802 
0803         ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, false);
0804         if (ret)
0805             return ret;
0806 
0807         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
0808         cmd->execute_cmd = sbc_execute_rw;
0809         break;
0810     case READ_16:
0811         sectors = transport_get_sectors_16(cdb);
0812         cmd->t_task_lba = transport_lba_64(cdb);
0813 
0814         if (sbc_check_dpofua(dev, cmd, cdb))
0815             return TCM_INVALID_CDB_FIELD;
0816 
0817         ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, false);
0818         if (ret)
0819             return ret;
0820 
0821         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
0822         cmd->execute_cmd = sbc_execute_rw;
0823         break;
0824     case WRITE_6:
0825         sectors = transport_get_sectors_6(cdb);
0826         cmd->t_task_lba = transport_lba_21(cdb);
0827         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
0828         cmd->execute_cmd = sbc_execute_rw;
0829         break;
0830     case WRITE_10:
0831     case WRITE_VERIFY:
0832         sectors = transport_get_sectors_10(cdb);
0833         cmd->t_task_lba = transport_lba_32(cdb);
0834 
0835         if (sbc_check_dpofua(dev, cmd, cdb))
0836             return TCM_INVALID_CDB_FIELD;
0837 
0838         ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, true);
0839         if (ret)
0840             return ret;
0841 
0842         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
0843         cmd->execute_cmd = sbc_execute_rw;
0844         break;
0845     case WRITE_12:
0846         sectors = transport_get_sectors_12(cdb);
0847         cmd->t_task_lba = transport_lba_32(cdb);
0848 
0849         if (sbc_check_dpofua(dev, cmd, cdb))
0850             return TCM_INVALID_CDB_FIELD;
0851 
0852         ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, true);
0853         if (ret)
0854             return ret;
0855 
0856         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
0857         cmd->execute_cmd = sbc_execute_rw;
0858         break;
0859     case WRITE_16:
0860     case WRITE_VERIFY_16:
0861         sectors = transport_get_sectors_16(cdb);
0862         cmd->t_task_lba = transport_lba_64(cdb);
0863 
0864         if (sbc_check_dpofua(dev, cmd, cdb))
0865             return TCM_INVALID_CDB_FIELD;
0866 
0867         ret = sbc_check_prot(dev, cmd, cdb[1] >> 5, sectors, true);
0868         if (ret)
0869             return ret;
0870 
0871         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
0872         cmd->execute_cmd = sbc_execute_rw;
0873         break;
0874     case VARIABLE_LENGTH_CMD:
0875     {
0876         u16 service_action = get_unaligned_be16(&cdb[8]);
0877         switch (service_action) {
0878         case WRITE_SAME_32:
0879             sectors = transport_get_sectors_32(cdb);
0880             if (!sectors) {
0881                 pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
0882                        " supported\n");
0883                 return TCM_INVALID_CDB_FIELD;
0884             }
0885 
0886             size = sbc_get_size(cmd, 1);
0887             cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
0888 
0889             ret = sbc_setup_write_same(cmd, cdb[10], ops);
0890             if (ret)
0891                 return ret;
0892             break;
0893         default:
0894             pr_err("VARIABLE_LENGTH_CMD service action"
0895                 " 0x%04x not supported\n", service_action);
0896             return TCM_UNSUPPORTED_SCSI_OPCODE;
0897         }
0898         break;
0899     }
0900     case COMPARE_AND_WRITE:
0901         if (!dev->dev_attrib.emulate_caw) {
0902             pr_err_ratelimited("se_device %s/%s (vpd_unit_serial %s) reject COMPARE_AND_WRITE\n",
0903                        dev->se_hba->backend->ops->name,
0904                        config_item_name(&dev->dev_group.cg_item),
0905                        dev->t10_wwn.unit_serial);
0906             return TCM_UNSUPPORTED_SCSI_OPCODE;
0907         }
0908         sectors = cdb[13];
0909         /*
0910          * Currently enforce COMPARE_AND_WRITE for a single sector
0911          */
0912         if (sectors > 1) {
0913             pr_err("COMPARE_AND_WRITE contains NoLB: %u greater"
0914                    " than 1\n", sectors);
0915             return TCM_INVALID_CDB_FIELD;
0916         }
0917         if (sbc_check_dpofua(dev, cmd, cdb))
0918             return TCM_INVALID_CDB_FIELD;
0919 
0920         /*
0921          * Double size because we have two buffers, note that
0922          * zero is not an error..
0923          */
0924         size = 2 * sbc_get_size(cmd, sectors);
0925         cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
0926         cmd->t_task_nolb = sectors;
0927         cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB | SCF_COMPARE_AND_WRITE;
0928         cmd->execute_cmd = sbc_compare_and_write;
0929         cmd->transport_complete_callback = compare_and_write_callback;
0930         break;
0931     case READ_CAPACITY:
0932         size = READ_CAP_LEN;
0933         cmd->execute_cmd = sbc_emulate_readcapacity;
0934         break;
0935     case SERVICE_ACTION_IN_16:
0936         switch (cmd->t_task_cdb[1] & 0x1f) {
0937         case SAI_READ_CAPACITY_16:
0938             cmd->execute_cmd = sbc_emulate_readcapacity_16;
0939             break;
0940         case SAI_REPORT_REFERRALS:
0941             cmd->execute_cmd = target_emulate_report_referrals;
0942             break;
0943         default:
0944             pr_err("Unsupported SA: 0x%02x\n",
0945                 cmd->t_task_cdb[1] & 0x1f);
0946             return TCM_INVALID_CDB_FIELD;
0947         }
0948         size = get_unaligned_be32(&cdb[10]);
0949         break;
0950     case SYNCHRONIZE_CACHE:
0951     case SYNCHRONIZE_CACHE_16:
0952         if (cdb[0] == SYNCHRONIZE_CACHE) {
0953             sectors = transport_get_sectors_10(cdb);
0954             cmd->t_task_lba = transport_lba_32(cdb);
0955         } else {
0956             sectors = transport_get_sectors_16(cdb);
0957             cmd->t_task_lba = transport_lba_64(cdb);
0958         }
0959         if (ops->execute_sync_cache) {
0960             cmd->execute_cmd = ops->execute_sync_cache;
0961             goto check_lba;
0962         }
0963         size = 0;
0964         cmd->execute_cmd = sbc_emulate_noop;
0965         break;
0966     case UNMAP:
0967         if (!ops->execute_unmap)
0968             return TCM_UNSUPPORTED_SCSI_OPCODE;
0969 
0970         if (!dev->dev_attrib.emulate_tpu) {
0971             pr_err("Got UNMAP, but backend device has"
0972                    " emulate_tpu disabled\n");
0973             return TCM_UNSUPPORTED_SCSI_OPCODE;
0974         }
0975         size = get_unaligned_be16(&cdb[7]);
0976         cmd->execute_cmd = sbc_execute_unmap;
0977         break;
0978     case WRITE_SAME_16:
0979         sectors = transport_get_sectors_16(cdb);
0980         if (!sectors) {
0981             pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
0982             return TCM_INVALID_CDB_FIELD;
0983         }
0984 
0985         size = sbc_get_size(cmd, 1);
0986         cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
0987 
0988         ret = sbc_setup_write_same(cmd, cdb[1], ops);
0989         if (ret)
0990             return ret;
0991         break;
0992     case WRITE_SAME:
0993         sectors = transport_get_sectors_10(cdb);
0994         if (!sectors) {
0995             pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
0996             return TCM_INVALID_CDB_FIELD;
0997         }
0998 
0999         size = sbc_get_size(cmd, 1);
1000         cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
1001 
1002         /*
1003          * Follow sbcr26 with WRITE_SAME (10) and check for the existence
1004          * of byte 1 bit 3 UNMAP instead of original reserved field
1005          */
1006         ret = sbc_setup_write_same(cmd, cdb[1], ops);
1007         if (ret)
1008             return ret;
1009         break;
1010     case VERIFY:
1011     case VERIFY_16:
1012         size = 0;
1013         if (cdb[0] == VERIFY) {
1014             sectors = transport_get_sectors_10(cdb);
1015             cmd->t_task_lba = transport_lba_32(cdb);
1016         } else {
1017             sectors = transport_get_sectors_16(cdb);
1018             cmd->t_task_lba = transport_lba_64(cdb);
1019         }
1020         cmd->execute_cmd = sbc_emulate_noop;
1021         goto check_lba;
1022     case REZERO_UNIT:
1023     case SEEK_6:
1024     case SEEK_10:
1025         /*
1026          * There are still clients out there which use these old SCSI-2
1027          * commands. This mainly happens when running VMs with legacy
1028          * guest systems, connected via SCSI command pass-through to
1029          * iSCSI targets. Make them happy and return status GOOD.
1030          */
1031         size = 0;
1032         cmd->execute_cmd = sbc_emulate_noop;
1033         break;
1034     case START_STOP:
1035         size = 0;
1036         cmd->execute_cmd = sbc_emulate_startstop;
1037         break;
1038     default:
1039         ret = spc_parse_cdb(cmd, &size);
1040         if (ret)
1041             return ret;
1042     }
1043 
1044     /* reject any command that we don't have a handler for */
1045     if (!cmd->execute_cmd)
1046         return TCM_UNSUPPORTED_SCSI_OPCODE;
1047 
1048     if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
1049         unsigned long long end_lba;
1050 check_lba:
1051         end_lba = dev->transport->get_blocks(dev) + 1;
1052         if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
1053             ((cmd->t_task_lba + sectors) > end_lba)) {
1054             pr_err("cmd exceeds last lba %llu "
1055                 "(lba %llu, sectors %u)\n",
1056                 end_lba, cmd->t_task_lba, sectors);
1057             return TCM_ADDRESS_OUT_OF_RANGE;
1058         }
1059 
1060         if (!(cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE))
1061             size = sbc_get_size(cmd, sectors);
1062     }
1063 
1064     return target_cmd_size_check(cmd, size);
1065 }
1066 EXPORT_SYMBOL(sbc_parse_cdb);
1067 
1068 u32 sbc_get_device_type(struct se_device *dev)
1069 {
1070     return TYPE_DISK;
1071 }
1072 EXPORT_SYMBOL(sbc_get_device_type);
1073 
1074 static sense_reason_t
1075 sbc_execute_unmap(struct se_cmd *cmd)
1076 {
1077     struct sbc_ops *ops = cmd->protocol_data;
1078     struct se_device *dev = cmd->se_dev;
1079     unsigned char *buf, *ptr = NULL;
1080     sector_t lba;
1081     int size;
1082     u32 range;
1083     sense_reason_t ret = 0;
1084     int dl, bd_dl;
1085 
1086     /* We never set ANC_SUP */
1087     if (cmd->t_task_cdb[1])
1088         return TCM_INVALID_CDB_FIELD;
1089 
1090     if (cmd->data_length == 0) {
1091         target_complete_cmd(cmd, SAM_STAT_GOOD);
1092         return 0;
1093     }
1094 
1095     if (cmd->data_length < 8) {
1096         pr_warn("UNMAP parameter list length %u too small\n",
1097             cmd->data_length);
1098         return TCM_PARAMETER_LIST_LENGTH_ERROR;
1099     }
1100 
1101     buf = transport_kmap_data_sg(cmd);
1102     if (!buf)
1103         return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1104 
1105     dl = get_unaligned_be16(&buf[0]);
1106     bd_dl = get_unaligned_be16(&buf[2]);
1107 
1108     size = cmd->data_length - 8;
1109     if (bd_dl > size)
1110         pr_warn("UNMAP parameter list length %u too small, ignoring bd_dl %u\n",
1111             cmd->data_length, bd_dl);
1112     else
1113         size = bd_dl;
1114 
1115     if (size / 16 > dev->dev_attrib.max_unmap_block_desc_count) {
1116         ret = TCM_INVALID_PARAMETER_LIST;
1117         goto err;
1118     }
1119 
1120     /* First UNMAP block descriptor starts at 8 byte offset */
1121     ptr = &buf[8];
1122     pr_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u"
1123         " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr);
1124 
1125     while (size >= 16) {
1126         lba = get_unaligned_be64(&ptr[0]);
1127         range = get_unaligned_be32(&ptr[8]);
1128         pr_debug("UNMAP: Using lba: %llu and range: %u\n",
1129                  (unsigned long long)lba, range);
1130 
1131         if (range > dev->dev_attrib.max_unmap_lba_count) {
1132             ret = TCM_INVALID_PARAMETER_LIST;
1133             goto err;
1134         }
1135 
1136         if (lba + range > dev->transport->get_blocks(dev) + 1) {
1137             ret = TCM_ADDRESS_OUT_OF_RANGE;
1138             goto err;
1139         }
1140 
1141         if (range) {
1142             ret = ops->execute_unmap(cmd, lba, range);
1143             if (ret)
1144                 goto err;
1145         }
1146 
1147         ptr += 16;
1148         size -= 16;
1149     }
1150 
1151 err:
1152     transport_kunmap_data_sg(cmd);
1153     if (!ret)
1154         target_complete_cmd(cmd, SAM_STAT_GOOD);
1155     return ret;
1156 }
1157 
1158 void
1159 sbc_dif_generate(struct se_cmd *cmd)
1160 {
1161     struct se_device *dev = cmd->se_dev;
1162     struct t10_pi_tuple *sdt;
1163     struct scatterlist *dsg = cmd->t_data_sg, *psg;
1164     sector_t sector = cmd->t_task_lba;
1165     void *daddr, *paddr;
1166     int i, j, offset = 0;
1167     unsigned int block_size = dev->dev_attrib.block_size;
1168 
1169     for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) {
1170         paddr = kmap_atomic(sg_page(psg)) + psg->offset;
1171         daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
1172 
1173         for (j = 0; j < psg->length;
1174                 j += sizeof(*sdt)) {
1175             __u16 crc;
1176             unsigned int avail;
1177 
1178             if (offset >= dsg->length) {
1179                 offset -= dsg->length;
1180                 kunmap_atomic(daddr - dsg->offset);
1181                 dsg = sg_next(dsg);
1182                 if (!dsg) {
1183                     kunmap_atomic(paddr - psg->offset);
1184                     return;
1185                 }
1186                 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
1187             }
1188 
1189             sdt = paddr + j;
1190             avail = min(block_size, dsg->length - offset);
1191             crc = crc_t10dif(daddr + offset, avail);
1192             if (avail < block_size) {
1193                 kunmap_atomic(daddr - dsg->offset);
1194                 dsg = sg_next(dsg);
1195                 if (!dsg) {
1196                     kunmap_atomic(paddr - psg->offset);
1197                     return;
1198                 }
1199                 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
1200                 offset = block_size - avail;
1201                 crc = crc_t10dif_update(crc, daddr, offset);
1202             } else {
1203                 offset += block_size;
1204             }
1205 
1206             sdt->guard_tag = cpu_to_be16(crc);
1207             if (cmd->prot_type == TARGET_DIF_TYPE1_PROT)
1208                 sdt->ref_tag = cpu_to_be32(sector & 0xffffffff);
1209             sdt->app_tag = 0;
1210 
1211             pr_debug("DIF %s INSERT sector: %llu guard_tag: 0x%04x"
1212                  " app_tag: 0x%04x ref_tag: %u\n",
1213                  (cmd->data_direction == DMA_TO_DEVICE) ?
1214                  "WRITE" : "READ", (unsigned long long)sector,
1215                  sdt->guard_tag, sdt->app_tag,
1216                  be32_to_cpu(sdt->ref_tag));
1217 
1218             sector++;
1219         }
1220 
1221         kunmap_atomic(daddr - dsg->offset);
1222         kunmap_atomic(paddr - psg->offset);
1223     }
1224 }
1225 
1226 static sense_reason_t
1227 sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt,
1228           __u16 crc, sector_t sector, unsigned int ei_lba)
1229 {
1230     __be16 csum;
1231 
1232     if (!(cmd->prot_checks & TARGET_DIF_CHECK_GUARD))
1233         goto check_ref;
1234 
1235     csum = cpu_to_be16(crc);
1236 
1237     if (sdt->guard_tag != csum) {
1238         pr_err("DIFv1 checksum failed on sector %llu guard tag 0x%04x"
1239             " csum 0x%04x\n", (unsigned long long)sector,
1240             be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum));
1241         return TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED;
1242     }
1243 
1244 check_ref:
1245     if (!(cmd->prot_checks & TARGET_DIF_CHECK_REFTAG))
1246         return 0;
1247 
1248     if (cmd->prot_type == TARGET_DIF_TYPE1_PROT &&
1249         be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
1250         pr_err("DIFv1 Type 1 reference failed on sector: %llu tag: 0x%08x"
1251                " sector MSB: 0x%08x\n", (unsigned long long)sector,
1252                be32_to_cpu(sdt->ref_tag), (u32)(sector & 0xffffffff));
1253         return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
1254     }
1255 
1256     if (cmd->prot_type == TARGET_DIF_TYPE2_PROT &&
1257         be32_to_cpu(sdt->ref_tag) != ei_lba) {
1258         pr_err("DIFv1 Type 2 reference failed on sector: %llu tag: 0x%08x"
1259                " ei_lba: 0x%08x\n", (unsigned long long)sector,
1260             be32_to_cpu(sdt->ref_tag), ei_lba);
1261         return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
1262     }
1263 
1264     return 0;
1265 }
1266 
1267 void sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read,
1268                struct scatterlist *sg, int sg_off)
1269 {
1270     struct se_device *dev = cmd->se_dev;
1271     struct scatterlist *psg;
1272     void *paddr, *addr;
1273     unsigned int i, len, left;
1274     unsigned int offset = sg_off;
1275 
1276     if (!sg)
1277         return;
1278 
1279     left = sectors * dev->prot_length;
1280 
1281     for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) {
1282         unsigned int psg_len, copied = 0;
1283 
1284         paddr = kmap_atomic(sg_page(psg)) + psg->offset;
1285         psg_len = min(left, psg->length);
1286         while (psg_len) {
1287             len = min(psg_len, sg->length - offset);
1288             addr = kmap_atomic(sg_page(sg)) + sg->offset + offset;
1289 
1290             if (read)
1291                 memcpy(paddr + copied, addr, len);
1292             else
1293                 memcpy(addr, paddr + copied, len);
1294 
1295             left -= len;
1296             offset += len;
1297             copied += len;
1298             psg_len -= len;
1299 
1300             kunmap_atomic(addr - sg->offset - offset);
1301 
1302             if (offset >= sg->length) {
1303                 sg = sg_next(sg);
1304                 offset = 0;
1305             }
1306         }
1307         kunmap_atomic(paddr - psg->offset);
1308     }
1309 }
1310 EXPORT_SYMBOL(sbc_dif_copy_prot);
1311 
1312 sense_reason_t
1313 sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors,
1314            unsigned int ei_lba, struct scatterlist *psg, int psg_off)
1315 {
1316     struct se_device *dev = cmd->se_dev;
1317     struct t10_pi_tuple *sdt;
1318     struct scatterlist *dsg = cmd->t_data_sg;
1319     sector_t sector = start;
1320     void *daddr, *paddr;
1321     int i;
1322     sense_reason_t rc;
1323     int dsg_off = 0;
1324     unsigned int block_size = dev->dev_attrib.block_size;
1325 
1326     for (; psg && sector < start + sectors; psg = sg_next(psg)) {
1327         paddr = kmap_atomic(sg_page(psg)) + psg->offset;
1328         daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
1329 
1330         for (i = psg_off; i < psg->length &&
1331                 sector < start + sectors;
1332                 i += sizeof(*sdt)) {
1333             __u16 crc;
1334             unsigned int avail;
1335 
1336             if (dsg_off >= dsg->length) {
1337                 dsg_off -= dsg->length;
1338                 kunmap_atomic(daddr - dsg->offset);
1339                 dsg = sg_next(dsg);
1340                 if (!dsg) {
1341                     kunmap_atomic(paddr - psg->offset);
1342                     return 0;
1343                 }
1344                 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
1345             }
1346 
1347             sdt = paddr + i;
1348 
1349             pr_debug("DIF READ sector: %llu guard_tag: 0x%04x"
1350                  " app_tag: 0x%04x ref_tag: %u\n",
1351                  (unsigned long long)sector, sdt->guard_tag,
1352                  sdt->app_tag, be32_to_cpu(sdt->ref_tag));
1353 
1354             if (sdt->app_tag == T10_PI_APP_ESCAPE) {
1355                 dsg_off += block_size;
1356                 goto next;
1357             }
1358 
1359             avail = min(block_size, dsg->length - dsg_off);
1360             crc = crc_t10dif(daddr + dsg_off, avail);
1361             if (avail < block_size) {
1362                 kunmap_atomic(daddr - dsg->offset);
1363                 dsg = sg_next(dsg);
1364                 if (!dsg) {
1365                     kunmap_atomic(paddr - psg->offset);
1366                     return 0;
1367                 }
1368                 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
1369                 dsg_off = block_size - avail;
1370                 crc = crc_t10dif_update(crc, daddr, dsg_off);
1371             } else {
1372                 dsg_off += block_size;
1373             }
1374 
1375             rc = sbc_dif_v1_verify(cmd, sdt, crc, sector, ei_lba);
1376             if (rc) {
1377                 kunmap_atomic(daddr - dsg->offset);
1378                 kunmap_atomic(paddr - psg->offset);
1379                 cmd->sense_info = sector;
1380                 return rc;
1381             }
1382 next:
1383             sector++;
1384             ei_lba++;
1385         }
1386 
1387         psg_off = 0;
1388         kunmap_atomic(daddr - dsg->offset);
1389         kunmap_atomic(paddr - psg->offset);
1390     }
1391 
1392     return 0;
1393 }
1394 EXPORT_SYMBOL(sbc_dif_verify);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!