Merge branches 'arm/rockchip', 'arm/exynos', 'arm/smmu', 'x86/vt-d', 'x86/amd', ...

[sfrench/cifs-2.6.git] / drivers / target / target_core_file.c

diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 3dcfc73528ec370a052eab91cb4c8ede00b40c5c..3f27bfd816d87201c5f3cec3ad7857ead488191b 100644 (file)
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -264,11 +264,10 @@ static int fd_do_prot_rw(struct se_cmd *cmd, struct fd_prot *fd_prot,
        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;
+       u32 prot_size;
+       int rc, ret = 1;
 
        prot_size = (cmd->data_length / se_dev->dev_attrib.block_size) *
                     se_dev->prot_length;
@@ -281,24 +280,16 @@ static int fd_do_prot_rw(struct se_cmd *cmd, struct fd_prot *fd_prot,
                }
                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);
+               fd_prot->prot_sg_nents = 1;
+               fd_prot->prot_sg = kzalloc(sizeof(struct scatterlist),
+                                          GFP_KERNEL);
                if (!fd_prot->prot_sg) {
                        pr_err("Unable to allocate fd_prot->prot_sg\n");
                        kfree(fd_prot->prot_buf);
                        return -ENOMEM;
                }
                sg_init_table(fd_prot->prot_sg, fd_prot->prot_sg_nents);
-               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;
-               }
+               sg_set_buf(fd_prot->prot_sg, buf, prot_size);
        }
 
        if (is_write) {
@@ -491,6 +482,56 @@ fd_execute_write_same(struct se_cmd *cmd)
        return 0;
 }
 
+static int
+fd_do_prot_fill(struct se_device *se_dev, sector_t lba, sector_t nolb,
+               void *buf, size_t bufsize)
+{
+       struct fd_dev *fd_dev = FD_DEV(se_dev);
+       struct file *prot_fd = fd_dev->fd_prot_file;
+       sector_t prot_length, prot;
+       loff_t pos = lba * se_dev->prot_length;
+
+       if (!prot_fd) {
+               pr_err("Unable to locate fd_dev->fd_prot_file\n");
+               return -ENODEV;
+       }
+
+       prot_length = nolb * se_dev->prot_length;
+
+       for (prot = 0; prot < prot_length;) {
+               sector_t len = min_t(sector_t, bufsize, prot_length - prot);
+               ssize_t ret = kernel_write(prot_fd, buf, len, pos + prot);
+
+               if (ret != len) {
+                       pr_err("vfs_write to prot file failed: %zd\n", ret);
+                       return ret < 0 ? ret : -ENODEV;
+               }
+               prot += ret;
+       }
+
+       return 0;
+}
+
+static int
+fd_do_prot_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
+{
+       void *buf;
+       int rc;
+
+       buf = (void *)__get_free_page(GFP_KERNEL);
+       if (!buf) {
+               pr_err("Unable to allocate FILEIO prot buf\n");
+               return -ENOMEM;
+       }
+       memset(buf, 0xff, PAGE_SIZE);
+
+       rc = fd_do_prot_fill(cmd->se_dev, lba, nolb, buf, PAGE_SIZE);
+
+       free_page((unsigned long)buf);
+
+       return rc;
+}
+
 static sense_reason_t
 fd_do_unmap(struct se_cmd *cmd, void *priv, sector_t lba, sector_t nolb)
 {
@@ -498,6 +539,12 @@ fd_do_unmap(struct se_cmd *cmd, void *priv, sector_t lba, sector_t nolb)
        struct inode *inode = file->f_mapping->host;
        int ret;
 
+       if (cmd->se_dev->dev_attrib.pi_prot_type) {
+               ret = fd_do_prot_unmap(cmd, lba, nolb);
+               if (ret)
+                       return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+       }
+
        if (S_ISBLK(inode->i_mode)) {
                /* The backend is block device, use discard */
                struct block_device *bdev = inode->i_bdev;
@@ -820,48 +867,28 @@ static int fd_init_prot(struct se_device *dev)
 
 static int fd_format_prot(struct se_device *dev)
 {
-       struct fd_dev *fd_dev = FD_DEV(dev);
-       struct file *prot_fd = fd_dev->fd_prot_file;
-       sector_t prot_length, prot;
        unsigned char *buf;
-       loff_t pos = 0;
        int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size;
-       int rc, ret = 0, size, len;
+       int ret;
 
        if (!dev->dev_attrib.pi_prot_type) {
                pr_err("Unable to format_prot while pi_prot_type == 0\n");
                return -ENODEV;
        }
-       if (!prot_fd) {
-               pr_err("Unable to locate fd_dev->fd_prot_file\n");
-               return -ENODEV;
-       }
 
        buf = vzalloc(unit_size);
        if (!buf) {
                pr_err("Unable to allocate FILEIO prot buf\n");
                return -ENOMEM;
        }
-       prot_length = (dev->transport->get_blocks(dev) + 1) * dev->prot_length;
-       size = prot_length;
 
        pr_debug("Using FILEIO prot_length: %llu\n",
-                (unsigned long long)prot_length);
+                (unsigned long long)(dev->transport->get_blocks(dev) + 1) *
+                                       dev->prot_length);
 
        memset(buf, 0xff, unit_size);
-       for (prot = 0; prot < prot_length; prot += unit_size) {
-               len = min(unit_size, size);
-               rc = kernel_write(prot_fd, buf, len, pos);
-               if (rc != len) {
-                       pr_err("vfs_write to prot file failed: %d\n", rc);
-                       ret = -ENODEV;
-                       goto out;
-               }
-               pos += len;
-               size -= len;
-       }
-
-out:
+       ret = fd_do_prot_fill(dev, 0, dev->transport->get_blocks(dev) + 1,
+                             buf, unit_size);
        vfree(buf);
        return ret;
 }
@@ -931,7 +958,6 @@ static struct se_subsystem_api fileio_template = {
        .inquiry_prod           = "FILEIO",
        .inquiry_rev            = FD_VERSION,
        .owner                  = THIS_MODULE,
-       .transport_type         = TRANSPORT_PLUGIN_VHBA_PDEV,
        .attach_hba             = fd_attach_hba,
        .detach_hba             = fd_detach_hba,
        .alloc_device           = fd_alloc_device,