target/file: Add DIF protection support to fd_execute_rw

This patch adds support for DIF protection into fd_execute_rw() code
for WRITE/READ I/O using sbc_dif_verify_[write,read]() logic.

It adds fd_do_prot_rw() for handling interface with FILEIO PI, and
uses a locally allocated fd_prot->prot_buf + fd_prot->prot_sg for
interacting with SBC DIF verify emulation code.

Cc: Martin K. Petersen <martin.petersen@oracle.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Hannes Reinecke <hare@suse.de>
Cc: Sagi Grimberg <sagig@mellanox.com>
Cc: Or Gerlitz <ogerlitz@mellanox.com>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 119d519097621c952ec6c1ae81400981ee63fd75..aaba7c588c4d4755200aabd27052fdb037aeeb44 100644 (file)
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -257,6 +257,72 @@ static void fd_free_device(struct se_device *dev)
        kfree(fd_dev);
 }
 
+static int fd_do_prot_rw(struct se_cmd *cmd, struct fd_prot *fd_prot,
+                        int is_write)
+{
+       struct se_device *se_dev = cmd->se_dev;
+       struct fd_dev *dev = FD_DEV(se_dev);
+       struct file *prot_fd = dev->fd_prot_file;
+       struct scatterlist *sg;
+       loff_t pos = (cmd->t_task_lba * se_dev->prot_length);
+       unsigned char *buf;
+       u32 prot_size, len, size;
+       int rc, ret = 1, i;
+
+       prot_size = (cmd->data_length / se_dev->dev_attrib.block_size) *
+                    se_dev->prot_length;
+
+       if (!is_write) {
+               fd_prot->prot_buf = vzalloc(prot_size);
+               if (!fd_prot->prot_buf) {
+                       pr_err("Unable to allocate fd_prot->prot_buf\n");
+                       return -ENOMEM;
+               }
+               buf = fd_prot->prot_buf;
+
+               fd_prot->prot_sg_nents = cmd->t_prot_nents;
+               fd_prot->prot_sg = kzalloc(sizeof(struct scatterlist) *
+                                          fd_prot->prot_sg_nents, GFP_KERNEL);
+               if (!fd_prot->prot_sg) {
+                       pr_err("Unable to allocate fd_prot->prot_sg\n");
+                       vfree(fd_prot->prot_buf);
+                       return -ENOMEM;
+               }
+               size = prot_size;
+
+               for_each_sg(fd_prot->prot_sg, sg, fd_prot->prot_sg_nents, i) {
+
+                       len = min_t(u32, PAGE_SIZE, size);
+                       sg_set_buf(sg, buf, len);
+                       size -= len;
+                       buf += len;
+               }
+       }
+
+       if (is_write) {
+               rc = kernel_write(prot_fd, fd_prot->prot_buf, prot_size, pos);
+               if (rc < 0 || prot_size != rc) {
+                       pr_err("kernel_write() for fd_do_prot_rw failed:"
+                              " %d\n", rc);
+                       ret = -EINVAL;
+               }
+       } else {
+               rc = kernel_read(prot_fd, pos, fd_prot->prot_buf, prot_size);
+               if (rc < 0) {
+                       pr_err("kernel_read() for fd_do_prot_rw failed:"
+                              " %d\n", rc);
+                       ret = -EINVAL;
+               }
+       }
+
+       if (is_write || ret < 0) {
+               kfree(fd_prot->prot_sg);
+               vfree(fd_prot->prot_buf);
+       }
+
+       return ret;
+}
+
 static int fd_do_rw(struct se_cmd *cmd, struct scatterlist *sgl,
                u32 sgl_nents, int is_write)
 {
@@ -551,6 +617,8 @@ fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
              enum dma_data_direction data_direction)
 {
        struct se_device *dev = cmd->se_dev;
+       struct fd_prot fd_prot;
+       sense_reason_t rc;
        int ret = 0;
 
        /*
@@ -558,8 +626,48 @@ fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
         * physical memory addresses to struct iovec virtual memory.
         */
        if (data_direction == DMA_FROM_DEVICE) {
+               memset(&fd_prot, 0, sizeof(struct fd_prot));
+
+               if (cmd->prot_type) {
+                       ret = fd_do_prot_rw(cmd, &fd_prot, false);
+                       if (ret < 0)
+                               return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+               }
+
                ret = fd_do_rw(cmd, sgl, sgl_nents, 0);
+
+               if (ret > 0 && cmd->prot_type) {
+                       u32 sectors = cmd->data_length / dev->dev_attrib.block_size;
+
+                       rc = sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors,
+                                                0, fd_prot.prot_sg, 0);
+                       if (rc) {
+                               kfree(fd_prot.prot_sg);
+                               vfree(fd_prot.prot_buf);
+                               return rc;
+                       }
+                       kfree(fd_prot.prot_sg);
+                       vfree(fd_prot.prot_buf);
+               }
        } else {
+               memset(&fd_prot, 0, sizeof(struct fd_prot));
+
+               if (cmd->prot_type) {
+                       u32 sectors = cmd->data_length / dev->dev_attrib.block_size;
+
+                       ret = fd_do_prot_rw(cmd, &fd_prot, false);
+                       if (ret < 0)
+                               return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+
+                       rc = sbc_dif_verify_write(cmd, cmd->t_task_lba, sectors,
+                                                 0, fd_prot.prot_sg, 0);
+                       if (rc) {
+                               kfree(fd_prot.prot_sg);
+                               vfree(fd_prot.prot_buf);
+                               return rc;
+                       }
+               }
+
                ret = fd_do_rw(cmd, sgl, sgl_nents, 1);
                /*
                 * Perform implicit vfs_fsync_range() for fd_do_writev() ops
@@ -576,10 +684,19 @@ fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 
                        vfs_fsync_range(fd_dev->fd_file, start, end, 1);
                }
+
+               if (ret > 0 && cmd->prot_type) {
+                       ret = fd_do_prot_rw(cmd, &fd_prot, true);
+                       if (ret < 0)
+                               return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+               }
        }
 
-       if (ret < 0)
+       if (ret < 0) {
+               kfree(fd_prot.prot_sg);
+               vfree(fd_prot.prot_buf);
                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+       }
 
        if (ret)
                target_complete_cmd(cmd, SAM_STAT_GOOD);

diff --git a/drivers/target/target_core_file.h b/drivers/target/target_core_file.h
index 583691ebcbe0405fb95b6255271685312f8acbab..97e5e7dd4259df84cdacfddf9fc4d0232ab42066 100644 (file)
--- a/drivers/target/target_core_file.h
+++ b/drivers/target/target_core_file.h
@@ -18,6 +18,11 @@
 #define FDBD_HAS_BUFFERED_IO_WCE 0x04
 #define FDBD_FORMAT_UNIT_SIZE  2048
 
+struct fd_prot {
+       unsigned char   *prot_buf;
+       struct scatterlist *prot_sg;
+       u32 prot_sg_nents;
+};
 
 struct fd_dev {
        struct se_device dev;