target: break up free_device callback

[linux.git] / drivers / target / target_core_rd.c

diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index ddc216c9f1f63dcdea780b5be5edbf34d9cc93d4..a6e8106abd6ffbcf44f76aa24622b52b473a5e10 100644 (file)
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -47,11 +47,9 @@ static int rd_attach_hba(struct se_hba *hba, u32 host_id)
 {
        struct rd_host *rd_host;
 
-       rd_host = kzalloc(sizeof(struct rd_host), GFP_KERNEL);
-       if (!rd_host) {
-               pr_err("Unable to allocate memory for struct rd_host\n");
+       rd_host = kzalloc(sizeof(*rd_host), GFP_KERNEL);
+       if (!rd_host)
                return -ENOMEM;
-       }
 
        rd_host->rd_host_id = host_id;
 
@@ -148,11 +146,8 @@ static int rd_allocate_sgl_table(struct rd_dev *rd_dev, struct rd_dev_sg_table *
 
                sg = kcalloc(sg_per_table + chain_entry, sizeof(*sg),
                                GFP_KERNEL);
-               if (!sg) {
-                       pr_err("Unable to allocate scatterlist array"
-                               " for struct rd_dev\n");
+               if (!sg)
                        return -ENOMEM;
-               }
 
                sg_init_table(sg, sg_per_table + chain_entry);
 
@@ -210,13 +205,9 @@ static int rd_build_device_space(struct rd_dev *rd_dev)
        total_sg_needed = rd_dev->rd_page_count;
 
        sg_tables = (total_sg_needed / max_sg_per_table) + 1;
-
-       sg_table = kzalloc(sg_tables * sizeof(struct rd_dev_sg_table), GFP_KERNEL);
-       if (!sg_table) {
-               pr_err("Unable to allocate memory for Ramdisk"
-                      " scatterlist tables\n");
+       sg_table = kcalloc(sg_tables, sizeof(*sg_table), GFP_KERNEL);
+       if (!sg_table)
                return -ENOMEM;
-       }
 
        rd_dev->sg_table_array = sg_table;
        rd_dev->sg_table_count = sg_tables;
@@ -271,13 +262,9 @@ static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block
        total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1;
 
        sg_tables = (total_sg_needed / max_sg_per_table) + 1;
-
-       sg_table = kzalloc(sg_tables * sizeof(struct rd_dev_sg_table), GFP_KERNEL);
-       if (!sg_table) {
-               pr_err("Unable to allocate memory for Ramdisk protection"
-                      " scatterlist tables\n");
+       sg_table = kcalloc(sg_tables, sizeof(*sg_table), GFP_KERNEL);
+       if (!sg_table)
                return -ENOMEM;
-       }
 
        rd_dev->sg_prot_array = sg_table;
        rd_dev->sg_prot_count = sg_tables;
@@ -298,11 +285,9 @@ static struct se_device *rd_alloc_device(struct se_hba *hba, const char *name)
        struct rd_dev *rd_dev;
        struct rd_host *rd_host = hba->hba_ptr;
 
-       rd_dev = kzalloc(sizeof(struct rd_dev), GFP_KERNEL);
-       if (!rd_dev) {
-               pr_err("Unable to allocate memory for struct rd_dev\n");
+       rd_dev = kzalloc(sizeof(*rd_dev), GFP_KERNEL);
+       if (!rd_dev)
                return NULL;
-       }
 
        rd_dev->rd_host = rd_host;
 
@@ -353,11 +338,15 @@ static void rd_dev_call_rcu(struct rcu_head *p)
 }
 
 static void rd_free_device(struct se_device *dev)
+{
+       call_rcu(&dev->rcu_head, rd_dev_call_rcu);
+}
+
+static void rd_destroy_device(struct se_device *dev)
 {
        struct rd_dev *rd_dev = RD_DEV(dev);
 
        rd_release_device_space(rd_dev);
-       call_rcu(&dev->rcu_head, rd_dev_call_rcu);
 }
 
 static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
@@ -410,7 +399,7 @@ static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, bool is_read)
        u32 prot_offset, prot_page;
        u32 prot_npages __maybe_unused;
        u64 tmp;
-       sense_reason_t rc = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+       sense_reason_t rc = 0;
 
        tmp = cmd->t_task_lba * se_dev->prot_length;
        prot_offset = do_div(tmp, PAGE_SIZE);
@@ -423,13 +412,14 @@ static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, bool is_read)
        prot_sg = &prot_table->sg_table[prot_page -
                                        prot_table->page_start_offset];
 
-       if (is_read)
-               rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
-                                   prot_sg, prot_offset);
-       else
-               rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
-                                   cmd->t_prot_sg, 0);
-
+       if (se_dev->dev_attrib.pi_prot_verify) {
+               if (is_read)
+                       rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
+                                           prot_sg, prot_offset);
+               else
+                       rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
+                                           cmd->t_prot_sg, 0);
+       }
        if (!rc)
                sbc_dif_copy_prot(cmd, sectors, is_read, prot_sg, prot_offset);
 
@@ -568,7 +558,7 @@ static ssize_t rd_set_configfs_dev_params(struct se_device *dev,
        struct rd_dev *rd_dev = RD_DEV(dev);
        char *orig, *ptr, *opts;
        substring_t args[MAX_OPT_ARGS];
-       int ret = 0, arg, token;
+       int arg, token;
 
        opts = kstrdup(page, GFP_KERNEL);
        if (!opts)
@@ -603,7 +593,7 @@ static ssize_t rd_set_configfs_dev_params(struct se_device *dev,
        }
 
        kfree(orig);
-       return (!ret) ? count : ret;
+       return count;
 }
 
 static ssize_t rd_show_configfs_dev_params(struct se_device *dev, char *b)
@@ -665,6 +655,7 @@ static const struct target_backend_ops rd_mcp_ops = {
        .detach_hba             = rd_detach_hba,
        .alloc_device           = rd_alloc_device,
        .configure_device       = rd_configure_device,
+       .destroy_device         = rd_destroy_device,
        .free_device            = rd_free_device,
        .parse_cdb              = rd_parse_cdb,
        .set_configfs_dev_params = rd_set_configfs_dev_params,