target/sbc: Add LBPRZ attribute + control CDB emulation

This change sets the LBPRZ flag in EVPD page b2h and READ CAPACITY (16)
based on a new unmap_zeroes_data device attribute. This flag is set
automatically for iblock based on underlying block device queue's
discard_zeroes_data flag.

Signed-off-by: Jamie Pocas <jamie.pocas@emc.com>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index 2e47fe68e4eab4f81473b37103eb98b174c0be41..affe4c393ebcbbdbd15d049208548470d7e71a1f 100644 (file)
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -499,6 +499,7 @@ DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_lba_count);
 DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_block_desc_count);
 DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity);
 DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity_alignment);
+DEF_CONFIGFS_ATTRIB_SHOW(unmap_zeroes_data);
 DEF_CONFIGFS_ATTRIB_SHOW(max_write_same_len);
 
 #define DEF_CONFIGFS_ATTRIB_STORE_U32(_name)                           \
@@ -866,6 +867,39 @@ static ssize_t emulate_rest_reord_store(struct config_item *item,
        return count;
 }
 
+static ssize_t unmap_zeroes_data_store(struct config_item *item,
+               const char *page, size_t count)
+{
+       struct se_dev_attrib *da = to_attrib(item);
+       bool flag;
+       int ret;
+
+       ret = strtobool(page, &flag);
+       if (ret < 0)
+               return ret;
+
+       if (da->da_dev->export_count) {
+               pr_err("dev[%p]: Unable to change SE Device"
+                      " unmap_zeroes_data while export_count is %d\n",
+                      da->da_dev, da->da_dev->export_count);
+               return -EINVAL;
+       }
+       /*
+        * We expect this value to be non-zero when generic Block Layer
+        * Discard supported is detected iblock_configure_device().
+        */
+       if (flag && !da->max_unmap_block_desc_count) {
+               pr_err("dev[%p]: Thin Provisioning LBPRZ will not be set"
+                      " because max_unmap_block_desc_count is zero\n",
+                      da->da_dev);
+              return -ENOSYS;
+       }
+       da->unmap_zeroes_data = flag;
+       pr_debug("dev[%p]: SE Device Thin Provisioning LBPRZ bit: %d\n",
+                da->da_dev, flag);
+       return 0;
+}
+
 /*
  * Note, this can only be called on unexported SE Device Object.
  */
@@ -998,6 +1032,7 @@ CONFIGFS_ATTR(, max_unmap_lba_count);
 CONFIGFS_ATTR(, max_unmap_block_desc_count);
 CONFIGFS_ATTR(, unmap_granularity);
 CONFIGFS_ATTR(, unmap_granularity_alignment);
+CONFIGFS_ATTR(, unmap_zeroes_data);
 CONFIGFS_ATTR(, max_write_same_len);
 
 /*
@@ -1034,6 +1069,7 @@ struct configfs_attribute *sbc_attrib_attrs[] = {
        &attr_max_unmap_block_desc_count,
        &attr_unmap_granularity,
        &attr_unmap_granularity_alignment,
+       &attr_unmap_zeroes_data,
        &attr_max_write_same_len,
        NULL,
 };

diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 88ea4e4f124b2113cf686f470aed171706304a94..cacd97a8cbd02d32509b0a590ff2c40b59be36b1 100644 (file)
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -813,6 +813,8 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
        dev->dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT;
        dev->dev_attrib.unmap_granularity_alignment =
                                DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT;
+       dev->dev_attrib.unmap_zeroes_data =
+                               DA_UNMAP_ZEROES_DATA_DEFAULT;
        dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN;
 
        xcopy_lun = &dev->xcopy_lun;

diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index f29c69120054463eee986c0ab6ed48ec6c504c39..e77d15000caa313a8c3c8bb4a403ba8f1aa9a6c6 100644 (file)
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -138,6 +138,8 @@ static int iblock_configure_device(struct se_device *dev)
                                q->limits.discard_granularity >> 9;
                dev->dev_attrib.unmap_granularity_alignment =
                                q->limits.discard_alignment;
+               dev->dev_attrib.unmap_zeroes_data =
+                               q->limits.discard_zeroes_data;
 
                pr_debug("IBLOCK: BLOCK Discard support available,"
                                " disabled by default\n");

diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index 0b4b2a67d9f9ed597479f1f2c0ea356126f55006..b83ac3766fe77851ff60a9aa65582cb51b7ffb48 100644 (file)
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -141,9 +141,17 @@ sbc_emulate_readcapacity_16(struct se_cmd *cmd)
         * Set Thin Provisioning Enable bit following sbc3r22 in section
         * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled.
         */
-       if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws)
+       if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws) {
                buf[14] |= 0x80;
 
+               /*
+                * LBPRZ signifies that zeroes will be read back from an LBA after
+                * an UNMAP or WRITE SAME w/ unmap bit (sbc3r36 5.16.2)
+                */
+               if (dev->dev_attrib.unmap_zeroes_data)
+                       buf[14] |= 0x40;
+       }
+
        rbuf = transport_kmap_data_sg(cmd);
        if (rbuf) {
                memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));

diff --git a/drivers/target/target_core_spc.c b/drivers/target/target_core_spc.c
index 9413e1a949e5bf9a63eb1f418a427440b1ad6132..0aa47babd16c61e2025b12a26443c3297da31c5a 100644 (file)
--- a/drivers/target/target_core_spc.c
+++ b/drivers/target/target_core_spc.c
@@ -635,6 +635,18 @@ spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
        if (dev->dev_attrib.emulate_tpws != 0)
                buf[5] |= 0x40 | 0x20;
 
+       /*
+        * The unmap_zeroes_data set means that the underlying device supports
+        * REQ_DISCARD and has the discard_zeroes_data bit set. This satisfies
+        * the SBC requirements for LBPRZ, meaning that a subsequent read
+        * will return zeroes after an UNMAP or WRITE SAME (16) to an LBA
+        * See sbc4r36 6.6.4.
+        */
+       if (((dev->dev_attrib.emulate_tpu != 0) ||
+            (dev->dev_attrib.emulate_tpws != 0)) &&
+            (dev->dev_attrib.unmap_zeroes_data != 0))
+               buf[5] |= 0x04;
+
        return 0;
 }
 

diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index 0a2c74008e5388f6d817272735882f40abc3a013..dc8b796dbcc7e68ffd650906b876033b2743a1d1 100644 (file)
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -63,6 +63,8 @@
 #define DA_UNMAP_GRANULARITY_DEFAULT           0
 /* Default unmap_granularity_alignment */
 #define DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT 0
+/* Default unmap_zeroes_data */
+#define DA_UNMAP_ZEROES_DATA_DEFAULT           0
 /* Default max_write_same_len, disabled by default */
 #define DA_MAX_WRITE_SAME_LEN                  0
 /* Use a model alias based on the configfs backend device name */
@@ -674,6 +676,7 @@ struct se_dev_attrib {
        int             force_pr_aptpl;
        int             is_nonrot;
        int             emulate_rest_reord;
+       int             unmap_zeroes_data;
        u32             hw_block_size;
        u32             block_size;
        u32             hw_max_sectors;