target: add a parse_cdb method to the backend drivers

Instead of trying to handle all SCSI command sets in one function
(transport_generic_cmd_sequencer) call out to the backend driver to perform
this functionality.  For pSCSI a copy of the existing code is used, but for
all virtual backends we can use a new parse_sbc_cdb helper is used to
provide a simple SBC emulation.

For now this setups means a fair amount of duplication between pSCSI and the
SBC library, but patches later in this series will sort out that problem.

(nab: Fix up build failure in target_core_pscsi.c)

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

1 files changed, 450 insertions, 0 deletions

diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
new file mode 100644
index 000000000000..9d1ca3814876
--- /dev/null
+++ b/drivers/target/target_core_sbc.c
@@ -0,0 +1,450 @@
+/*
+ * SCSI Block Commands (SBC) parsing and emulation.
+ *
+ * Copyright (c) 2002, 2003, 2004, 2005 PyX Technologies, Inc.
+ * Copyright (c) 2005, 2006, 2007 SBE, Inc.
+ * Copyright (c) 2007-2010 Rising Tide Systems
+ * Copyright (c) 2008-2010 Linux-iSCSI.org
+ *
+ * Nicholas A. Bellinger <nab@kernel.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ratelimit.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_backend.h>
+#include <target/target_core_fabric.h>
+
+#include "target_core_internal.h"
+#include "target_core_ua.h"
+
+
+static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)
+{
+        return cmd->se_dev->se_sub_dev->se_dev_attrib.block_size * sectors;
+}
+
+static int sbc_check_valid_sectors(struct se_cmd *cmd)
+{
+        struct se_device *dev = cmd->se_dev;
+        unsigned long long end_lba;
+        u32 sectors;
+
+        sectors = cmd->data_length / dev->se_sub_dev->se_dev_attrib.block_size;
+        end_lba = dev->transport->get_blocks(dev) + 1;
+
+        if (cmd->t_task_lba + sectors > end_lba) {
+                pr_err("target: lba %llu, sectors %u exceeds end lba %llu\n",
+                        cmd->t_task_lba, sectors, end_lba);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static inline u32 transport_get_sectors_6(unsigned char *cdb)
+{
+        /*
+         * Use 8-bit sector value.  SBC-3 says:
+         *
+         *   A TRANSFER LENGTH field set to zero specifies that 256
+         *   logical blocks shall be written.  Any other value
+         *   specifies the number of logical blocks that shall be
+         *   written.
+         */
+        return cdb[4] ? : 256;
+}
+
+static inline u32 transport_get_sectors_10(unsigned char *cdb)
+{
+        return (u32)(cdb[7] << 8) + cdb[8];
+}
+
+static inline u32 transport_get_sectors_12(unsigned char *cdb)
+{
+        return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9];
+}
+
+static inline u32 transport_get_sectors_16(unsigned char *cdb)
+{
+        return (u32)(cdb[10] << 24) + (cdb[11] << 16) +
+                    (cdb[12] << 8) + cdb[13];
+}
+
+/*
+ * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants
+ */
+static inline u32 transport_get_sectors_32(unsigned char *cdb)
+{
+        return (u32)(cdb[28] << 24) + (cdb[29] << 16) +
+                    (cdb[30] << 8) + cdb[31];
+
+}
+
+static inline u32 transport_lba_21(unsigned char *cdb)
+{
+        return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3];
+}
+
+static inline u32 transport_lba_32(unsigned char *cdb)
+{
+        return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
+}
+
+static inline unsigned long long transport_lba_64(unsigned char *cdb)
+{
+        unsigned int __v1, __v2;
+
+        __v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
+        __v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
+
+        return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
+}
+
+/*
+ * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs
+ */
+static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
+{
+        unsigned int __v1, __v2;
+
+        __v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15];
+        __v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19];
+
+        return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
+}
+
+static int sbc_write_same_supported(struct se_device *dev,
+                unsigned char *flags)
+{
+        if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
+                pr_err("WRITE_SAME PBDATA and LBDATA"
+                        " bits not supported for Block Discard"
+                        " Emulation\n");
+                return -ENOSYS;
+        }
+
+        /*
+         * Currently for the emulated case we only accept
+         * tpws with the UNMAP=1 bit set.
+         */
+        if (!(flags[0] & 0x08)) {
+                pr_err("WRITE_SAME w/o UNMAP bit not"
+                        " supported for Block Discard Emulation\n");
+                return -ENOSYS;
+        }
+
+        return 0;
+}
+
+static void xdreadwrite_callback(struct se_cmd *cmd)
+{
+        unsigned char *buf, *addr;
+        struct scatterlist *sg;
+        unsigned int offset;
+        int i;
+        int count;
+        /*
+         * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command
+         *
+         * 1) read the specified logical block(s);
+         * 2) transfer logical blocks from the data-out buffer;
+         * 3) XOR the logical blocks transferred from the data-out buffer with
+         *    the logical blocks read, storing the resulting XOR data in a buffer;
+         * 4) if the DISABLE WRITE bit is set to zero, then write the logical
+         *    blocks transferred from the data-out buffer; and
+         * 5) transfer the resulting XOR data to the data-in buffer.
+         */
+        buf = kmalloc(cmd->data_length, GFP_KERNEL);
+        if (!buf) {
+                pr_err("Unable to allocate xor_callback buf\n");
+                return;
+        }
+        /*
+         * Copy the scatterlist WRITE buffer located at cmd->t_data_sg
+         * into the locally allocated *buf
+         */
+        sg_copy_to_buffer(cmd->t_data_sg,
+                          cmd->t_data_nents,
+                          buf,
+                          cmd->data_length);
+
+        /*
+         * Now perform the XOR against the BIDI read memory located at
+         * cmd->t_mem_bidi_list
+         */
+
+        offset = 0;
+        for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) {
+                addr = kmap_atomic(sg_page(sg));
+                if (!addr)
+                        goto out;
+
+                for (i = 0; i < sg->length; i++)
+                        *(addr + sg->offset + i) ^= *(buf + offset + i);
+
+                offset += sg->length;
+                kunmap_atomic(addr);
+        }
+
+out:
+        kfree(buf);
+}
+
+int sbc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
+{
+        struct se_subsystem_dev *su_dev = cmd->se_dev->se_sub_dev;
+        struct se_device *dev = cmd->se_dev;
+        unsigned char *cdb = cmd->t_task_cdb;
+        u32 sectors = 0;
+        int ret;
+
+        switch (cdb[0]) {
+        case READ_6:
+                sectors = transport_get_sectors_6(cdb);
+                cmd->t_task_lba = transport_lba_21(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                break;
+        case READ_10:
+                sectors = transport_get_sectors_10(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                break;
+        case READ_12:
+                sectors = transport_get_sectors_12(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                break;
+        case READ_16:
+                sectors = transport_get_sectors_16(cdb);
+                cmd->t_task_lba = transport_lba_64(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                break;
+        case WRITE_6:
+                sectors = transport_get_sectors_6(cdb);
+                cmd->t_task_lba = transport_lba_21(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                break;
+        case WRITE_10:
+        case WRITE_VERIFY:
+                sectors = transport_get_sectors_10(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
+                if (cdb[1] & 0x8)
+                        cmd->se_cmd_flags |= SCF_FUA;
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                break;
+        case WRITE_12:
+                sectors = transport_get_sectors_12(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
+                if (cdb[1] & 0x8)
+                        cmd->se_cmd_flags |= SCF_FUA;
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                break;
+        case WRITE_16:
+                sectors = transport_get_sectors_16(cdb);
+                cmd->t_task_lba = transport_lba_64(cdb);
+                if (cdb[1] & 0x8)
+                        cmd->se_cmd_flags |= SCF_FUA;
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+                break;
+        case XDWRITEREAD_10:
+                if ((cmd->data_direction != DMA_TO_DEVICE) ||
+                    !(cmd->se_cmd_flags & SCF_BIDI))
+                        goto out_invalid_cdb_field;
+                sectors = transport_get_sectors_10(cdb);
+
+                cmd->t_task_lba = transport_lba_32(cdb);
+                cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+
+                /*
+                 * Setup BIDI XOR callback to be run after I/O completion.
+                 */
+                cmd->transport_complete_callback = &xdreadwrite_callback;
+                if (cdb[1] & 0x8)
+                        cmd->se_cmd_flags |= SCF_FUA;
+                break;
+        case VARIABLE_LENGTH_CMD:
+        {
+                u16 service_action = get_unaligned_be16(&cdb[8]);
+                switch (service_action) {
+                case XDWRITEREAD_32:
+                        sectors = transport_get_sectors_32(cdb);
+
+                        /*
+                         * Use WRITE_32 and READ_32 opcodes for the emulated
+                         * XDWRITE_READ_32 logic.
+                         */
+                        cmd->t_task_lba = transport_lba_64_ext(cdb);
+                        cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
+
+                        /*
+                         * Setup BIDI XOR callback to be run during after I/O
+                         * completion.
+                         */
+                        cmd->transport_complete_callback = &xdreadwrite_callback;
+                        if (cdb[1] & 0x8)
+                                cmd->se_cmd_flags |= SCF_FUA;
+                        break;
+                case WRITE_SAME_32:
+                        sectors = transport_get_sectors_32(cdb);
+                        if (!sectors) {
+                                pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
+                                       " supported\n");
+                                goto out_invalid_cdb_field;
+                        }
+
+                        *size = sbc_get_size(cmd, 1);
+                        cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
+
+                        if (sbc_write_same_supported(dev, &cdb[10]) < 0)
+                                goto out_unsupported_cdb;
+                        cmd->execute_cmd = target_emulate_write_same;
+                        break;
+                default:
+                        pr_err("VARIABLE_LENGTH_CMD service action"
+                                " 0x%04x not supported\n", service_action);
+                        goto out_unsupported_cdb;
+                }
+                break;
+        }
+        case READ_CAPACITY:
+                *size = READ_CAP_LEN;
+                cmd->execute_cmd = target_emulate_readcapacity;
+                break;
+        case SERVICE_ACTION_IN:
+                switch (cmd->t_task_cdb[1] & 0x1f) {
+                case SAI_READ_CAPACITY_16:
+                        cmd->execute_cmd = target_emulate_readcapacity_16;
+                        break;
+                default:
+                        pr_err("Unsupported SA: 0x%02x\n",
+                                cmd->t_task_cdb[1] & 0x1f);
+                        goto out_invalid_cdb_field;
+                }
+                *size = (cdb[10] << 24) | (cdb[11] << 16) |
+                       (cdb[12] << 8) | cdb[13];
+                break;
+        case SYNCHRONIZE_CACHE:
+        case SYNCHRONIZE_CACHE_16:
+                /*
+                 * Extract LBA and range to be flushed for emulated SYNCHRONIZE_CACHE
+                 */
+                if (cdb[0] == SYNCHRONIZE_CACHE) {
+                        sectors = transport_get_sectors_10(cdb);
+                        cmd->t_task_lba = transport_lba_32(cdb);
+                } else {
+                        sectors = transport_get_sectors_16(cdb);
+                        cmd->t_task_lba = transport_lba_64(cdb);
+                }
+
+                *size = sbc_get_size(cmd, sectors);
+
+                /*
+                 * Check to ensure that LBA + Range does not exceed past end of
+                 * device for IBLOCK and FILEIO ->do_sync_cache() backend calls
+                 */
+                if (cmd->t_task_lba || sectors) {
+                        if (sbc_check_valid_sectors(cmd) < 0)
+                                goto out_invalid_cdb_field;
+                }
+                cmd->execute_cmd = target_emulate_synchronize_cache;
+                break;
+        case UNMAP:
+                *size = get_unaligned_be16(&cdb[7]);
+                cmd->execute_cmd = target_emulate_unmap;
+                break;
+        case WRITE_SAME_16:
+                sectors = transport_get_sectors_16(cdb);
+                if (!sectors) {
+                        pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+                        goto out_invalid_cdb_field;
+                }
+
+                *size = sbc_get_size(cmd, 1);
+                cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
+
+                if (sbc_write_same_supported(dev, &cdb[1]) < 0)
+                        goto out_unsupported_cdb;
+                cmd->execute_cmd = target_emulate_write_same;
+                break;
+        case WRITE_SAME:
+                sectors = transport_get_sectors_10(cdb);
+                if (!sectors) {
+                        pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+                        goto out_invalid_cdb_field;
+                }
+
+                *size = sbc_get_size(cmd, 1);
+                cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
+
+                /*
+                 * Follow sbcr26 with WRITE_SAME (10) and check for the existence
+                 * of byte 1 bit 3 UNMAP instead of original reserved field
+                 */
+                if (sbc_write_same_supported(dev, &cdb[1]) < 0)
+                        goto out_unsupported_cdb;
+                cmd->execute_cmd = target_emulate_write_same;
+                break;
+        case VERIFY:
+                *size = 0;
+                cmd->execute_cmd = target_emulate_noop;
+                break;
+        default:
+                ret = spc_parse_cdb(cmd, size, false);
+                if (ret)
+                        return ret;
+        }
+
+        /* reject any command that we don't have a handler for */
+        if (!(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) && !cmd->execute_cmd)
+                goto out_unsupported_cdb;
+
+        if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
+                if (sectors > su_dev->se_dev_attrib.fabric_max_sectors) {
+                        printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
+                                " big sectors %u exceeds fabric_max_sectors:"
+                                " %u\n", cdb[0], sectors,
+                                su_dev->se_dev_attrib.fabric_max_sectors);
+                        goto out_invalid_cdb_field;
+                }
+                if (sectors > su_dev->se_dev_attrib.hw_max_sectors) {
+                        printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
+                                " big sectors %u exceeds backend hw_max_sectors:"
+                                " %u\n", cdb[0], sectors,
+                                su_dev->se_dev_attrib.hw_max_sectors);
+                        goto out_invalid_cdb_field;
+                }
+
+                *size = sbc_get_size(cmd, sectors);
+        }
+
+        return 0;
+
+out_unsupported_cdb:
+        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+        cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
+        return -EINVAL;
+out_invalid_cdb_field:
+        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
+        cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
+        return -EINVAL;
+}
+EXPORT_SYMBOL(sbc_parse_cdb);