diff options
author | 2016-04-11 10:41:07 +0300 | |
---|---|---|
committer | 2016-04-13 08:17:18 +0300 | |
commit | e09b41010ba33a20a87472ee821fa407a5b8da36 (patch) | |
tree | d10dc367189862e7ca5c592f033dc3726e1df4e3 /kernel/drivers/target/target_core_configfs.c | |
parent | f93b97fd65072de626c074dbe099a1fff05ce060 (diff) |
These changes are the raw update to linux-4.4.6-rt14. Kernel sources
are taken from kernel.org, and rt patch from the rt wiki download page.
During the rebasing, the following patch collided:
Force tick interrupt and get rid of softirq magic(I70131fb85).
Collisions have been removed because its logic was found on the
source already.
Change-Id: I7f57a4081d9deaa0d9ccfc41a6c8daccdee3b769
Signed-off-by: José Pekkarinen <jose.pekkarinen@nokia.com>
Diffstat (limited to 'kernel/drivers/target/target_core_configfs.c')
-rw-r--r-- | kernel/drivers/target/target_core_configfs.c | 1716 |
1 files changed, 975 insertions, 741 deletions
diff --git a/kernel/drivers/target/target_core_configfs.c b/kernel/drivers/target/target_core_configfs.c index e7b0430a0..b9b9ffde4 100644 --- a/kernel/drivers/target/target_core_configfs.c +++ b/kernel/drivers/target/target_core_configfs.c @@ -40,9 +40,6 @@ #include <target/target_core_base.h> #include <target/target_core_backend.h> #include <target/target_core_fabric.h> -#include <target/target_core_fabric_configfs.h> -#include <target/target_core_configfs.h> -#include <target/configfs_macros.h> #include "target_core_internal.h" #include "target_core_alua.h" @@ -51,15 +48,26 @@ #include "target_core_xcopy.h" #define TB_CIT_SETUP(_name, _item_ops, _group_ops, _attrs) \ -static void target_core_setup_##_name##_cit(struct se_subsystem_api *sa) \ +static void target_core_setup_##_name##_cit(struct target_backend *tb) \ { \ - struct target_backend_cits *tbc = &sa->tb_cits; \ - struct config_item_type *cit = &tbc->tb_##_name##_cit; \ + struct config_item_type *cit = &tb->tb_##_name##_cit; \ \ cit->ct_item_ops = _item_ops; \ cit->ct_group_ops = _group_ops; \ cit->ct_attrs = _attrs; \ - cit->ct_owner = sa->owner; \ + cit->ct_owner = tb->ops->owner; \ + pr_debug("Setup generic %s\n", __stringify(_name)); \ +} + +#define TB_CIT_SETUP_DRV(_name, _item_ops, _group_ops) \ +static void target_core_setup_##_name##_cit(struct target_backend *tb) \ +{ \ + struct config_item_type *cit = &tb->tb_##_name##_cit; \ + \ + cit->ct_item_ops = _item_ops; \ + cit->ct_group_ops = _group_ops; \ + cit->ct_attrs = tb->ops->tb_##_name##_attrs; \ + cit->ct_owner = tb->ops->owner; \ pr_debug("Setup generic %s\n", __stringify(_name)); \ } @@ -68,12 +76,6 @@ extern struct t10_alua_lu_gp *default_lu_gp; static LIST_HEAD(g_tf_list); static DEFINE_MUTEX(g_tf_lock); -struct target_core_configfs_attribute { - struct configfs_attribute attr; - ssize_t (*show)(void *, char *); - ssize_t (*store)(void *, const char *, size_t); -}; - static struct config_group target_core_hbagroup; static struct config_group alua_group; static struct config_group alua_lu_gps_group; @@ -87,24 +89,15 @@ item_to_hba(struct config_item *item) /* * Attributes for /sys/kernel/config/target/ */ -static ssize_t target_core_attr_show(struct config_item *item, - struct configfs_attribute *attr, - char *page) +static ssize_t target_core_item_version_show(struct config_item *item, + char *page) { return sprintf(page, "Target Engine Core ConfigFS Infrastructure %s" - " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_CONFIGFS_VERSION, + " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine); } -static struct configfs_item_operations target_core_fabric_item_ops = { - .show_attribute = target_core_attr_show, -}; - -static struct configfs_attribute target_core_item_attr_version = { - .ca_owner = THIS_MODULE, - .ca_name = "version", - .ca_mode = S_IRUGO, -}; +CONFIGFS_ATTR_RO(target_core_item_, version); static struct target_fabric_configfs *target_core_get_fabric( const char *name) @@ -116,7 +109,7 @@ static struct target_fabric_configfs *target_core_get_fabric( mutex_lock(&g_tf_lock); list_for_each_entry(tf, &g_tf_list, tf_list) { - if (!strcmp(tf->tf_name, name)) { + if (!strcmp(tf->tf_ops->name, name)) { atomic_inc(&tf->tf_access_cnt); mutex_unlock(&g_tf_lock); return tf; @@ -193,29 +186,24 @@ static struct config_group *target_core_register_fabric( return ERR_PTR(-EINVAL); } pr_debug("Target_Core_ConfigFS: REGISTER -> Located fabric:" - " %s\n", tf->tf_name); + " %s\n", tf->tf_ops->name); /* * On a successful target_core_get_fabric() look, the returned * struct target_fabric_configfs *tf will contain a usage reference. */ pr_debug("Target_Core_ConfigFS: REGISTER tfc_wwn_cit -> %p\n", - &tf->tf_cit_tmpl.tfc_wwn_cit); + &tf->tf_wwn_cit); tf->tf_group.default_groups = tf->tf_default_groups; tf->tf_group.default_groups[0] = &tf->tf_disc_group; tf->tf_group.default_groups[1] = NULL; - config_group_init_type_name(&tf->tf_group, name, - &tf->tf_cit_tmpl.tfc_wwn_cit); + config_group_init_type_name(&tf->tf_group, name, &tf->tf_wwn_cit); config_group_init_type_name(&tf->tf_disc_group, "discovery_auth", - &tf->tf_cit_tmpl.tfc_discovery_cit); + &tf->tf_discovery_cit); pr_debug("Target_Core_ConfigFS: REGISTER -> Allocated Fabric:" " %s\n", tf->tf_group.cg_item.ci_name); - tf->tf_fabric = &tf->tf_group.cg_item; - pr_debug("Target_Core_ConfigFS: REGISTER -> Set tf->tf_fabric" - " for %s\n", name); - return &tf->tf_group; } @@ -236,13 +224,9 @@ static void target_core_deregister_fabric( " tf list\n", config_item_name(item)); pr_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric:" - " %s\n", tf->tf_name); + " %s\n", tf->tf_ops->name); atomic_dec(&tf->tf_access_cnt); - pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing" - " tf->tf_fabric for %s\n", tf->tf_name); - tf->tf_fabric = NULL; - pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci" " %s\n", config_item_name(item)); @@ -272,7 +256,6 @@ static struct configfs_attribute *target_core_fabric_item_attrs[] = { * Provides Fabrics Groups and Item Attributes for /sys/kernel/config/target/ */ static struct config_item_type target_core_fabrics_item = { - .ct_item_ops = &target_core_fabric_item_ops, .ct_group_ops = &target_core_fabric_group_ops, .ct_attrs = target_core_fabric_item_attrs, .ct_owner = THIS_MODULE, @@ -318,10 +301,6 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo) pr_err("Missing tfo->get_fabric_name()\n"); return -EINVAL; } - if (!tfo->get_fabric_proto_ident) { - pr_err("Missing tfo->get_fabric_proto_ident()\n"); - return -EINVAL; - } if (!tfo->tpg_get_wwn) { pr_err("Missing tfo->tpg_get_wwn()\n"); return -EINVAL; @@ -330,18 +309,6 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo) pr_err("Missing tfo->tpg_get_tag()\n"); return -EINVAL; } - if (!tfo->tpg_get_default_depth) { - pr_err("Missing tfo->tpg_get_default_depth()\n"); - return -EINVAL; - } - if (!tfo->tpg_get_pr_transport_id) { - pr_err("Missing tfo->tpg_get_pr_transport_id()\n"); - return -EINVAL; - } - if (!tfo->tpg_get_pr_transport_id_len) { - pr_err("Missing tfo->tpg_get_pr_transport_id_len()\n"); - return -EINVAL; - } if (!tfo->tpg_check_demo_mode) { pr_err("Missing tfo->tpg_check_demo_mode()\n"); return -EINVAL; @@ -358,14 +325,6 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo) pr_err("Missing tfo->tpg_check_prod_mode_write_protect()\n"); return -EINVAL; } - if (!tfo->tpg_alloc_fabric_acl) { - pr_err("Missing tfo->tpg_alloc_fabric_acl()\n"); - return -EINVAL; - } - if (!tfo->tpg_release_fabric_acl) { - pr_err("Missing tfo->tpg_release_fabric_acl()\n"); - return -EINVAL; - } if (!tfo->tpg_get_inst_index) { pr_err("Missing tfo->tpg_get_inst_index()\n"); return -EINVAL; @@ -398,10 +357,6 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo) pr_err("Missing tfo->set_default_node_attributes()\n"); return -EINVAL; } - if (!tfo->get_task_tag) { - pr_err("Missing tfo->get_task_tag()\n"); - return -EINVAL; - } if (!tfo->get_cmd_state) { pr_err("Missing tfo->get_cmd_state()\n"); return -EINVAL; @@ -464,15 +419,7 @@ int target_register_template(const struct target_core_fabric_ops *fo) INIT_LIST_HEAD(&tf->tf_list); atomic_set(&tf->tf_access_cnt, 0); - - /* - * Setup the default generic struct config_item_type's (cits) in - * struct target_fabric_configfs->tf_cit_tmpl - */ - tf->tf_module = fo->module; - snprintf(tf->tf_name, TARGET_FABRIC_NAME_SIZE, "%s", fo->name); - - tf->tf_ops = *fo; + tf->tf_ops = fo; target_fabric_setup_cits(tf); mutex_lock(&g_tf_lock); @@ -489,11 +436,18 @@ void target_unregister_template(const struct target_core_fabric_ops *fo) mutex_lock(&g_tf_lock); list_for_each_entry(t, &g_tf_list, tf_list) { - if (!strcmp(t->tf_name, fo->name)) { + if (!strcmp(t->tf_ops->name, fo->name)) { BUG_ON(atomic_read(&t->tf_access_cnt)); list_del(&t->tf_list); + mutex_unlock(&g_tf_lock); + /* + * Wait for any outstanding fabric se_deve_entry->rcu_head + * callbacks to complete post kfree_rcu(), before allowing + * fabric driver unload of TFO->module to proceed. + */ + rcu_barrier(); kfree(t); - break; + return; } } mutex_unlock(&g_tf_lock); @@ -504,53 +458,626 @@ EXPORT_SYMBOL(target_unregister_template); // Stop functions called by external Target Fabrics Modules //############################################################################*/ +static inline struct se_dev_attrib *to_attrib(struct config_item *item) +{ + return container_of(to_config_group(item), struct se_dev_attrib, + da_group); +} + /* Start functions for struct config_item_type tb_dev_attrib_cit */ +#define DEF_CONFIGFS_ATTRIB_SHOW(_name) \ +static ssize_t _name##_show(struct config_item *item, char *page) \ +{ \ + return snprintf(page, PAGE_SIZE, "%u\n", to_attrib(item)->_name); \ +} + +DEF_CONFIGFS_ATTRIB_SHOW(emulate_model_alias); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_dpo); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_write); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_read); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_write_cache); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_ua_intlck_ctrl); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_tas); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpu); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpws); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_caw); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_3pc); +DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_type); +DEF_CONFIGFS_ATTRIB_SHOW(hw_pi_prot_type); +DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_format); +DEF_CONFIGFS_ATTRIB_SHOW(enforce_pr_isids); +DEF_CONFIGFS_ATTRIB_SHOW(is_nonrot); +DEF_CONFIGFS_ATTRIB_SHOW(emulate_rest_reord); +DEF_CONFIGFS_ATTRIB_SHOW(force_pr_aptpl); +DEF_CONFIGFS_ATTRIB_SHOW(hw_block_size); +DEF_CONFIGFS_ATTRIB_SHOW(block_size); +DEF_CONFIGFS_ATTRIB_SHOW(hw_max_sectors); +DEF_CONFIGFS_ATTRIB_SHOW(optimal_sectors); +DEF_CONFIGFS_ATTRIB_SHOW(hw_queue_depth); +DEF_CONFIGFS_ATTRIB_SHOW(queue_depth); +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(max_write_same_len); + +#define DEF_CONFIGFS_ATTRIB_STORE_U32(_name) \ +static ssize_t _name##_store(struct config_item *item, const char *page,\ + size_t count) \ +{ \ + struct se_dev_attrib *da = to_attrib(item); \ + u32 val; \ + int ret; \ + \ + ret = kstrtou32(page, 0, &val); \ + if (ret < 0) \ + return ret; \ + da->_name = val; \ + return count; \ +} + +DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_lba_count); +DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_block_desc_count); +DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity); +DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity_alignment); +DEF_CONFIGFS_ATTRIB_STORE_U32(max_write_same_len); + +#define DEF_CONFIGFS_ATTRIB_STORE_BOOL(_name) \ +static ssize_t _name##_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; \ + da->_name = flag; \ + return count; \ +} + +DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_fua_write); +DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_caw); +DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_3pc); +DEF_CONFIGFS_ATTRIB_STORE_BOOL(enforce_pr_isids); +DEF_CONFIGFS_ATTRIB_STORE_BOOL(is_nonrot); + +#define DEF_CONFIGFS_ATTRIB_STORE_STUB(_name) \ +static ssize_t _name##_store(struct config_item *item, const char *page,\ + size_t count) \ +{ \ + printk_once(KERN_WARNING \ + "ignoring deprecated ##_name## attribute\n"); \ + return count; \ +} + +DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_dpo); +DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_fua_read); + +static void dev_set_t10_wwn_model_alias(struct se_device *dev) +{ + const char *configname; + + configname = config_item_name(&dev->dev_group.cg_item); + if (strlen(configname) >= 16) { + pr_warn("dev[%p]: Backstore name '%s' is too long for " + "INQUIRY_MODEL, truncating to 16 bytes\n", dev, + configname); + } + snprintf(&dev->t10_wwn.model[0], 16, "%s", configname); +} -CONFIGFS_EATTR_STRUCT(target_core_dev_attrib, se_dev_attrib); -CONFIGFS_EATTR_OPS(target_core_dev_attrib, se_dev_attrib, da_group); +static ssize_t emulate_model_alias_store(struct config_item *item, + const char *page, size_t count) +{ + struct se_dev_attrib *da = to_attrib(item); + struct se_device *dev = da->da_dev; + bool flag; + int ret; + + if (dev->export_count) { + pr_err("dev[%p]: Unable to change model alias" + " while export_count is %d\n", + dev, dev->export_count); + return -EINVAL; + } + + ret = strtobool(page, &flag); + if (ret < 0) + return ret; + + if (flag) { + dev_set_t10_wwn_model_alias(dev); + } else { + strncpy(&dev->t10_wwn.model[0], + dev->transport->inquiry_prod, 16); + } + da->emulate_model_alias = flag; + return count; +} + +static ssize_t emulate_write_cache_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 (flag && da->da_dev->transport->get_write_cache) { + pr_err("emulate_write_cache not supported for this device\n"); + return -EINVAL; + } + + da->emulate_write_cache = flag; + pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n", + da->da_dev, flag); + return count; +} + +static ssize_t emulate_ua_intlck_ctrl_store(struct config_item *item, + const char *page, size_t count) +{ + struct se_dev_attrib *da = to_attrib(item); + u32 val; + int ret; + + ret = kstrtou32(page, 0, &val); + if (ret < 0) + return ret; + + if (val != 0 && val != 1 && val != 2) { + pr_err("Illegal value %d\n", val); + return -EINVAL; + } + + if (da->da_dev->export_count) { + pr_err("dev[%p]: Unable to change SE Device" + " UA_INTRLCK_CTRL while export_count is %d\n", + da->da_dev, da->da_dev->export_count); + return -EINVAL; + } + da->emulate_ua_intlck_ctrl = val; + pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n", + da->da_dev, val); + return count; +} + +static ssize_t emulate_tas_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 TAS while" + " export_count is %d\n", + da->da_dev, da->da_dev->export_count); + return -EINVAL; + } + da->emulate_tas = flag; + pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n", + da->da_dev, flag ? "Enabled" : "Disabled"); + + return count; +} + +static ssize_t emulate_tpu_store(struct config_item *item, + const char *page, size_t count) +{ + struct se_dev_attrib *da = to_attrib(item); + bool flag; + int ret; -static struct configfs_item_operations target_core_dev_attrib_ops = { - .show_attribute = target_core_dev_attrib_attr_show, - .store_attribute = target_core_dev_attrib_attr_store, + ret = strtobool(page, &flag); + if (ret < 0) + return ret; + + /* + * We expect this value to be non-zero when generic Block Layer + * Discard supported is detected iblock_create_virtdevice(). + */ + if (flag && !da->max_unmap_block_desc_count) { + pr_err("Generic Block Discard not supported\n"); + return -ENOSYS; + } + + da->emulate_tpu = flag; + pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n", + da->da_dev, flag); + return count; +} + +static ssize_t emulate_tpws_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; + + /* + * We expect this value to be non-zero when generic Block Layer + * Discard supported is detected iblock_create_virtdevice(). + */ + if (flag && !da->max_unmap_block_desc_count) { + pr_err("Generic Block Discard not supported\n"); + return -ENOSYS; + } + + da->emulate_tpws = flag; + pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n", + da->da_dev, flag); + return count; +} + +static ssize_t pi_prot_type_store(struct config_item *item, + const char *page, size_t count) +{ + struct se_dev_attrib *da = to_attrib(item); + int old_prot = da->pi_prot_type, ret; + struct se_device *dev = da->da_dev; + u32 flag; + + ret = kstrtou32(page, 0, &flag); + if (ret < 0) + return ret; + + if (flag != 0 && flag != 1 && flag != 2 && flag != 3) { + pr_err("Illegal value %d for pi_prot_type\n", flag); + return -EINVAL; + } + if (flag == 2) { + pr_err("DIF TYPE2 protection currently not supported\n"); + return -ENOSYS; + } + if (da->hw_pi_prot_type) { + pr_warn("DIF protection enabled on underlying hardware," + " ignoring\n"); + return count; + } + if (!dev->transport->init_prot || !dev->transport->free_prot) { + /* 0 is only allowed value for non-supporting backends */ + if (flag == 0) + return count; + + pr_err("DIF protection not supported by backend: %s\n", + dev->transport->name); + return -ENOSYS; + } + if (!(dev->dev_flags & DF_CONFIGURED)) { + pr_err("DIF protection requires device to be configured\n"); + return -ENODEV; + } + if (dev->export_count) { + pr_err("dev[%p]: Unable to change SE Device PROT type while" + " export_count is %d\n", dev, dev->export_count); + return -EINVAL; + } + + da->pi_prot_type = flag; + + if (flag && !old_prot) { + ret = dev->transport->init_prot(dev); + if (ret) { + da->pi_prot_type = old_prot; + return ret; + } + + } else if (!flag && old_prot) { + dev->transport->free_prot(dev); + } + + pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag); + return count; +} + +static ssize_t pi_prot_format_store(struct config_item *item, + const char *page, size_t count) +{ + struct se_dev_attrib *da = to_attrib(item); + struct se_device *dev = da->da_dev; + bool flag; + int ret; + + ret = strtobool(page, &flag); + if (ret < 0) + return ret; + + if (!flag) + return count; + + if (!dev->transport->format_prot) { + pr_err("DIF protection format not supported by backend %s\n", + dev->transport->name); + return -ENOSYS; + } + if (!(dev->dev_flags & DF_CONFIGURED)) { + pr_err("DIF protection format requires device to be configured\n"); + return -ENODEV; + } + if (dev->export_count) { + pr_err("dev[%p]: Unable to format SE Device PROT type while" + " export_count is %d\n", dev, dev->export_count); + return -EINVAL; + } + + ret = dev->transport->format_prot(dev); + if (ret) + return ret; + + pr_debug("dev[%p]: SE Device Protection Format complete\n", dev); + return count; +} + +static ssize_t force_pr_aptpl_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 set force_pr_aptpl while" + " export_count is %d\n", + da->da_dev, da->da_dev->export_count); + return -EINVAL; + } + + da->force_pr_aptpl = flag; + pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", da->da_dev, flag); + return count; +} + +static ssize_t emulate_rest_reord_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 (flag != 0) { + printk(KERN_ERR "dev[%p]: SE Device emulation of restricted" + " reordering not implemented\n", da->da_dev); + return -ENOSYS; + } + da->emulate_rest_reord = flag; + pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", + da->da_dev, flag); + return count; +} + +/* + * Note, this can only be called on unexported SE Device Object. + */ +static ssize_t queue_depth_store(struct config_item *item, + const char *page, size_t count) +{ + struct se_dev_attrib *da = to_attrib(item); + struct se_device *dev = da->da_dev; + u32 val; + int ret; + + ret = kstrtou32(page, 0, &val); + if (ret < 0) + return ret; + + if (dev->export_count) { + pr_err("dev[%p]: Unable to change SE Device TCQ while" + " export_count is %d\n", + dev, dev->export_count); + return -EINVAL; + } + if (!val) { + pr_err("dev[%p]: Illegal ZERO value for queue_depth\n", dev); + return -EINVAL; + } + + if (val > dev->dev_attrib.queue_depth) { + if (val > dev->dev_attrib.hw_queue_depth) { + pr_err("dev[%p]: Passed queue_depth:" + " %u exceeds TCM/SE_Device MAX" + " TCQ: %u\n", dev, val, + dev->dev_attrib.hw_queue_depth); + return -EINVAL; + } + } + da->queue_depth = dev->queue_depth = val; + pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n", dev, val); + return count; +} + +static ssize_t optimal_sectors_store(struct config_item *item, + const char *page, size_t count) +{ + struct se_dev_attrib *da = to_attrib(item); + u32 val; + int ret; + + ret = kstrtou32(page, 0, &val); + if (ret < 0) + return ret; + + if (da->da_dev->export_count) { + pr_err("dev[%p]: Unable to change SE Device" + " optimal_sectors while export_count is %d\n", + da->da_dev, da->da_dev->export_count); + return -EINVAL; + } + if (val > da->hw_max_sectors) { + pr_err("dev[%p]: Passed optimal_sectors %u cannot be" + " greater than hw_max_sectors: %u\n", + da->da_dev, val, da->hw_max_sectors); + return -EINVAL; + } + + da->optimal_sectors = val; + pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n", + da->da_dev, val); + return count; +} + +static ssize_t block_size_store(struct config_item *item, + const char *page, size_t count) +{ + struct se_dev_attrib *da = to_attrib(item); + u32 val; + int ret; + + ret = kstrtou32(page, 0, &val); + if (ret < 0) + return ret; + + if (da->da_dev->export_count) { + pr_err("dev[%p]: Unable to change SE Device block_size" + " while export_count is %d\n", + da->da_dev, da->da_dev->export_count); + return -EINVAL; + } + + if (val != 512 && val != 1024 && val != 2048 && val != 4096) { + pr_err("dev[%p]: Illegal value for block_device: %u" + " for SE device, must be 512, 1024, 2048 or 4096\n", + da->da_dev, val); + return -EINVAL; + } + + da->block_size = val; + if (da->max_bytes_per_io) + da->hw_max_sectors = da->max_bytes_per_io / val; + + pr_debug("dev[%p]: SE Device block_size changed to %u\n", + da->da_dev, val); + return count; +} + +CONFIGFS_ATTR(, emulate_model_alias); +CONFIGFS_ATTR(, emulate_dpo); +CONFIGFS_ATTR(, emulate_fua_write); +CONFIGFS_ATTR(, emulate_fua_read); +CONFIGFS_ATTR(, emulate_write_cache); +CONFIGFS_ATTR(, emulate_ua_intlck_ctrl); +CONFIGFS_ATTR(, emulate_tas); +CONFIGFS_ATTR(, emulate_tpu); +CONFIGFS_ATTR(, emulate_tpws); +CONFIGFS_ATTR(, emulate_caw); +CONFIGFS_ATTR(, emulate_3pc); +CONFIGFS_ATTR(, pi_prot_type); +CONFIGFS_ATTR_RO(, hw_pi_prot_type); +CONFIGFS_ATTR(, pi_prot_format); +CONFIGFS_ATTR(, enforce_pr_isids); +CONFIGFS_ATTR(, is_nonrot); +CONFIGFS_ATTR(, emulate_rest_reord); +CONFIGFS_ATTR(, force_pr_aptpl); +CONFIGFS_ATTR_RO(, hw_block_size); +CONFIGFS_ATTR(, block_size); +CONFIGFS_ATTR_RO(, hw_max_sectors); +CONFIGFS_ATTR(, optimal_sectors); +CONFIGFS_ATTR_RO(, hw_queue_depth); +CONFIGFS_ATTR(, queue_depth); +CONFIGFS_ATTR(, max_unmap_lba_count); +CONFIGFS_ATTR(, max_unmap_block_desc_count); +CONFIGFS_ATTR(, unmap_granularity); +CONFIGFS_ATTR(, unmap_granularity_alignment); +CONFIGFS_ATTR(, max_write_same_len); + +/* + * dev_attrib attributes for devices using the target core SBC/SPC + * interpreter. Any backend using spc_parse_cdb should be using + * these. + */ +struct configfs_attribute *sbc_attrib_attrs[] = { + &attr_emulate_model_alias, + &attr_emulate_dpo, + &attr_emulate_fua_write, + &attr_emulate_fua_read, + &attr_emulate_write_cache, + &attr_emulate_ua_intlck_ctrl, + &attr_emulate_tas, + &attr_emulate_tpu, + &attr_emulate_tpws, + &attr_emulate_caw, + &attr_emulate_3pc, + &attr_pi_prot_type, + &attr_hw_pi_prot_type, + &attr_pi_prot_format, + &attr_enforce_pr_isids, + &attr_is_nonrot, + &attr_emulate_rest_reord, + &attr_force_pr_aptpl, + &attr_hw_block_size, + &attr_block_size, + &attr_hw_max_sectors, + &attr_optimal_sectors, + &attr_hw_queue_depth, + &attr_queue_depth, + &attr_max_unmap_lba_count, + &attr_max_unmap_block_desc_count, + &attr_unmap_granularity, + &attr_unmap_granularity_alignment, + &attr_max_write_same_len, + NULL, }; +EXPORT_SYMBOL(sbc_attrib_attrs); -TB_CIT_SETUP(dev_attrib, &target_core_dev_attrib_ops, NULL, NULL); +/* + * Minimal dev_attrib attributes for devices passing through CDBs. + * In this case we only provide a few read-only attributes for + * backwards compatibility. + */ +struct configfs_attribute *passthrough_attrib_attrs[] = { + &attr_hw_pi_prot_type, + &attr_hw_block_size, + &attr_hw_max_sectors, + &attr_hw_queue_depth, + NULL, +}; +EXPORT_SYMBOL(passthrough_attrib_attrs); + +TB_CIT_SETUP_DRV(dev_attrib, NULL, NULL); /* End functions for struct config_item_type tb_dev_attrib_cit */ /* Start functions for struct config_item_type tb_dev_wwn_cit */ -CONFIGFS_EATTR_STRUCT(target_core_dev_wwn, t10_wwn); -#define SE_DEV_WWN_ATTR(_name, _mode) \ -static struct target_core_dev_wwn_attribute target_core_dev_wwn_##_name = \ - __CONFIGFS_EATTR(_name, _mode, \ - target_core_dev_wwn_show_attr_##_name, \ - target_core_dev_wwn_store_attr_##_name); - -#define SE_DEV_WWN_ATTR_RO(_name); \ -do { \ - static struct target_core_dev_wwn_attribute \ - target_core_dev_wwn_##_name = \ - __CONFIGFS_EATTR_RO(_name, \ - target_core_dev_wwn_show_attr_##_name); \ -} while (0); +static struct t10_wwn *to_t10_wwn(struct config_item *item) +{ + return container_of(to_config_group(item), struct t10_wwn, t10_wwn_group); +} /* * VPD page 0x80 Unit serial */ -static ssize_t target_core_dev_wwn_show_attr_vpd_unit_serial( - struct t10_wwn *t10_wwn, - char *page) +static ssize_t target_wwn_vpd_unit_serial_show(struct config_item *item, + char *page) { return sprintf(page, "T10 VPD Unit Serial Number: %s\n", - &t10_wwn->unit_serial[0]); + &to_t10_wwn(item)->unit_serial[0]); } -static ssize_t target_core_dev_wwn_store_attr_vpd_unit_serial( - struct t10_wwn *t10_wwn, - const char *page, - size_t count) +static ssize_t target_wwn_vpd_unit_serial_store(struct config_item *item, + const char *page, size_t count) { + struct t10_wwn *t10_wwn = to_t10_wwn(item); struct se_device *dev = t10_wwn->t10_dev; unsigned char buf[INQUIRY_VPD_SERIAL_LEN]; @@ -606,15 +1133,13 @@ static ssize_t target_core_dev_wwn_store_attr_vpd_unit_serial( return count; } -SE_DEV_WWN_ATTR(vpd_unit_serial, S_IRUGO | S_IWUSR); - /* * VPD page 0x83 Protocol Identifier */ -static ssize_t target_core_dev_wwn_show_attr_vpd_protocol_identifier( - struct t10_wwn *t10_wwn, - char *page) +static ssize_t target_wwn_vpd_protocol_identifier_show(struct config_item *item, + char *page) { + struct t10_wwn *t10_wwn = to_t10_wwn(item); struct t10_vpd *vpd; unsigned char buf[VPD_TMP_BUF_SIZE]; ssize_t len = 0; @@ -638,25 +1163,15 @@ static ssize_t target_core_dev_wwn_show_attr_vpd_protocol_identifier( return len; } -static ssize_t target_core_dev_wwn_store_attr_vpd_protocol_identifier( - struct t10_wwn *t10_wwn, - const char *page, - size_t count) -{ - return -ENOSYS; -} - -SE_DEV_WWN_ATTR(vpd_protocol_identifier, S_IRUGO | S_IWUSR); - /* * Generic wrapper for dumping VPD identifiers by association. */ #define DEF_DEV_WWN_ASSOC_SHOW(_name, _assoc) \ -static ssize_t target_core_dev_wwn_show_attr_##_name( \ - struct t10_wwn *t10_wwn, \ - char *page) \ +static ssize_t target_wwn_##_name##_show(struct config_item *item, \ + char *page) \ { \ - struct t10_vpd *vpd; \ + struct t10_wwn *t10_wwn = to_t10_wwn(item); \ + struct t10_vpd *vpd; \ unsigned char buf[VPD_TMP_BUF_SIZE]; \ ssize_t len = 0; \ \ @@ -688,84 +1203,39 @@ static ssize_t target_core_dev_wwn_show_attr_##_name( \ return len; \ } -/* - * VPD page 0x83 Association: Logical Unit - */ +/* VPD page 0x83 Association: Logical Unit */ DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_logical_unit, 0x00); - -static ssize_t target_core_dev_wwn_store_attr_vpd_assoc_logical_unit( - struct t10_wwn *t10_wwn, - const char *page, - size_t count) -{ - return -ENOSYS; -} - -SE_DEV_WWN_ATTR(vpd_assoc_logical_unit, S_IRUGO | S_IWUSR); - -/* - * VPD page 0x83 Association: Target Port - */ +/* VPD page 0x83 Association: Target Port */ DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_target_port, 0x10); - -static ssize_t target_core_dev_wwn_store_attr_vpd_assoc_target_port( - struct t10_wwn *t10_wwn, - const char *page, - size_t count) -{ - return -ENOSYS; -} - -SE_DEV_WWN_ATTR(vpd_assoc_target_port, S_IRUGO | S_IWUSR); - -/* - * VPD page 0x83 Association: SCSI Target Device - */ +/* VPD page 0x83 Association: SCSI Target Device */ DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_scsi_target_device, 0x20); -static ssize_t target_core_dev_wwn_store_attr_vpd_assoc_scsi_target_device( - struct t10_wwn *t10_wwn, - const char *page, - size_t count) -{ - return -ENOSYS; -} - -SE_DEV_WWN_ATTR(vpd_assoc_scsi_target_device, S_IRUGO | S_IWUSR); - -CONFIGFS_EATTR_OPS(target_core_dev_wwn, t10_wwn, t10_wwn_group); +CONFIGFS_ATTR(target_wwn_, vpd_unit_serial); +CONFIGFS_ATTR_RO(target_wwn_, vpd_protocol_identifier); +CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_logical_unit); +CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_target_port); +CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_scsi_target_device); static struct configfs_attribute *target_core_dev_wwn_attrs[] = { - &target_core_dev_wwn_vpd_unit_serial.attr, - &target_core_dev_wwn_vpd_protocol_identifier.attr, - &target_core_dev_wwn_vpd_assoc_logical_unit.attr, - &target_core_dev_wwn_vpd_assoc_target_port.attr, - &target_core_dev_wwn_vpd_assoc_scsi_target_device.attr, + &target_wwn_attr_vpd_unit_serial, + &target_wwn_attr_vpd_protocol_identifier, + &target_wwn_attr_vpd_assoc_logical_unit, + &target_wwn_attr_vpd_assoc_target_port, + &target_wwn_attr_vpd_assoc_scsi_target_device, NULL, }; -static struct configfs_item_operations target_core_dev_wwn_ops = { - .show_attribute = target_core_dev_wwn_attr_show, - .store_attribute = target_core_dev_wwn_attr_store, -}; - -TB_CIT_SETUP(dev_wwn, &target_core_dev_wwn_ops, NULL, target_core_dev_wwn_attrs); +TB_CIT_SETUP(dev_wwn, NULL, NULL, target_core_dev_wwn_attrs); /* End functions for struct config_item_type tb_dev_wwn_cit */ /* Start functions for struct config_item_type tb_dev_pr_cit */ -CONFIGFS_EATTR_STRUCT(target_core_dev_pr, se_device); -#define SE_DEV_PR_ATTR(_name, _mode) \ -static struct target_core_dev_pr_attribute target_core_dev_pr_##_name = \ - __CONFIGFS_EATTR(_name, _mode, \ - target_core_dev_pr_show_attr_##_name, \ - target_core_dev_pr_store_attr_##_name); - -#define SE_DEV_PR_ATTR_RO(_name); \ -static struct target_core_dev_pr_attribute target_core_dev_pr_##_name = \ - __CONFIGFS_EATTR_RO(_name, \ - target_core_dev_pr_show_attr_##_name); +static struct se_device *pr_to_dev(struct config_item *item) +{ + return container_of(to_config_group(item), struct se_device, + dev_pr_group); +} static ssize_t target_core_dev_pr_show_spc3_res(struct se_device *dev, char *page) @@ -806,9 +1276,9 @@ static ssize_t target_core_dev_pr_show_spc2_res(struct se_device *dev, return len; } -static ssize_t target_core_dev_pr_show_attr_res_holder(struct se_device *dev, - char *page) +static ssize_t target_pr_res_holder_show(struct config_item *item, char *page) { + struct se_device *dev = pr_to_dev(item); int ret; if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH) @@ -823,11 +1293,10 @@ static ssize_t target_core_dev_pr_show_attr_res_holder(struct se_device *dev, return ret; } -SE_DEV_PR_ATTR_RO(res_holder); - -static ssize_t target_core_dev_pr_show_attr_res_pr_all_tgt_pts( - struct se_device *dev, char *page) +static ssize_t target_pr_res_pr_all_tgt_pts_show(struct config_item *item, + char *page) { + struct se_device *dev = pr_to_dev(item); ssize_t len = 0; spin_lock(&dev->dev_reservation_lock); @@ -845,24 +1314,18 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_all_tgt_pts( return len; } -SE_DEV_PR_ATTR_RO(res_pr_all_tgt_pts); - -static ssize_t target_core_dev_pr_show_attr_res_pr_generation( - struct se_device *dev, char *page) +static ssize_t target_pr_res_pr_generation_show(struct config_item *item, + char *page) { - return sprintf(page, "0x%08x\n", dev->t10_pr.pr_generation); + return sprintf(page, "0x%08x\n", pr_to_dev(item)->t10_pr.pr_generation); } -SE_DEV_PR_ATTR_RO(res_pr_generation); -/* - * res_pr_holder_tg_port - */ -static ssize_t target_core_dev_pr_show_attr_res_pr_holder_tg_port( - struct se_device *dev, char *page) +static ssize_t target_pr_res_pr_holder_tg_port_show(struct config_item *item, + char *page) { + struct se_device *dev = pr_to_dev(item); struct se_node_acl *se_nacl; - struct se_lun *lun; struct se_portal_group *se_tpg; struct t10_pr_registration *pr_reg; const struct target_core_fabric_ops *tfo; @@ -877,7 +1340,6 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_holder_tg_port( se_nacl = pr_reg->pr_reg_nacl; se_tpg = se_nacl->se_tpg; - lun = pr_reg->pr_reg_tg_pt_lun; tfo = se_tpg->se_tpg_tfo; len += sprintf(page+len, "SPC-3 Reservation: %s" @@ -885,20 +1347,20 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_holder_tg_port( tfo->tpg_get_wwn(se_tpg)); len += sprintf(page+len, "SPC-3 Reservation: Relative Port" " Identifier Tag: %hu %s Portal Group Tag: %hu" - " %s Logical Unit: %u\n", lun->lun_sep->sep_rtpi, + " %s Logical Unit: %llu\n", pr_reg->tg_pt_sep_rtpi, tfo->get_fabric_name(), tfo->tpg_get_tag(se_tpg), - tfo->get_fabric_name(), lun->unpacked_lun); + tfo->get_fabric_name(), pr_reg->pr_aptpl_target_lun); out_unlock: spin_unlock(&dev->dev_reservation_lock); return len; } -SE_DEV_PR_ATTR_RO(res_pr_holder_tg_port); -static ssize_t target_core_dev_pr_show_attr_res_pr_registered_i_pts( - struct se_device *dev, char *page) +static ssize_t target_pr_res_pr_registered_i_pts_show(struct config_item *item, + char *page) { + struct se_device *dev = pr_to_dev(item); const struct target_core_fabric_ops *tfo; struct t10_pr_registration *pr_reg; unsigned char buf[384]; @@ -936,11 +1398,9 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_registered_i_pts( return len; } -SE_DEV_PR_ATTR_RO(res_pr_registered_i_pts); - -static ssize_t target_core_dev_pr_show_attr_res_pr_type( - struct se_device *dev, char *page) +static ssize_t target_pr_res_pr_type_show(struct config_item *item, char *page) { + struct se_device *dev = pr_to_dev(item); struct t10_pr_registration *pr_reg; ssize_t len = 0; @@ -957,11 +1417,10 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_type( return len; } -SE_DEV_PR_ATTR_RO(res_pr_type); - -static ssize_t target_core_dev_pr_show_attr_res_type( - struct se_device *dev, char *page) +static ssize_t target_pr_res_type_show(struct config_item *item, char *page) { + struct se_device *dev = pr_to_dev(item); + if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH) return sprintf(page, "SPC_PASSTHROUGH\n"); else if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) @@ -970,11 +1429,11 @@ static ssize_t target_core_dev_pr_show_attr_res_type( return sprintf(page, "SPC3_PERSISTENT_RESERVATIONS\n"); } -SE_DEV_PR_ATTR_RO(res_type); - -static ssize_t target_core_dev_pr_show_attr_res_aptpl_active( - struct se_device *dev, char *page) +static ssize_t target_pr_res_aptpl_active_show(struct config_item *item, + char *page) { + struct se_device *dev = pr_to_dev(item); + if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH) return 0; @@ -982,14 +1441,11 @@ static ssize_t target_core_dev_pr_show_attr_res_aptpl_active( (dev->t10_pr.pr_aptpl_active) ? "Activated" : "Disabled"); } -SE_DEV_PR_ATTR_RO(res_aptpl_active); - -/* - * res_aptpl_metadata - */ -static ssize_t target_core_dev_pr_show_attr_res_aptpl_metadata( - struct se_device *dev, char *page) +static ssize_t target_pr_res_aptpl_metadata_show(struct config_item *item, + char *page) { + struct se_device *dev = pr_to_dev(item); + if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH) return 0; @@ -1012,35 +1468,34 @@ static match_table_t tokens = { {Opt_res_type, "res_type=%d"}, {Opt_res_scope, "res_scope=%d"}, {Opt_res_all_tg_pt, "res_all_tg_pt=%d"}, - {Opt_mapped_lun, "mapped_lun=%d"}, + {Opt_mapped_lun, "mapped_lun=%lld"}, {Opt_target_fabric, "target_fabric=%s"}, {Opt_target_node, "target_node=%s"}, {Opt_tpgt, "tpgt=%d"}, {Opt_port_rtpi, "port_rtpi=%d"}, - {Opt_target_lun, "target_lun=%d"}, + {Opt_target_lun, "target_lun=%lld"}, {Opt_err, NULL} }; -static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata( - struct se_device *dev, - const char *page, - size_t count) +static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item, + const char *page, size_t count) { + struct se_device *dev = pr_to_dev(item); unsigned char *i_fabric = NULL, *i_port = NULL, *isid = NULL; unsigned char *t_fabric = NULL, *t_port = NULL; char *orig, *ptr, *opts; substring_t args[MAX_OPT_ARGS]; unsigned long long tmp_ll; u64 sa_res_key = 0; - u32 mapped_lun = 0, target_lun = 0; + u64 mapped_lun = 0, target_lun = 0; int ret = -1, res_holder = 0, all_tg_pt = 0, arg, token; - u16 port_rpti = 0, tpgt = 0; - u8 type = 0, scope; + u16 tpgt = 0; + u8 type = 0; if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH) - return 0; + return count; if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) - return 0; + return count; if (dev->export_count) { pr_debug("Unable to process APTPL metadata while" @@ -1106,24 +1561,33 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata( * PR APTPL Metadata for Reservation */ case Opt_res_holder: - match_int(args, &arg); + ret = match_int(args, &arg); + if (ret) + goto out; res_holder = arg; break; case Opt_res_type: - match_int(args, &arg); + ret = match_int(args, &arg); + if (ret) + goto out; type = (u8)arg; break; case Opt_res_scope: - match_int(args, &arg); - scope = (u8)arg; + ret = match_int(args, &arg); + if (ret) + goto out; break; case Opt_res_all_tg_pt: - match_int(args, &arg); + ret = match_int(args, &arg); + if (ret) + goto out; all_tg_pt = (int)arg; break; case Opt_mapped_lun: - match_int(args, &arg); - mapped_lun = (u32)arg; + ret = match_int(args, &arg); + if (ret) + goto out; + mapped_lun = (u64)arg; break; /* * PR APTPL Metadata for Target Port @@ -1150,16 +1614,21 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata( } break; case Opt_tpgt: - match_int(args, &arg); + ret = match_int(args, &arg); + if (ret) + goto out; tpgt = (u16)arg; break; case Opt_port_rtpi: - match_int(args, &arg); - port_rpti = (u16)arg; + ret = match_int(args, &arg); + if (ret) + goto out; break; case Opt_target_lun: - match_int(args, &arg); - target_lun = (u32)arg; + ret = match_int(args, &arg); + if (ret) + goto out; + target_lun = (u64)arg; break; default: break; @@ -1192,77 +1661,65 @@ out: return (ret == 0) ? count : ret; } -SE_DEV_PR_ATTR(res_aptpl_metadata, S_IRUGO | S_IWUSR); -CONFIGFS_EATTR_OPS(target_core_dev_pr, se_device, dev_pr_group); +CONFIGFS_ATTR_RO(target_pr_, res_holder); +CONFIGFS_ATTR_RO(target_pr_, res_pr_all_tgt_pts); +CONFIGFS_ATTR_RO(target_pr_, res_pr_generation); +CONFIGFS_ATTR_RO(target_pr_, res_pr_holder_tg_port); +CONFIGFS_ATTR_RO(target_pr_, res_pr_registered_i_pts); +CONFIGFS_ATTR_RO(target_pr_, res_pr_type); +CONFIGFS_ATTR_RO(target_pr_, res_type); +CONFIGFS_ATTR_RO(target_pr_, res_aptpl_active); +CONFIGFS_ATTR(target_pr_, res_aptpl_metadata); static struct configfs_attribute *target_core_dev_pr_attrs[] = { - &target_core_dev_pr_res_holder.attr, - &target_core_dev_pr_res_pr_all_tgt_pts.attr, - &target_core_dev_pr_res_pr_generation.attr, - &target_core_dev_pr_res_pr_holder_tg_port.attr, - &target_core_dev_pr_res_pr_registered_i_pts.attr, - &target_core_dev_pr_res_pr_type.attr, - &target_core_dev_pr_res_type.attr, - &target_core_dev_pr_res_aptpl_active.attr, - &target_core_dev_pr_res_aptpl_metadata.attr, + &target_pr_attr_res_holder, + &target_pr_attr_res_pr_all_tgt_pts, + &target_pr_attr_res_pr_generation, + &target_pr_attr_res_pr_holder_tg_port, + &target_pr_attr_res_pr_registered_i_pts, + &target_pr_attr_res_pr_type, + &target_pr_attr_res_type, + &target_pr_attr_res_aptpl_active, + &target_pr_attr_res_aptpl_metadata, NULL, }; -static struct configfs_item_operations target_core_dev_pr_ops = { - .show_attribute = target_core_dev_pr_attr_show, - .store_attribute = target_core_dev_pr_attr_store, -}; - -TB_CIT_SETUP(dev_pr, &target_core_dev_pr_ops, NULL, target_core_dev_pr_attrs); +TB_CIT_SETUP(dev_pr, NULL, NULL, target_core_dev_pr_attrs); /* End functions for struct config_item_type tb_dev_pr_cit */ /* Start functions for struct config_item_type tb_dev_cit */ -static ssize_t target_core_show_dev_info(void *p, char *page) +static inline struct se_device *to_device(struct config_item *item) +{ + return container_of(to_config_group(item), struct se_device, dev_group); +} + +static ssize_t target_dev_info_show(struct config_item *item, char *page) { - struct se_device *dev = p; - struct se_subsystem_api *t = dev->transport; + struct se_device *dev = to_device(item); int bl = 0; ssize_t read_bytes = 0; transport_dump_dev_state(dev, page, &bl); read_bytes += bl; - read_bytes += t->show_configfs_dev_params(dev, page+read_bytes); + read_bytes += dev->transport->show_configfs_dev_params(dev, + page+read_bytes); return read_bytes; } -static struct target_core_configfs_attribute target_core_attr_dev_info = { - .attr = { .ca_owner = THIS_MODULE, - .ca_name = "info", - .ca_mode = S_IRUGO }, - .show = target_core_show_dev_info, - .store = NULL, -}; - -static ssize_t target_core_store_dev_control( - void *p, - const char *page, - size_t count) +static ssize_t target_dev_control_store(struct config_item *item, + const char *page, size_t count) { - struct se_device *dev = p; - struct se_subsystem_api *t = dev->transport; + struct se_device *dev = to_device(item); - return t->set_configfs_dev_params(dev, page, count); + return dev->transport->set_configfs_dev_params(dev, page, count); } -static struct target_core_configfs_attribute target_core_attr_dev_control = { - .attr = { .ca_owner = THIS_MODULE, - .ca_name = "control", - .ca_mode = S_IWUSR }, - .show = NULL, - .store = target_core_store_dev_control, -}; - -static ssize_t target_core_show_dev_alias(void *p, char *page) +static ssize_t target_dev_alias_show(struct config_item *item, char *page) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); if (!(dev->dev_flags & DF_USING_ALIAS)) return 0; @@ -1270,12 +1727,10 @@ static ssize_t target_core_show_dev_alias(void *p, char *page) return snprintf(page, PAGE_SIZE, "%s\n", dev->dev_alias); } -static ssize_t target_core_store_dev_alias( - void *p, - const char *page, - size_t count) +static ssize_t target_dev_alias_store(struct config_item *item, + const char *page, size_t count) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); struct se_hba *hba = dev->se_hba; ssize_t read_bytes; @@ -1302,17 +1757,9 @@ static ssize_t target_core_store_dev_alias( return read_bytes; } -static struct target_core_configfs_attribute target_core_attr_dev_alias = { - .attr = { .ca_owner = THIS_MODULE, - .ca_name = "alias", - .ca_mode = S_IRUGO | S_IWUSR }, - .show = target_core_show_dev_alias, - .store = target_core_store_dev_alias, -}; - -static ssize_t target_core_show_dev_udev_path(void *p, char *page) +static ssize_t target_dev_udev_path_show(struct config_item *item, char *page) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); if (!(dev->dev_flags & DF_USING_UDEV_PATH)) return 0; @@ -1320,12 +1767,10 @@ static ssize_t target_core_show_dev_udev_path(void *p, char *page) return snprintf(page, PAGE_SIZE, "%s\n", dev->udev_path); } -static ssize_t target_core_store_dev_udev_path( - void *p, - const char *page, - size_t count) +static ssize_t target_dev_udev_path_store(struct config_item *item, + const char *page, size_t count) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); struct se_hba *hba = dev->se_hba; ssize_t read_bytes; @@ -1353,27 +1798,17 @@ static ssize_t target_core_store_dev_udev_path( return read_bytes; } -static struct target_core_configfs_attribute target_core_attr_dev_udev_path = { - .attr = { .ca_owner = THIS_MODULE, - .ca_name = "udev_path", - .ca_mode = S_IRUGO | S_IWUSR }, - .show = target_core_show_dev_udev_path, - .store = target_core_store_dev_udev_path, -}; - -static ssize_t target_core_show_dev_enable(void *p, char *page) +static ssize_t target_dev_enable_show(struct config_item *item, char *page) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); return snprintf(page, PAGE_SIZE, "%d\n", !!(dev->dev_flags & DF_CONFIGURED)); } -static ssize_t target_core_store_dev_enable( - void *p, - const char *page, - size_t count) +static ssize_t target_dev_enable_store(struct config_item *item, + const char *page, size_t count) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); char *ptr; int ret; @@ -1390,17 +1825,9 @@ static ssize_t target_core_store_dev_enable( return count; } -static struct target_core_configfs_attribute target_core_attr_dev_enable = { - .attr = { .ca_owner = THIS_MODULE, - .ca_name = "enable", - .ca_mode = S_IRUGO | S_IWUSR }, - .show = target_core_show_dev_enable, - .store = target_core_store_dev_enable, -}; - -static ssize_t target_core_show_alua_lu_gp(void *p, char *page) +static ssize_t target_dev_alua_lu_gp_show(struct config_item *item, char *page) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); struct config_item *lu_ci; struct t10_alua_lu_gp *lu_gp; struct t10_alua_lu_gp_member *lu_gp_mem; @@ -1422,12 +1849,10 @@ static ssize_t target_core_show_alua_lu_gp(void *p, char *page) return len; } -static ssize_t target_core_store_alua_lu_gp( - void *p, - const char *page, - size_t count) +static ssize_t target_dev_alua_lu_gp_store(struct config_item *item, + const char *page, size_t count) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); struct se_hba *hba = dev->se_hba; struct t10_alua_lu_gp *lu_gp = NULL, *lu_gp_new = NULL; struct t10_alua_lu_gp_member *lu_gp_mem; @@ -1436,7 +1861,7 @@ static ssize_t target_core_store_alua_lu_gp( lu_gp_mem = dev->dev_alua_lu_gp_mem; if (!lu_gp_mem) - return 0; + return count; if (count > LU_GROUP_NAME_BUF) { pr_err("ALUA LU Group Alias too large!\n"); @@ -1504,17 +1929,9 @@ static ssize_t target_core_store_alua_lu_gp( return count; } -static struct target_core_configfs_attribute target_core_attr_dev_alua_lu_gp = { - .attr = { .ca_owner = THIS_MODULE, - .ca_name = "alua_lu_gp", - .ca_mode = S_IRUGO | S_IWUSR }, - .show = target_core_show_alua_lu_gp, - .store = target_core_store_alua_lu_gp, -}; - -static ssize_t target_core_show_dev_lba_map(void *p, char *page) +static ssize_t target_dev_lba_map_show(struct config_item *item, char *page) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); struct t10_alua_lba_map *map; struct t10_alua_lba_map_member *mem; char *b = page; @@ -1557,12 +1974,10 @@ static ssize_t target_core_show_dev_lba_map(void *p, char *page) return bl; } -static ssize_t target_core_store_dev_lba_map( - void *p, - const char *page, - size_t count) +static ssize_t target_dev_lba_map_store(struct config_item *item, + const char *page, size_t count) { - struct se_device *dev = p; + struct se_device *dev = to_device(item); struct t10_alua_lba_map *lba_map = NULL; struct list_head lba_list; char *map_entries, *ptr; @@ -1674,22 +2089,22 @@ out: return count; } -static struct target_core_configfs_attribute target_core_attr_dev_lba_map = { - .attr = { .ca_owner = THIS_MODULE, - .ca_name = "lba_map", - .ca_mode = S_IRUGO | S_IWUSR }, - .show = target_core_show_dev_lba_map, - .store = target_core_store_dev_lba_map, -}; +CONFIGFS_ATTR_RO(target_dev_, info); +CONFIGFS_ATTR_WO(target_dev_, control); +CONFIGFS_ATTR(target_dev_, alias); +CONFIGFS_ATTR(target_dev_, udev_path); +CONFIGFS_ATTR(target_dev_, enable); +CONFIGFS_ATTR(target_dev_, alua_lu_gp); +CONFIGFS_ATTR(target_dev_, lba_map); static struct configfs_attribute *target_core_dev_attrs[] = { - &target_core_attr_dev_info.attr, - &target_core_attr_dev_control.attr, - &target_core_attr_dev_alias.attr, - &target_core_attr_dev_udev_path.attr, - &target_core_attr_dev_enable.attr, - &target_core_attr_dev_alua_lu_gp.attr, - &target_core_attr_dev_lba_map.attr, + &target_dev_attr_info, + &target_dev_attr_control, + &target_dev_attr_alias, + &target_dev_attr_udev_path, + &target_dev_attr_enable, + &target_dev_attr_alua_lu_gp, + &target_dev_attr_lba_map, NULL, }; @@ -1703,42 +2118,8 @@ static void target_core_dev_release(struct config_item *item) target_free_device(dev); } -static ssize_t target_core_dev_show(struct config_item *item, - struct configfs_attribute *attr, - char *page) -{ - struct config_group *dev_cg = to_config_group(item); - struct se_device *dev = - container_of(dev_cg, struct se_device, dev_group); - struct target_core_configfs_attribute *tc_attr = container_of( - attr, struct target_core_configfs_attribute, attr); - - if (!tc_attr->show) - return -EINVAL; - - return tc_attr->show(dev, page); -} - -static ssize_t target_core_dev_store(struct config_item *item, - struct configfs_attribute *attr, - const char *page, size_t count) -{ - struct config_group *dev_cg = to_config_group(item); - struct se_device *dev = - container_of(dev_cg, struct se_device, dev_group); - struct target_core_configfs_attribute *tc_attr = container_of( - attr, struct target_core_configfs_attribute, attr); - - if (!tc_attr->store) - return -EINVAL; - - return tc_attr->store(dev, page, count); -} - static struct configfs_item_operations target_core_dev_item_ops = { .release = target_core_dev_release, - .show_attribute = target_core_dev_show, - .store_attribute = target_core_dev_store, }; TB_CIT_SETUP(dev, &target_core_dev_item_ops, NULL, target_core_dev_attrs); @@ -1747,38 +2128,25 @@ TB_CIT_SETUP(dev, &target_core_dev_item_ops, NULL, target_core_dev_attrs); /* Start functions for struct config_item_type target_core_alua_lu_gp_cit */ -CONFIGFS_EATTR_STRUCT(target_core_alua_lu_gp, t10_alua_lu_gp); -#define SE_DEV_ALUA_LU_ATTR(_name, _mode) \ -static struct target_core_alua_lu_gp_attribute \ - target_core_alua_lu_gp_##_name = \ - __CONFIGFS_EATTR(_name, _mode, \ - target_core_alua_lu_gp_show_attr_##_name, \ - target_core_alua_lu_gp_store_attr_##_name); - -#define SE_DEV_ALUA_LU_ATTR_RO(_name) \ -static struct target_core_alua_lu_gp_attribute \ - target_core_alua_lu_gp_##_name = \ - __CONFIGFS_EATTR_RO(_name, \ - target_core_alua_lu_gp_show_attr_##_name); +static inline struct t10_alua_lu_gp *to_lu_gp(struct config_item *item) +{ + return container_of(to_config_group(item), struct t10_alua_lu_gp, + lu_gp_group); +} -/* - * lu_gp_id - */ -static ssize_t target_core_alua_lu_gp_show_attr_lu_gp_id( - struct t10_alua_lu_gp *lu_gp, - char *page) +static ssize_t target_lu_gp_lu_gp_id_show(struct config_item *item, char *page) { + struct t10_alua_lu_gp *lu_gp = to_lu_gp(item); + if (!lu_gp->lu_gp_valid_id) return 0; - return sprintf(page, "%hu\n", lu_gp->lu_gp_id); } -static ssize_t target_core_alua_lu_gp_store_attr_lu_gp_id( - struct t10_alua_lu_gp *lu_gp, - const char *page, - size_t count) +static ssize_t target_lu_gp_lu_gp_id_store(struct config_item *item, + const char *page, size_t count) { + struct t10_alua_lu_gp *lu_gp = to_lu_gp(item); struct config_group *alua_lu_gp_cg = &lu_gp->lu_gp_group; unsigned long lu_gp_id; int ret; @@ -1807,15 +2175,9 @@ static ssize_t target_core_alua_lu_gp_store_attr_lu_gp_id( return count; } -SE_DEV_ALUA_LU_ATTR(lu_gp_id, S_IRUGO | S_IWUSR); - -/* - * members - */ -static ssize_t target_core_alua_lu_gp_show_attr_members( - struct t10_alua_lu_gp *lu_gp, - char *page) +static ssize_t target_lu_gp_members_show(struct config_item *item, char *page) { + struct t10_alua_lu_gp *lu_gp = to_lu_gp(item); struct se_device *dev; struct se_hba *hba; struct t10_alua_lu_gp_member *lu_gp_mem; @@ -1847,13 +2209,12 @@ static ssize_t target_core_alua_lu_gp_show_attr_members( return len; } -SE_DEV_ALUA_LU_ATTR_RO(members); - -CONFIGFS_EATTR_OPS(target_core_alua_lu_gp, t10_alua_lu_gp, lu_gp_group); +CONFIGFS_ATTR(target_lu_gp_, lu_gp_id); +CONFIGFS_ATTR_RO(target_lu_gp_, members); static struct configfs_attribute *target_core_alua_lu_gp_attrs[] = { - &target_core_alua_lu_gp_lu_gp_id.attr, - &target_core_alua_lu_gp_members.attr, + &target_lu_gp_attr_lu_gp_id, + &target_lu_gp_attr_members, NULL, }; @@ -1867,8 +2228,6 @@ static void target_core_alua_lu_gp_release(struct config_item *item) static struct configfs_item_operations target_core_alua_lu_gp_ops = { .release = target_core_alua_lu_gp_release, - .show_attribute = target_core_alua_lu_gp_attr_show, - .store_attribute = target_core_alua_lu_gp_attr_store, }; static struct config_item_type target_core_alua_lu_gp_cit = { @@ -1939,36 +2298,23 @@ static struct config_item_type target_core_alua_lu_gps_cit = { /* Start functions for struct config_item_type target_core_alua_tg_pt_gp_cit */ -CONFIGFS_EATTR_STRUCT(target_core_alua_tg_pt_gp, t10_alua_tg_pt_gp); -#define SE_DEV_ALUA_TG_PT_ATTR(_name, _mode) \ -static struct target_core_alua_tg_pt_gp_attribute \ - target_core_alua_tg_pt_gp_##_name = \ - __CONFIGFS_EATTR(_name, _mode, \ - target_core_alua_tg_pt_gp_show_attr_##_name, \ - target_core_alua_tg_pt_gp_store_attr_##_name); - -#define SE_DEV_ALUA_TG_PT_ATTR_RO(_name) \ -static struct target_core_alua_tg_pt_gp_attribute \ - target_core_alua_tg_pt_gp_##_name = \ - __CONFIGFS_EATTR_RO(_name, \ - target_core_alua_tg_pt_gp_show_attr_##_name); +static inline struct t10_alua_tg_pt_gp *to_tg_pt_gp(struct config_item *item) +{ + return container_of(to_config_group(item), struct t10_alua_tg_pt_gp, + tg_pt_gp_group); +} -/* - * alua_access_state - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_access_state( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_alua_access_state_show(struct config_item *item, + char *page) { return sprintf(page, "%d\n", - atomic_read(&tg_pt_gp->tg_pt_gp_alua_access_state)); + atomic_read(&to_tg_pt_gp(item)->tg_pt_gp_alua_access_state)); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_access_state( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_alua_access_state_store(struct config_item *item, + const char *page, size_t count) { + struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); struct se_device *dev = tg_pt_gp->tg_pt_gp_dev; unsigned long tmp; int new_state, ret; @@ -2010,24 +2356,18 @@ static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_access_state( return (!ret) ? count : -EINVAL; } -SE_DEV_ALUA_TG_PT_ATTR(alua_access_state, S_IRUGO | S_IWUSR); - -/* - * alua_access_status - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_access_status( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_alua_access_status_show(struct config_item *item, + char *page) { + struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); return sprintf(page, "%s\n", core_alua_dump_status(tg_pt_gp->tg_pt_gp_alua_access_status)); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_access_status( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_alua_access_status_store( + struct config_item *item, const char *page, size_t count) { + struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); unsigned long tmp; int new_status, ret; @@ -2058,43 +2398,31 @@ static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_access_status( return count; } -SE_DEV_ALUA_TG_PT_ATTR(alua_access_status, S_IRUGO | S_IWUSR); - -/* - * alua_access_type - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_access_type( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_alua_access_type_show(struct config_item *item, + char *page) { - return core_alua_show_access_type(tg_pt_gp, page); + return core_alua_show_access_type(to_tg_pt_gp(item), page); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_access_type( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_alua_access_type_store(struct config_item *item, + const char *page, size_t count) { - return core_alua_store_access_type(tg_pt_gp, page, count); + return core_alua_store_access_type(to_tg_pt_gp(item), page, count); } -SE_DEV_ALUA_TG_PT_ATTR(alua_access_type, S_IRUGO | S_IWUSR); - -/* - * alua_supported_states - */ - -#define SE_DEV_ALUA_SUPPORT_STATE_SHOW(_name, _var, _bit) \ -static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_support_##_name( \ - struct t10_alua_tg_pt_gp *t, char *p) \ +#define ALUA_SUPPORTED_STATE_ATTR(_name, _bit) \ +static ssize_t target_tg_pt_gp_alua_support_##_name##_show( \ + struct config_item *item, char *p) \ { \ - return sprintf(p, "%d\n", !!(t->_var & _bit)); \ -} - -#define SE_DEV_ALUA_SUPPORT_STATE_STORE(_name, _var, _bit) \ -static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_support_##_name(\ - struct t10_alua_tg_pt_gp *t, const char *p, size_t c) \ + struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item); \ + return sprintf(p, "%d\n", \ + !!(t->tg_pt_gp_alua_supported_states & _bit)); \ +} \ + \ +static ssize_t target_tg_pt_gp_alua_support_##_name##_store( \ + struct config_item *item, const char *p, size_t c) \ { \ + struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item); \ unsigned long tmp; \ int ret; \ \ @@ -2115,70 +2443,32 @@ static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_support_##_name(\ return -EINVAL; \ } \ if (tmp) \ - t->_var |= _bit; \ + t->tg_pt_gp_alua_supported_states |= _bit; \ else \ - t->_var &= ~_bit; \ + t->tg_pt_gp_alua_supported_states &= ~_bit; \ \ return c; \ } -SE_DEV_ALUA_SUPPORT_STATE_SHOW(transitioning, - tg_pt_gp_alua_supported_states, ALUA_T_SUP); -SE_DEV_ALUA_SUPPORT_STATE_STORE(transitioning, - tg_pt_gp_alua_supported_states, ALUA_T_SUP); -SE_DEV_ALUA_TG_PT_ATTR(alua_support_transitioning, S_IRUGO | S_IWUSR); - -SE_DEV_ALUA_SUPPORT_STATE_SHOW(offline, - tg_pt_gp_alua_supported_states, ALUA_O_SUP); -SE_DEV_ALUA_SUPPORT_STATE_STORE(offline, - tg_pt_gp_alua_supported_states, ALUA_O_SUP); -SE_DEV_ALUA_TG_PT_ATTR(alua_support_offline, S_IRUGO | S_IWUSR); - -SE_DEV_ALUA_SUPPORT_STATE_SHOW(lba_dependent, - tg_pt_gp_alua_supported_states, ALUA_LBD_SUP); -SE_DEV_ALUA_SUPPORT_STATE_STORE(lba_dependent, - tg_pt_gp_alua_supported_states, ALUA_LBD_SUP); -SE_DEV_ALUA_TG_PT_ATTR(alua_support_lba_dependent, S_IRUGO); - -SE_DEV_ALUA_SUPPORT_STATE_SHOW(unavailable, - tg_pt_gp_alua_supported_states, ALUA_U_SUP); -SE_DEV_ALUA_SUPPORT_STATE_STORE(unavailable, - tg_pt_gp_alua_supported_states, ALUA_U_SUP); -SE_DEV_ALUA_TG_PT_ATTR(alua_support_unavailable, S_IRUGO | S_IWUSR); - -SE_DEV_ALUA_SUPPORT_STATE_SHOW(standby, - tg_pt_gp_alua_supported_states, ALUA_S_SUP); -SE_DEV_ALUA_SUPPORT_STATE_STORE(standby, - tg_pt_gp_alua_supported_states, ALUA_S_SUP); -SE_DEV_ALUA_TG_PT_ATTR(alua_support_standby, S_IRUGO | S_IWUSR); - -SE_DEV_ALUA_SUPPORT_STATE_SHOW(active_optimized, - tg_pt_gp_alua_supported_states, ALUA_AO_SUP); -SE_DEV_ALUA_SUPPORT_STATE_STORE(active_optimized, - tg_pt_gp_alua_supported_states, ALUA_AO_SUP); -SE_DEV_ALUA_TG_PT_ATTR(alua_support_active_optimized, S_IRUGO | S_IWUSR); - -SE_DEV_ALUA_SUPPORT_STATE_SHOW(active_nonoptimized, - tg_pt_gp_alua_supported_states, ALUA_AN_SUP); -SE_DEV_ALUA_SUPPORT_STATE_STORE(active_nonoptimized, - tg_pt_gp_alua_supported_states, ALUA_AN_SUP); -SE_DEV_ALUA_TG_PT_ATTR(alua_support_active_nonoptimized, S_IRUGO | S_IWUSR); +ALUA_SUPPORTED_STATE_ATTR(transitioning, ALUA_T_SUP); +ALUA_SUPPORTED_STATE_ATTR(offline, ALUA_O_SUP); +ALUA_SUPPORTED_STATE_ATTR(lba_dependent, ALUA_LBD_SUP); +ALUA_SUPPORTED_STATE_ATTR(unavailable, ALUA_U_SUP); +ALUA_SUPPORTED_STATE_ATTR(standby, ALUA_S_SUP); +ALUA_SUPPORTED_STATE_ATTR(active_optimized, ALUA_AO_SUP); +ALUA_SUPPORTED_STATE_ATTR(active_nonoptimized, ALUA_AN_SUP); -/* - * alua_write_metadata - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_write_metadata( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_alua_write_metadata_show( + struct config_item *item, char *page) { - return sprintf(page, "%d\n", tg_pt_gp->tg_pt_gp_write_metadata); + return sprintf(page, "%d\n", + to_tg_pt_gp(item)->tg_pt_gp_write_metadata); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_write_metadata( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_alua_write_metadata_store( + struct config_item *item, const char *page, size_t count) { + struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); unsigned long tmp; int ret; @@ -2198,110 +2488,71 @@ static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_write_metadata( return count; } -SE_DEV_ALUA_TG_PT_ATTR(alua_write_metadata, S_IRUGO | S_IWUSR); - - - -/* - * nonop_delay_msecs - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_nonop_delay_msecs( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_nonop_delay_msecs_show(struct config_item *item, + char *page) { - return core_alua_show_nonop_delay_msecs(tg_pt_gp, page); - + return core_alua_show_nonop_delay_msecs(to_tg_pt_gp(item), page); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_nonop_delay_msecs( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_nonop_delay_msecs_store(struct config_item *item, + const char *page, size_t count) { - return core_alua_store_nonop_delay_msecs(tg_pt_gp, page, count); + return core_alua_store_nonop_delay_msecs(to_tg_pt_gp(item), page, + count); } -SE_DEV_ALUA_TG_PT_ATTR(nonop_delay_msecs, S_IRUGO | S_IWUSR); - -/* - * trans_delay_msecs - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_trans_delay_msecs( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_trans_delay_msecs_show(struct config_item *item, + char *page) { - return core_alua_show_trans_delay_msecs(tg_pt_gp, page); + return core_alua_show_trans_delay_msecs(to_tg_pt_gp(item), page); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_trans_delay_msecs( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_trans_delay_msecs_store(struct config_item *item, + const char *page, size_t count) { - return core_alua_store_trans_delay_msecs(tg_pt_gp, page, count); + return core_alua_store_trans_delay_msecs(to_tg_pt_gp(item), page, + count); } -SE_DEV_ALUA_TG_PT_ATTR(trans_delay_msecs, S_IRUGO | S_IWUSR); - -/* - * implicit_trans_secs - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_implicit_trans_secs( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_implicit_trans_secs_show( + struct config_item *item, char *page) { - return core_alua_show_implicit_trans_secs(tg_pt_gp, page); + return core_alua_show_implicit_trans_secs(to_tg_pt_gp(item), page); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_implicit_trans_secs( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_implicit_trans_secs_store( + struct config_item *item, const char *page, size_t count) { - return core_alua_store_implicit_trans_secs(tg_pt_gp, page, count); + return core_alua_store_implicit_trans_secs(to_tg_pt_gp(item), page, + count); } -SE_DEV_ALUA_TG_PT_ATTR(implicit_trans_secs, S_IRUGO | S_IWUSR); - -/* - * preferred - */ - -static ssize_t target_core_alua_tg_pt_gp_show_attr_preferred( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_preferred_show(struct config_item *item, + char *page) { - return core_alua_show_preferred_bit(tg_pt_gp, page); + return core_alua_show_preferred_bit(to_tg_pt_gp(item), page); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_preferred( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_preferred_store(struct config_item *item, + const char *page, size_t count) { - return core_alua_store_preferred_bit(tg_pt_gp, page, count); + return core_alua_store_preferred_bit(to_tg_pt_gp(item), page, count); } -SE_DEV_ALUA_TG_PT_ATTR(preferred, S_IRUGO | S_IWUSR); - -/* - * tg_pt_gp_id - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_tg_pt_gp_id( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_tg_pt_gp_id_show(struct config_item *item, + char *page) { + struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); + if (!tg_pt_gp->tg_pt_gp_valid_id) return 0; - return sprintf(page, "%hu\n", tg_pt_gp->tg_pt_gp_id); } -static ssize_t target_core_alua_tg_pt_gp_store_attr_tg_pt_gp_id( - struct t10_alua_tg_pt_gp *tg_pt_gp, - const char *page, - size_t count) +static ssize_t target_tg_pt_gp_tg_pt_gp_id_store(struct config_item *item, + const char *page, size_t count) { + struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); struct config_group *alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group; unsigned long tg_pt_gp_id; int ret; @@ -2330,30 +2581,20 @@ static ssize_t target_core_alua_tg_pt_gp_store_attr_tg_pt_gp_id( return count; } -SE_DEV_ALUA_TG_PT_ATTR(tg_pt_gp_id, S_IRUGO | S_IWUSR); - -/* - * members - */ -static ssize_t target_core_alua_tg_pt_gp_show_attr_members( - struct t10_alua_tg_pt_gp *tg_pt_gp, - char *page) +static ssize_t target_tg_pt_gp_members_show(struct config_item *item, + char *page) { - struct se_port *port; - struct se_portal_group *tpg; + struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); struct se_lun *lun; - struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem; ssize_t len = 0, cur_len; unsigned char buf[TG_PT_GROUP_NAME_BUF]; memset(buf, 0, TG_PT_GROUP_NAME_BUF); spin_lock(&tg_pt_gp->tg_pt_gp_lock); - list_for_each_entry(tg_pt_gp_mem, &tg_pt_gp->tg_pt_gp_mem_list, - tg_pt_gp_mem_list) { - port = tg_pt_gp_mem->tg_pt; - tpg = port->sep_tpg; - lun = port->sep_lun; + list_for_each_entry(lun, &tg_pt_gp->tg_pt_gp_lun_list, + lun_tg_pt_gp_link) { + struct se_portal_group *tpg = lun->lun_tpg; cur_len = snprintf(buf, TG_PT_GROUP_NAME_BUF, "%s/%s/tpgt_%hu" "/%s\n", tpg->se_tpg_tfo->get_fabric_name(), @@ -2375,29 +2616,42 @@ static ssize_t target_core_alua_tg_pt_gp_show_attr_members( return len; } -SE_DEV_ALUA_TG_PT_ATTR_RO(members); - -CONFIGFS_EATTR_OPS(target_core_alua_tg_pt_gp, t10_alua_tg_pt_gp, - tg_pt_gp_group); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_state); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_status); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_type); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_transitioning); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_offline); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_lba_dependent); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_unavailable); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_standby); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_optimized); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_nonoptimized); +CONFIGFS_ATTR(target_tg_pt_gp_, alua_write_metadata); +CONFIGFS_ATTR(target_tg_pt_gp_, nonop_delay_msecs); +CONFIGFS_ATTR(target_tg_pt_gp_, trans_delay_msecs); +CONFIGFS_ATTR(target_tg_pt_gp_, implicit_trans_secs); +CONFIGFS_ATTR(target_tg_pt_gp_, preferred); +CONFIGFS_ATTR(target_tg_pt_gp_, tg_pt_gp_id); +CONFIGFS_ATTR_RO(target_tg_pt_gp_, members); static struct configfs_attribute *target_core_alua_tg_pt_gp_attrs[] = { - &target_core_alua_tg_pt_gp_alua_access_state.attr, - &target_core_alua_tg_pt_gp_alua_access_status.attr, - &target_core_alua_tg_pt_gp_alua_access_type.attr, - &target_core_alua_tg_pt_gp_alua_support_transitioning.attr, - &target_core_alua_tg_pt_gp_alua_support_offline.attr, - &target_core_alua_tg_pt_gp_alua_support_lba_dependent.attr, - &target_core_alua_tg_pt_gp_alua_support_unavailable.attr, - &target_core_alua_tg_pt_gp_alua_support_standby.attr, - &target_core_alua_tg_pt_gp_alua_support_active_nonoptimized.attr, - &target_core_alua_tg_pt_gp_alua_support_active_optimized.attr, - &target_core_alua_tg_pt_gp_alua_write_metadata.attr, - &target_core_alua_tg_pt_gp_nonop_delay_msecs.attr, - &target_core_alua_tg_pt_gp_trans_delay_msecs.attr, - &target_core_alua_tg_pt_gp_implicit_trans_secs.attr, - &target_core_alua_tg_pt_gp_preferred.attr, - &target_core_alua_tg_pt_gp_tg_pt_gp_id.attr, - &target_core_alua_tg_pt_gp_members.attr, + &target_tg_pt_gp_attr_alua_access_state, + &target_tg_pt_gp_attr_alua_access_status, + &target_tg_pt_gp_attr_alua_access_type, + &target_tg_pt_gp_attr_alua_support_transitioning, + &target_tg_pt_gp_attr_alua_support_offline, + &target_tg_pt_gp_attr_alua_support_lba_dependent, + &target_tg_pt_gp_attr_alua_support_unavailable, + &target_tg_pt_gp_attr_alua_support_standby, + &target_tg_pt_gp_attr_alua_support_active_nonoptimized, + &target_tg_pt_gp_attr_alua_support_active_optimized, + &target_tg_pt_gp_attr_alua_write_metadata, + &target_tg_pt_gp_attr_nonop_delay_msecs, + &target_tg_pt_gp_attr_trans_delay_msecs, + &target_tg_pt_gp_attr_implicit_trans_secs, + &target_tg_pt_gp_attr_preferred, + &target_tg_pt_gp_attr_tg_pt_gp_id, + &target_tg_pt_gp_attr_members, NULL, }; @@ -2411,8 +2665,6 @@ static void target_core_alua_tg_pt_gp_release(struct config_item *item) static struct configfs_item_operations target_core_alua_tg_pt_gp_ops = { .release = target_core_alua_tg_pt_gp_release, - .show_attribute = target_core_alua_tg_pt_gp_attr_show, - .store_attribute = target_core_alua_tg_pt_gp_attr_store, }; static struct config_item_type target_core_alua_tg_pt_gp_cit = { @@ -2526,9 +2778,9 @@ static struct config_group *target_core_make_subdev( const char *name) { struct t10_alua_tg_pt_gp *tg_pt_gp; - struct se_subsystem_api *t; struct config_item *hba_ci = &group->cg_item; struct se_hba *hba = item_to_hba(hba_ci); + struct target_backend *tb = hba->backend; struct se_device *dev; struct config_group *dev_cg = NULL, *tg_pt_gp_cg = NULL; struct config_group *dev_stat_grp = NULL; @@ -2537,10 +2789,6 @@ static struct config_group *target_core_make_subdev( ret = mutex_lock_interruptible(&hba->hba_access_mutex); if (ret) return ERR_PTR(ret); - /* - * Locate the struct se_subsystem_api from parent's struct se_hba. - */ - t = hba->transport; dev = target_alloc_device(hba, name); if (!dev) @@ -2553,17 +2801,17 @@ static struct config_group *target_core_make_subdev( if (!dev_cg->default_groups) goto out_free_device; - config_group_init_type_name(dev_cg, name, &t->tb_cits.tb_dev_cit); + config_group_init_type_name(dev_cg, name, &tb->tb_dev_cit); config_group_init_type_name(&dev->dev_attrib.da_group, "attrib", - &t->tb_cits.tb_dev_attrib_cit); + &tb->tb_dev_attrib_cit); config_group_init_type_name(&dev->dev_pr_group, "pr", - &t->tb_cits.tb_dev_pr_cit); + &tb->tb_dev_pr_cit); config_group_init_type_name(&dev->t10_wwn.t10_wwn_group, "wwn", - &t->tb_cits.tb_dev_wwn_cit); + &tb->tb_dev_wwn_cit); config_group_init_type_name(&dev->t10_alua.alua_tg_pt_gps_group, - "alua", &t->tb_cits.tb_dev_alua_tg_pt_gps_cit); + "alua", &tb->tb_dev_alua_tg_pt_gps_cit); config_group_init_type_name(&dev->dev_stat_grps.stat_group, - "statistics", &t->tb_cits.tb_dev_stat_cit); + "statistics", &tb->tb_dev_stat_cit); dev_cg->default_groups[0] = &dev->dev_attrib.da_group; dev_cg->default_groups[1] = &dev->dev_pr_group; @@ -2674,34 +2922,24 @@ static struct configfs_group_operations target_core_hba_group_ops = { .drop_item = target_core_drop_subdev, }; -CONFIGFS_EATTR_STRUCT(target_core_hba, se_hba); -#define SE_HBA_ATTR(_name, _mode) \ -static struct target_core_hba_attribute \ - target_core_hba_##_name = \ - __CONFIGFS_EATTR(_name, _mode, \ - target_core_hba_show_attr_##_name, \ - target_core_hba_store_attr_##_name); -#define SE_HBA_ATTR_RO(_name) \ -static struct target_core_hba_attribute \ - target_core_hba_##_name = \ - __CONFIGFS_EATTR_RO(_name, \ - target_core_hba_show_attr_##_name); +static inline struct se_hba *to_hba(struct config_item *item) +{ + return container_of(to_config_group(item), struct se_hba, hba_group); +} -static ssize_t target_core_hba_show_attr_hba_info( - struct se_hba *hba, - char *page) +static ssize_t target_hba_info_show(struct config_item *item, char *page) { + struct se_hba *hba = to_hba(item); + return sprintf(page, "HBA Index: %d plugin: %s version: %s\n", - hba->hba_id, hba->transport->name, - TARGET_CORE_CONFIGFS_VERSION); + hba->hba_id, hba->backend->ops->name, + TARGET_CORE_VERSION); } -SE_HBA_ATTR_RO(hba_info); - -static ssize_t target_core_hba_show_attr_hba_mode(struct se_hba *hba, - char *page) +static ssize_t target_hba_mode_show(struct config_item *item, char *page) { + struct se_hba *hba = to_hba(item); int hba_mode = 0; if (hba->hba_flags & HBA_FLAGS_PSCSI_MODE) @@ -2710,14 +2948,14 @@ static ssize_t target_core_hba_show_attr_hba_mode(struct se_hba *hba, return sprintf(page, "%d\n", hba_mode); } -static ssize_t target_core_hba_store_attr_hba_mode(struct se_hba *hba, - const char *page, size_t count) +static ssize_t target_hba_mode_store(struct config_item *item, + const char *page, size_t count) { - struct se_subsystem_api *transport = hba->transport; + struct se_hba *hba = to_hba(item); unsigned long mode_flag; int ret; - if (transport->pmode_enable_hba == NULL) + if (hba->backend->ops->pmode_enable_hba == NULL) return -EINVAL; ret = kstrtoul(page, 0, &mode_flag); @@ -2731,7 +2969,7 @@ static ssize_t target_core_hba_store_attr_hba_mode(struct se_hba *hba, return -EINVAL; } - ret = transport->pmode_enable_hba(hba, mode_flag); + ret = hba->backend->ops->pmode_enable_hba(hba, mode_flag); if (ret < 0) return -EINVAL; if (ret > 0) @@ -2742,9 +2980,8 @@ static ssize_t target_core_hba_store_attr_hba_mode(struct se_hba *hba, return count; } -SE_HBA_ATTR(hba_mode, S_IRUGO | S_IWUSR); - -CONFIGFS_EATTR_OPS(target_core_hba, se_hba, hba_group); +CONFIGFS_ATTR_RO(target_, hba_info); +CONFIGFS_ATTR(target_, hba_mode); static void target_core_hba_release(struct config_item *item) { @@ -2754,15 +2991,13 @@ static void target_core_hba_release(struct config_item *item) } static struct configfs_attribute *target_core_hba_attrs[] = { - &target_core_hba_hba_info.attr, - &target_core_hba_hba_mode.attr, + &target_attr_hba_info, + &target_attr_hba_mode, NULL, }; static struct configfs_item_operations target_core_hba_item_ops = { .release = target_core_hba_release, - .show_attribute = target_core_hba_attr_show, - .store_attribute = target_core_hba_attr_store, }; static struct config_item_type target_core_hba_cit = { @@ -2857,16 +3092,15 @@ static struct config_item_type target_core_cit = { /* Stop functions for struct config_item_type target_core_hba_cit */ -void target_core_setup_sub_cits(struct se_subsystem_api *sa) +void target_setup_backend_cits(struct target_backend *tb) { - target_core_setup_dev_cit(sa); - target_core_setup_dev_attrib_cit(sa); - target_core_setup_dev_pr_cit(sa); - target_core_setup_dev_wwn_cit(sa); - target_core_setup_dev_alua_tg_pt_gps_cit(sa); - target_core_setup_dev_stat_cit(sa); + target_core_setup_dev_cit(tb); + target_core_setup_dev_attrib_cit(tb); + target_core_setup_dev_pr_cit(tb); + target_core_setup_dev_wwn_cit(tb); + target_core_setup_dev_alua_tg_pt_gps_cit(tb); + target_core_setup_dev_stat_cit(tb); } -EXPORT_SYMBOL(target_core_setup_sub_cits); static int __init target_core_init_configfs(void) { @@ -2968,7 +3202,7 @@ static int __init target_core_init_configfs(void) goto out_global; } pr_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric" - " Infrastructure: "TARGET_CORE_CONFIGFS_VERSION" on %s/%s" + " Infrastructure: "TARGET_CORE_VERSION" on %s/%s" " on "UTS_RELEASE"\n", utsname()->sysname, utsname()->machine); /* * Register built-in RAMDISK subsystem logic for virtual LUN 0 |