drivers/target/target_core_configfs.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*******************************************************************************
   3  * Filename:  target_core_configfs.c
   4  *
   5  * This file contains ConfigFS logic for the Generic Target Engine project.
   6  *
   7  * (c) Copyright 2008-2013 Datera, Inc.
   8  *
   9  * Nicholas A. Bellinger <[email protected]>
  10  *
  11  * based on configfs Copyright (C) 2005 Oracle.  All rights reserved.
  12  *
  13  ****************************************************************************/
  14
  15 #include <linux/kstrtox.h>
  16 #include <linux/module.h>
  17 #include <linux/moduleparam.h>
  18 #include <generated/utsrelease.h>
  19 #include <linux/utsname.h>
  20 #include <linux/init.h>
  21 #include <linux/fs.h>
  22 #include <linux/namei.h>
  23 #include <linux/slab.h>
  24 #include <linux/types.h>
  25 #include <linux/delay.h>
  26 #include <linux/unistd.h>
  27 #include <linux/string.h>
  28 #include <linux/parser.h>
  29 #include <linux/syscalls.h>
  30 #include <linux/configfs.h>
  31 #include <linux/spinlock.h>
  32
  33 #include <target/target_core_base.h>
  34 #include <target/target_core_backend.h>
  35 #include <target/target_core_fabric.h>
  36
  37 #include "target_core_internal.h"
  38 #include "target_core_alua.h"
  39 #include "target_core_pr.h"
  40 #include "target_core_rd.h"
  41 #include "target_core_xcopy.h"
  42
  43 #define TB_CIT_SETUP(_name, _item_ops, _group_ops, _attrs)              \
  44 static void target_core_setup_##_name##_cit(struct target_backend *tb)  \
  45 {                                                                       \
  46         struct config_item_type *cit = &tb->tb_##_name##_cit;           \
  47                                                                         \
  48         cit->ct_item_ops = _item_ops;                                   \
  49         cit->ct_group_ops = _group_ops;                                 \
  50         cit->ct_attrs = _attrs;                                         \
  51         cit->ct_owner = tb->ops->owner;                                 \
  52         pr_debug("Setup generic %s\n", __stringify(_name));             \
  53 }
  54
  55 #define TB_CIT_SETUP_DRV(_name, _item_ops, _group_ops)                  \
  56 static void target_core_setup_##_name##_cit(struct target_backend *tb)  \
  57 {                                                                       \
  58         struct config_item_type *cit = &tb->tb_##_name##_cit;           \
  59                                                                         \
  60         cit->ct_item_ops = _item_ops;                                   \
  61         cit->ct_group_ops = _group_ops;                                 \
  62         cit->ct_attrs = tb->ops->tb_##_name##_attrs;                    \
  63         cit->ct_owner = tb->ops->owner;                                 \
  64         pr_debug("Setup generic %s\n", __stringify(_name));             \
  65 }
  66
  67 extern struct t10_alua_lu_gp *default_lu_gp;
  68
  69 static LIST_HEAD(g_tf_list);
  70 static DEFINE_MUTEX(g_tf_lock);
  71
  72 static struct config_group target_core_hbagroup;
  73 static struct config_group alua_group;
  74 static struct config_group alua_lu_gps_group;
  75
  76 static unsigned int target_devices;
  77 static DEFINE_MUTEX(target_devices_lock);
  78
  79 static inline struct se_hba *
  80 item_to_hba(struct config_item *item)
  81 {
  82         return container_of(to_config_group(item), struct se_hba, hba_group);
  83 }
  84
  85 /*
  86  * Attributes for /sys/kernel/config/target/
  87  */
  88 static ssize_t target_core_item_version_show(struct config_item *item,
  89                 char *page)
  90 {
  91         return sprintf(page, "Target Engine Core ConfigFS Infrastructure %s"
  92                 " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_VERSION,
  93                 utsname()->sysname, utsname()->machine);
  94 }
  95
  96 CONFIGFS_ATTR_RO(target_core_item_, version);
  97
  98 char db_root[DB_ROOT_LEN] = DB_ROOT_DEFAULT;
  99 static char db_root_stage[DB_ROOT_LEN];
 100
 101 static ssize_t target_core_item_dbroot_show(struct config_item *item,
 102                                             char *page)
 103 {
 104         return sprintf(page, "%s\n", db_root);
 105 }
 106
 107 static ssize_t target_core_item_dbroot_store(struct config_item *item,
 108                                         const char *page, size_t count)
 109 {
 110         ssize_t read_bytes;
 111         struct file *fp;
 112         ssize_t r = -EINVAL;
 113
 114         mutex_lock(&target_devices_lock);
 115         if (target_devices) {
 116                 pr_err("db_root: cannot be changed because it's in use\n");
 117                 goto unlock;
 118         }
 119
 120         if (count > (DB_ROOT_LEN - 1)) {
 121                 pr_err("db_root: count %d exceeds DB_ROOT_LEN-1: %u\n",
 122                        (int)count, DB_ROOT_LEN - 1);
 123                 goto unlock;
 124         }
 125
 126         read_bytes = snprintf(db_root_stage, DB_ROOT_LEN, "%s", page);
 127         if (!read_bytes)
 128                 goto unlock;
 129
 130         if (db_root_stage[read_bytes - 1] == '\n')
 131                 db_root_stage[read_bytes - 1] = '\0';
 132
 133         /* validate new db root before accepting it */
 134         fp = filp_open(db_root_stage, O_RDONLY, 0);
 135         if (IS_ERR(fp)) {
 136                 pr_err("db_root: cannot open: %s\n", db_root_stage);
 137                 goto unlock;
 138         }
 139         if (!S_ISDIR(file_inode(fp)->i_mode)) {
 140                 filp_close(fp, NULL);
 141                 pr_err("db_root: not a directory: %s\n", db_root_stage);
 142                 goto unlock;
 143         }
 144         filp_close(fp, NULL);
 145
 146         strncpy(db_root, db_root_stage, read_bytes);
 147         pr_debug("Target_Core_ConfigFS: db_root set to %s\n", db_root);
 148
 149         r = read_bytes;
 150
 151 unlock:
 152         mutex_unlock(&target_devices_lock);
 153         return r;
 154 }
 155
 156 CONFIGFS_ATTR(target_core_item_, dbroot);
 157
 158 static struct target_fabric_configfs *target_core_get_fabric(
 159         const char *name)
 160 {
 161         struct target_fabric_configfs *tf;
 162
 163         if (!name)
 164                 return NULL;
 165
 166         mutex_lock(&g_tf_lock);
 167         list_for_each_entry(tf, &g_tf_list, tf_list) {
 168                 const char *cmp_name = tf->tf_ops->fabric_alias;
 169                 if (!cmp_name)
 170                         cmp_name = tf->tf_ops->fabric_name;
 171                 if (!strcmp(cmp_name, name)) {
 172                         atomic_inc(&tf->tf_access_cnt);
 173                         mutex_unlock(&g_tf_lock);
 174                         return tf;
 175                 }
 176         }
 177         mutex_unlock(&g_tf_lock);
 178
 179         return NULL;
 180 }
 181
 182 /*
 183  * Called from struct target_core_group_ops->make_group()
 184  */
 185 static struct config_group *target_core_register_fabric(
 186         struct config_group *group,
 187         const char *name)
 188 {
 189         struct target_fabric_configfs *tf;
 190         int ret;
 191
 192         pr_debug("Target_Core_ConfigFS: REGISTER -> group: %p name:"
 193                         " %s\n", group, name);
 194
 195         tf = target_core_get_fabric(name);
 196         if (!tf) {
 197                 pr_debug("target_core_register_fabric() trying autoload for %s\n",
 198                          name);
 199
 200                 /*
 201                  * Below are some hardcoded request_module() calls to automatically
 202                  * local fabric modules when the following is called:
 203                  *
 204                  * mkdir -p /sys/kernel/config/target/$MODULE_NAME
 205                  *
 206                  * Note that this does not limit which TCM fabric module can be
 207                  * registered, but simply provids auto loading logic for modules with
 208                  * mkdir(2) system calls with known TCM fabric modules.
 209                  */
 210
 211                 if (!strncmp(name, "iscsi", 5)) {
 212                         /*
 213                          * Automatically load the LIO Target fabric module when the
 214                          * following is called:
 215                          *
 216                          * mkdir -p $CONFIGFS/target/iscsi
 217                          */
 218                         ret = request_module("iscsi_target_mod");
 219                         if (ret < 0) {
 220                                 pr_debug("request_module() failed for"
 221                                          " iscsi_target_mod.ko: %d\n", ret);
 222                                 return ERR_PTR(-EINVAL);
 223                         }
 224                 } else if (!strncmp(name, "loopback", 8)) {
 225                         /*
 226                          * Automatically load the tcm_loop fabric module when the
 227                          * following is called:
 228                          *
 229                          * mkdir -p $CONFIGFS/target/loopback
 230                          */
 231                         ret = request_module("tcm_loop");
 232                         if (ret < 0) {
 233                                 pr_debug("request_module() failed for"
 234                                          " tcm_loop.ko: %d\n", ret);
 235                                 return ERR_PTR(-EINVAL);
 236                         }
 237                 }
 238
 239                 tf = target_core_get_fabric(name);
 240         }
 241
 242         if (!tf) {
 243                 pr_debug("target_core_get_fabric() failed for %s\n",
 244                          name);
 245                 return ERR_PTR(-EINVAL);
 246         }
 247         pr_debug("Target_Core_ConfigFS: REGISTER -> Located fabric:"
 248                         " %s\n", tf->tf_ops->fabric_name);
 249         /*
 250          * On a successful target_core_get_fabric() look, the returned
 251          * struct target_fabric_configfs *tf will contain a usage reference.
 252          */
 253         pr_debug("Target_Core_ConfigFS: REGISTER tfc_wwn_cit -> %p\n",
 254                         &tf->tf_wwn_cit);
 255
 256         config_group_init_type_name(&tf->tf_group, name, &tf->tf_wwn_cit);
 257
 258         config_group_init_type_name(&tf->tf_disc_group, "discovery_auth",
 259                         &tf->tf_discovery_cit);
 260         configfs_add_default_group(&tf->tf_disc_group, &tf->tf_group);
 261
 262         pr_debug("Target_Core_ConfigFS: REGISTER -> Allocated Fabric: %s\n",
 263                  config_item_name(&tf->tf_group.cg_item));
 264         return &tf->tf_group;
 265 }
 266
 267 /*
 268  * Called from struct target_core_group_ops->drop_item()
 269  */
 270 static void target_core_deregister_fabric(
 271         struct config_group *group,
 272         struct config_item *item)
 273 {
 274         struct target_fabric_configfs *tf = container_of(
 275                 to_config_group(item), struct target_fabric_configfs, tf_group);
 276
 277         pr_debug("Target_Core_ConfigFS: DEREGISTER -> Looking up %s in"
 278                 " tf list\n", config_item_name(item));
 279
 280         pr_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric:"
 281                         " %s\n", tf->tf_ops->fabric_name);
 282         atomic_dec(&tf->tf_access_cnt);
 283
 284         pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci"
 285                         " %s\n", config_item_name(item));
 286
 287         configfs_remove_default_groups(&tf->tf_group);
 288         config_item_put(item);
 289 }
 290
 291 static struct configfs_group_operations target_core_fabric_group_ops = {
 292         .make_group     = &target_core_register_fabric,
 293         .drop_item      = &target_core_deregister_fabric,
 294 };
 295
 296 /*
 297  * All item attributes appearing in /sys/kernel/target/ appear here.
 298  */
 299 static struct configfs_attribute *target_core_fabric_item_attrs[] = {
 300         &target_core_item_attr_version,
 301         &target_core_item_attr_dbroot,
 302         NULL,
 303 };
 304
 305 /*
 306  * Provides Fabrics Groups and Item Attributes for /sys/kernel/config/target/
 307  */
 308 static const struct config_item_type target_core_fabrics_item = {
 309         .ct_group_ops   = &target_core_fabric_group_ops,
 310         .ct_attrs       = target_core_fabric_item_attrs,
 311         .ct_owner       = THIS_MODULE,
 312 };
 313
 314 static struct configfs_subsystem target_core_fabrics = {
 315         .su_group = {
 316                 .cg_item = {
 317                         .ci_namebuf = "target",
 318                         .ci_type = &target_core_fabrics_item,
 319                 },
 320         },
 321 };
 322
 323 int target_depend_item(struct config_item *item)
 324 {
 325         return configfs_depend_item(&target_core_fabrics, item);
 326 }
 327 EXPORT_SYMBOL(target_depend_item);
 328
 329 void target_undepend_item(struct config_item *item)
 330 {
 331         return configfs_undepend_item(item);
 332 }
 333 EXPORT_SYMBOL(target_undepend_item);
 334
 335 /*##############################################################################
 336 // Start functions called by external Target Fabrics Modules
 337 //############################################################################*/
 338 static int target_disable_feature(struct se_portal_group *se_tpg)
 339 {
 340         return 0;
 341 }
 342
 343 static u32 target_default_get_inst_index(struct se_portal_group *se_tpg)
 344 {
 345         return 1;
 346 }
 347
 348 static u32 target_default_sess_get_index(struct se_session *se_sess)
 349 {
 350         return 0;
 351 }
 352
 353 static void target_set_default_node_attributes(struct se_node_acl *se_acl)
 354 {
 355 }
 356
 357 static int target_default_get_cmd_state(struct se_cmd *se_cmd)
 358 {
 359         return 0;
 360 }
 361
 362 static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
 363 {
 364         if (tfo->fabric_alias) {
 365                 if (strlen(tfo->fabric_alias) >= TARGET_FABRIC_NAME_SIZE) {
 366                         pr_err("Passed alias: %s exceeds "
 367                                 "TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_alias);
 368                         return -EINVAL;
 369                 }
 370         }
 371         if (!tfo->fabric_name) {
 372                 pr_err("Missing tfo->fabric_name\n");
 373                 return -EINVAL;
 374         }
 375         if (strlen(tfo->fabric_name) >= TARGET_FABRIC_NAME_SIZE) {
 376                 pr_err("Passed name: %s exceeds "
 377                         "TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_name);
 378                 return -EINVAL;
 379         }
 380         if (!tfo->tpg_get_wwn) {
 381                 pr_err("Missing tfo->tpg_get_wwn()\n");
 382                 return -EINVAL;
 383         }
 384         if (!tfo->tpg_get_tag) {
 385                 pr_err("Missing tfo->tpg_get_tag()\n");
 386                 return -EINVAL;
 387         }
 388         if (!tfo->release_cmd) {
 389                 pr_err("Missing tfo->release_cmd()\n");
 390                 return -EINVAL;
 391         }
 392         if (!tfo->write_pending) {
 393                 pr_err("Missing tfo->write_pending()\n");
 394                 return -EINVAL;
 395         }
 396         if (!tfo->queue_data_in) {
 397                 pr_err("Missing tfo->queue_data_in()\n");
 398                 return -EINVAL;
 399         }
 400         if (!tfo->queue_status) {
 401                 pr_err("Missing tfo->queue_status()\n");
 402                 return -EINVAL;
 403         }
 404         if (!tfo->queue_tm_rsp) {
 405                 pr_err("Missing tfo->queue_tm_rsp()\n");
 406                 return -EINVAL;
 407         }
 408         if (!tfo->aborted_task) {
 409                 pr_err("Missing tfo->aborted_task()\n");
 410                 return -EINVAL;
 411         }
 412         if (!tfo->check_stop_free) {
 413                 pr_err("Missing tfo->check_stop_free()\n");
 414                 return -EINVAL;
 415         }
 416         /*
 417          * We at least require tfo->fabric_make_wwn(), tfo->fabric_drop_wwn()
 418          * tfo->fabric_make_tpg() and tfo->fabric_drop_tpg() in
 419          * target_core_fabric_configfs.c WWN+TPG group context code.
 420          */
 421         if (!tfo->fabric_make_wwn) {
 422                 pr_err("Missing tfo->fabric_make_wwn()\n");
 423                 return -EINVAL;
 424         }
 425         if (!tfo->fabric_drop_wwn) {
 426                 pr_err("Missing tfo->fabric_drop_wwn()\n");
 427                 return -EINVAL;
 428         }
 429         if (!tfo->fabric_make_tpg) {
 430                 pr_err("Missing tfo->fabric_make_tpg()\n");
 431                 return -EINVAL;
 432         }
 433         if (!tfo->fabric_drop_tpg) {
 434                 pr_err("Missing tfo->fabric_drop_tpg()\n");
 435                 return -EINVAL;
 436         }
 437
 438         return 0;
 439 }
 440
 441 static void target_set_default_ops(struct target_core_fabric_ops *tfo)
 442 {
 443         if (!tfo->tpg_check_demo_mode)
 444                 tfo->tpg_check_demo_mode = target_disable_feature;
 445
 446         if (!tfo->tpg_check_demo_mode_cache)
 447                 tfo->tpg_check_demo_mode_cache = target_disable_feature;
 448
 449         if (!tfo->tpg_check_demo_mode_write_protect)
 450                 tfo->tpg_check_demo_mode_write_protect = target_disable_feature;
 451
 452         if (!tfo->tpg_check_prod_mode_write_protect)
 453                 tfo->tpg_check_prod_mode_write_protect = target_disable_feature;
 454
 455         if (!tfo->tpg_get_inst_index)
 456                 tfo->tpg_get_inst_index = target_default_get_inst_index;
 457
 458         if (!tfo->sess_get_index)
 459                 tfo->sess_get_index = target_default_sess_get_index;
 460
 461         if (!tfo->set_default_node_attributes)
 462                 tfo->set_default_node_attributes = target_set_default_node_attributes;
 463
 464         if (!tfo->get_cmd_state)
 465                 tfo->get_cmd_state = target_default_get_cmd_state;
 466 }
 467
 468 int target_register_template(const struct target_core_fabric_ops *fo)
 469 {
 470         struct target_core_fabric_ops *tfo;
 471         struct target_fabric_configfs *tf;
 472         int ret;
 473
 474         ret = target_fabric_tf_ops_check(fo);
 475         if (ret)
 476                 return ret;
 477
 478         tf = kzalloc(sizeof(struct target_fabric_configfs), GFP_KERNEL);
 479         if (!tf) {
 480                 pr_err("%s: could not allocate memory!\n", __func__);
 481                 return -ENOMEM;
 482         }
 483         tfo = kzalloc(sizeof(struct target_core_fabric_ops), GFP_KERNEL);
 484         if (!tfo) {
 485                 kfree(tf);
 486                 pr_err("%s: could not allocate memory!\n", __func__);
 487                 return -ENOMEM;
 488         }
 489         memcpy(tfo, fo, sizeof(*tfo));
 490         target_set_default_ops(tfo);
 491
 492         INIT_LIST_HEAD(&tf->tf_list);
 493         atomic_set(&tf->tf_access_cnt, 0);
 494         tf->tf_ops = tfo;
 495         target_fabric_setup_cits(tf);
 496
 497         mutex_lock(&g_tf_lock);
 498         list_add_tail(&tf->tf_list, &g_tf_list);
 499         mutex_unlock(&g_tf_lock);
 500
 501         return 0;
 502 }
 503 EXPORT_SYMBOL(target_register_template);
 504
 505 void target_unregister_template(const struct target_core_fabric_ops *fo)
 506 {
 507         struct target_fabric_configfs *t;
 508
 509         mutex_lock(&g_tf_lock);
 510         list_for_each_entry(t, &g_tf_list, tf_list) {
 511                 if (!strcmp(t->tf_ops->fabric_name, fo->fabric_name)) {
 512                         BUG_ON(atomic_read(&t->tf_access_cnt));
 513                         list_del(&t->tf_list);
 514                         mutex_unlock(&g_tf_lock);
 515                         /*
 516                          * Wait for any outstanding fabric se_deve_entry->rcu_head
 517                          * callbacks to complete post kfree_rcu(), before allowing
 518                          * fabric driver unload of TFO->module to proceed.
 519                          */
 520                         rcu_barrier();
 521                         kfree(t->tf_tpg_base_cit.ct_attrs);
 522                         kfree(t->tf_ops);
 523                         kfree(t);
 524                         return;
 525                 }
 526         }
 527         mutex_unlock(&g_tf_lock);
 528 }
 529 EXPORT_SYMBOL(target_unregister_template);
 530
 531 /*##############################################################################
 532 // Stop functions called by external Target Fabrics Modules
 533 //############################################################################*/
 534
 535 static inline struct se_dev_attrib *to_attrib(struct config_item *item)
 536 {
 537         return container_of(to_config_group(item), struct se_dev_attrib,
 538                         da_group);
 539 }
 540
 541 /* Start functions for struct config_item_type tb_dev_attrib_cit */
 542 #define DEF_CONFIGFS_ATTRIB_SHOW(_name)                                 \
 543 static ssize_t _name##_show(struct config_item *item, char *page)       \
 544 {                                                                       \
 545         return snprintf(page, PAGE_SIZE, "%u\n", to_attrib(item)->_name); \
 546 }
 547
 548 DEF_CONFIGFS_ATTRIB_SHOW(emulate_model_alias);
 549 DEF_CONFIGFS_ATTRIB_SHOW(emulate_dpo);
 550 DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_write);
 551 DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_read);
 552 DEF_CONFIGFS_ATTRIB_SHOW(emulate_write_cache);
 553 DEF_CONFIGFS_ATTRIB_SHOW(emulate_ua_intlck_ctrl);
 554 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tas);
 555 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpu);
 556 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpws);
 557 DEF_CONFIGFS_ATTRIB_SHOW(emulate_caw);
 558 DEF_CONFIGFS_ATTRIB_SHOW(emulate_3pc);
 559 DEF_CONFIGFS_ATTRIB_SHOW(emulate_pr);
 560 DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_type);
 561 DEF_CONFIGFS_ATTRIB_SHOW(hw_pi_prot_type);
 562 DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_verify);
 563 DEF_CONFIGFS_ATTRIB_SHOW(enforce_pr_isids);
 564 DEF_CONFIGFS_ATTRIB_SHOW(is_nonrot);
 565 DEF_CONFIGFS_ATTRIB_SHOW(emulate_rest_reord);
 566 DEF_CONFIGFS_ATTRIB_SHOW(force_pr_aptpl);
 567 DEF_CONFIGFS_ATTRIB_SHOW(hw_block_size);
 568 DEF_CONFIGFS_ATTRIB_SHOW(block_size);
 569 DEF_CONFIGFS_ATTRIB_SHOW(hw_max_sectors);
 570 DEF_CONFIGFS_ATTRIB_SHOW(optimal_sectors);
 571 DEF_CONFIGFS_ATTRIB_SHOW(hw_queue_depth);
 572 DEF_CONFIGFS_ATTRIB_SHOW(queue_depth);
 573 DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_lba_count);
 574 DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_block_desc_count);
 575 DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity);
 576 DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity_alignment);
 577 DEF_CONFIGFS_ATTRIB_SHOW(unmap_zeroes_data);
 578 DEF_CONFIGFS_ATTRIB_SHOW(max_write_same_len);
 579 DEF_CONFIGFS_ATTRIB_SHOW(emulate_rsoc);
 580 DEF_CONFIGFS_ATTRIB_SHOW(submit_type);
 581
 582 #define DEF_CONFIGFS_ATTRIB_STORE_U32(_name)                            \
 583 static ssize_t _name##_store(struct config_item *item, const char *page,\
 584                 size_t count)                                           \
 585 {                                                                       \
 586         struct se_dev_attrib *da = to_attrib(item);                     \
 587         u32 val;                                                        \
 588         int ret;                                                        \
 589                                                                         \
 590         ret = kstrtou32(page, 0, &val);                                 \
 591         if (ret < 0)                                                    \
 592                 return ret;                                             \
 593         da->_name = val;                                                \
 594         return count;                                                   \
 595 }
 596
 597 DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_lba_count);
 598 DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_block_desc_count);
 599 DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity);
 600 DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity_alignment);
 601 DEF_CONFIGFS_ATTRIB_STORE_U32(max_write_same_len);
 602
 603 #define DEF_CONFIGFS_ATTRIB_STORE_BOOL(_name)                           \
 604 static ssize_t _name##_store(struct config_item *item, const char *page,        \
 605                 size_t count)                                           \
 606 {                                                                       \
 607         struct se_dev_attrib *da = to_attrib(item);                     \
 608         bool flag;                                                      \
 609         int ret;                                                        \
 610                                                                         \
 611         ret = kstrtobool(page, &flag);                                  \
 612         if (ret < 0)                                                    \
 613                 return ret;                                             \
 614         da->_name = flag;                                               \
 615         return count;                                                   \
 616 }
 617
 618 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_fua_write);
 619 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_caw);
 620 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_3pc);
 621 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_pr);
 622 DEF_CONFIGFS_ATTRIB_STORE_BOOL(enforce_pr_isids);
 623 DEF_CONFIGFS_ATTRIB_STORE_BOOL(is_nonrot);
 624
 625 #define DEF_CONFIGFS_ATTRIB_STORE_STUB(_name)                           \
 626 static ssize_t _name##_store(struct config_item *item, const char *page,\
 627                 size_t count)                                           \
 628 {                                                                       \
 629         printk_once(KERN_WARNING                                        \
 630                 "ignoring deprecated %s attribute\n",                   \
 631                 __stringify(_name));                                    \
 632         return count;                                                   \
 633 }
 634
 635 DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_dpo);
 636 DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_fua_read);
 637
 638 static void dev_set_t10_wwn_model_alias(struct se_device *dev)
 639 {
 640         const char *configname;
 641
 642         configname = config_item_name(&dev->dev_group.cg_item);
 643         if (strlen(configname) >= INQUIRY_MODEL_LEN) {
 644                 pr_warn("dev[%p]: Backstore name '%s' is too long for "
 645                         "INQUIRY_MODEL, truncating to 15 characters\n", dev,
 646                         configname);
 647         }
 648         /*
 649          * XXX We can't use sizeof(dev->t10_wwn.model) (INQUIRY_MODEL_LEN + 1)
 650          * here without potentially breaking existing setups, so continue to
 651          * truncate one byte shorter than what can be carried in INQUIRY.
 652          */
 653         strscpy(dev->t10_wwn.model, configname, INQUIRY_MODEL_LEN);
 654 }
 655
 656 static ssize_t emulate_model_alias_store(struct config_item *item,
 657                 const char *page, size_t count)
 658 {
 659         struct se_dev_attrib *da = to_attrib(item);
 660         struct se_device *dev = da->da_dev;
 661         bool flag;
 662         int ret;
 663
 664         if (dev->export_count) {
 665                 pr_err("dev[%p]: Unable to change model alias"
 666                         " while export_count is %d\n",
 667                         dev, dev->export_count);
 668                 return -EINVAL;
 669         }
 670
 671         ret = kstrtobool(page, &flag);
 672         if (ret < 0)
 673                 return ret;
 674
 675         BUILD_BUG_ON(sizeof(dev->t10_wwn.model) != INQUIRY_MODEL_LEN + 1);
 676         if (flag) {
 677                 dev_set_t10_wwn_model_alias(dev);
 678         } else {
 679                 strscpy(dev->t10_wwn.model, dev->transport->inquiry_prod,
 680                         sizeof(dev->t10_wwn.model));
 681         }
 682         da->emulate_model_alias = flag;
 683         return count;
 684 }
 685
 686 static ssize_t emulate_write_cache_store(struct config_item *item,
 687                 const char *page, size_t count)
 688 {
 689         struct se_dev_attrib *da = to_attrib(item);
 690         bool flag;
 691         int ret;
 692
 693         ret = kstrtobool(page, &flag);
 694         if (ret < 0)
 695                 return ret;
 696
 697         if (flag && da->da_dev->transport->get_write_cache) {
 698                 pr_err("emulate_write_cache not supported for this device\n");
 699                 return -EINVAL;
 700         }
 701
 702         da->emulate_write_cache = flag;
 703         pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
 704                         da->da_dev, flag);
 705         return count;
 706 }
 707
 708 static ssize_t emulate_ua_intlck_ctrl_store(struct config_item *item,
 709                 const char *page, size_t count)
 710 {
 711         struct se_dev_attrib *da = to_attrib(item);
 712         u32 val;
 713         int ret;
 714
 715         ret = kstrtou32(page, 0, &val);
 716         if (ret < 0)
 717                 return ret;
 718
 719         if (val != TARGET_UA_INTLCK_CTRL_CLEAR
 720          && val != TARGET_UA_INTLCK_CTRL_NO_CLEAR
 721          && val != TARGET_UA_INTLCK_CTRL_ESTABLISH_UA) {
 722                 pr_err("Illegal value %d\n", val);
 723                 return -EINVAL;
 724         }
 725
 726         if (da->da_dev->export_count) {
 727                 pr_err("dev[%p]: Unable to change SE Device"
 728                         " UA_INTRLCK_CTRL while export_count is %d\n",
 729                         da->da_dev, da->da_dev->export_count);
 730                 return -EINVAL;
 731         }
 732         da->emulate_ua_intlck_ctrl = val;
 733         pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
 734                 da->da_dev, val);
 735         return count;
 736 }
 737
 738 static ssize_t emulate_tas_store(struct config_item *item,
 739                 const char *page, size_t count)
 740 {
 741         struct se_dev_attrib *da = to_attrib(item);
 742         bool flag;
 743         int ret;
 744
 745         ret = kstrtobool(page, &flag);
 746         if (ret < 0)
 747                 return ret;
 748
 749         if (da->da_dev->export_count) {
 750                 pr_err("dev[%p]: Unable to change SE Device TAS while"
 751                         " export_count is %d\n",
 752                         da->da_dev, da->da_dev->export_count);
 753                 return -EINVAL;
 754         }
 755         da->emulate_tas = flag;
 756         pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
 757                 da->da_dev, flag ? "Enabled" : "Disabled");
 758
 759         return count;
 760 }
 761
 762 static ssize_t emulate_tpu_store(struct config_item *item,
 763                 const char *page, size_t count)
 764 {
 765         struct se_dev_attrib *da = to_attrib(item);
 766         struct se_device *dev = da->da_dev;
 767         bool flag;
 768         int ret;
 769
 770         ret = kstrtobool(page, &flag);
 771         if (ret < 0)
 772                 return ret;
 773
 774         /*
 775          * We expect this value to be non-zero when generic Block Layer
 776          * Discard supported is detected iblock_create_virtdevice().
 777          */
 778         if (flag && !da->max_unmap_block_desc_count) {
 779                 if (!dev->transport->configure_unmap ||
 780                     !dev->transport->configure_unmap(dev)) {
 781                         pr_err("Generic Block Discard not supported\n");
 782                         return -ENOSYS;
 783                 }
 784         }
 785
 786         da->emulate_tpu = flag;
 787         pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
 788                 da->da_dev, flag);
 789         return count;
 790 }
 791
 792 static ssize_t emulate_tpws_store(struct config_item *item,
 793                 const char *page, size_t count)
 794 {
 795         struct se_dev_attrib *da = to_attrib(item);
 796         struct se_device *dev = da->da_dev;
 797         bool flag;
 798         int ret;
 799
 800         ret = kstrtobool(page, &flag);
 801         if (ret < 0)
 802                 return ret;
 803
 804         /*
 805          * We expect this value to be non-zero when generic Block Layer
 806          * Discard supported is detected iblock_create_virtdevice().
 807          */
 808         if (flag && !da->max_unmap_block_desc_count) {
 809                 if (!dev->transport->configure_unmap ||
 810                     !dev->transport->configure_unmap(dev)) {
 811                         pr_err("Generic Block Discard not supported\n");
 812                         return -ENOSYS;
 813                 }
 814         }
 815
 816         da->emulate_tpws = flag;
 817         pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
 818                                 da->da_dev, flag);
 819         return count;
 820 }
 821
 822 static ssize_t pi_prot_type_store(struct config_item *item,
 823                 const char *page, size_t count)
 824 {
 825         struct se_dev_attrib *da = to_attrib(item);
 826         int old_prot = da->pi_prot_type, ret;
 827         struct se_device *dev = da->da_dev;
 828         u32 flag;
 829
 830         ret = kstrtou32(page, 0, &flag);
 831         if (ret < 0)
 832                 return ret;
 833
 834         if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {
 835                 pr_err("Illegal value %d for pi_prot_type\n", flag);
 836                 return -EINVAL;
 837         }
 838         if (flag == 2) {
 839                 pr_err("DIF TYPE2 protection currently not supported\n");
 840                 return -ENOSYS;
 841         }
 842         if (da->hw_pi_prot_type) {
 843                 pr_warn("DIF protection enabled on underlying hardware,"
 844                         " ignoring\n");
 845                 return count;
 846         }
 847         if (!dev->transport->init_prot || !dev->transport->free_prot) {
 848                 /* 0 is only allowed value for non-supporting backends */
 849                 if (flag == 0)
 850                         return count;
 851
 852                 pr_err("DIF protection not supported by backend: %s\n",
 853                        dev->transport->name);
 854                 return -ENOSYS;
 855         }
 856         if (!target_dev_configured(dev)) {
 857                 pr_err("DIF protection requires device to be configured\n");
 858                 return -ENODEV;
 859         }
 860         if (dev->export_count) {
 861                 pr_err("dev[%p]: Unable to change SE Device PROT type while"
 862                        " export_count is %d\n", dev, dev->export_count);
 863                 return -EINVAL;
 864         }
 865
 866         da->pi_prot_type = flag;
 867
 868         if (flag && !old_prot) {
 869                 ret = dev->transport->init_prot(dev);
 870                 if (ret) {
 871                         da->pi_prot_type = old_prot;
 872                         da->pi_prot_verify = (bool) da->pi_prot_type;
 873                         return ret;
 874                 }
 875
 876         } else if (!flag && old_prot) {
 877                 dev->transport->free_prot(dev);
 878         }
 879
 880         da->pi_prot_verify = (bool) da->pi_prot_type;
 881         pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);
 882         return count;
 883 }
 884
 885 /* always zero, but attr needs to remain RW to avoid userspace breakage */
 886 static ssize_t pi_prot_format_show(struct config_item *item, char *page)
 887 {
 888         return snprintf(page, PAGE_SIZE, "0\n");
 889 }
 890
 891 static ssize_t pi_prot_format_store(struct config_item *item,
 892                 const char *page, size_t count)
 893 {
 894         struct se_dev_attrib *da = to_attrib(item);
 895         struct se_device *dev = da->da_dev;
 896         bool flag;
 897         int ret;
 898
 899         ret = kstrtobool(page, &flag);
 900         if (ret < 0)
 901                 return ret;
 902
 903         if (!flag)
 904                 return count;
 905
 906         if (!dev->transport->format_prot) {
 907                 pr_err("DIF protection format not supported by backend %s\n",
 908                        dev->transport->name);
 909                 return -ENOSYS;
 910         }
 911         if (!target_dev_configured(dev)) {
 912                 pr_err("DIF protection format requires device to be configured\n");
 913                 return -ENODEV;
 914         }
 915         if (dev->export_count) {
 916                 pr_err("dev[%p]: Unable to format SE Device PROT type while"
 917                        " export_count is %d\n", dev, dev->export_count);
 918                 return -EINVAL;
 919         }
 920
 921         ret = dev->transport->format_prot(dev);
 922         if (ret)
 923                 return ret;
 924
 925         pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);
 926         return count;
 927 }
 928
 929 static ssize_t pi_prot_verify_store(struct config_item *item,
 930                 const char *page, size_t count)
 931 {
 932         struct se_dev_attrib *da = to_attrib(item);
 933         bool flag;
 934         int ret;
 935
 936         ret = kstrtobool(page, &flag);
 937         if (ret < 0)
 938                 return ret;
 939
 940         if (!flag) {
 941                 da->pi_prot_verify = flag;
 942                 return count;
 943         }
 944         if (da->hw_pi_prot_type) {
 945                 pr_warn("DIF protection enabled on underlying hardware,"
 946                         " ignoring\n");
 947                 return count;
 948         }
 949         if (!da->pi_prot_type) {
 950                 pr_warn("DIF protection not supported by backend, ignoring\n");
 951                 return count;
 952         }
 953         da->pi_prot_verify = flag;
 954
 955         return count;
 956 }
 957
 958 static ssize_t force_pr_aptpl_store(struct config_item *item,
 959                 const char *page, size_t count)
 960 {
 961         struct se_dev_attrib *da = to_attrib(item);
 962         bool flag;
 963         int ret;
 964
 965         ret = kstrtobool(page, &flag);
 966         if (ret < 0)
 967                 return ret;
 968         if (da->da_dev->export_count) {
 969                 pr_err("dev[%p]: Unable to set force_pr_aptpl while"
 970                        " export_count is %d\n",
 971                        da->da_dev, da->da_dev->export_count);
 972                 return -EINVAL;
 973         }
 974
 975         da->force_pr_aptpl = flag;
 976         pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", da->da_dev, flag);
 977         return count;
 978 }
 979
 980 static ssize_t emulate_rest_reord_store(struct config_item *item,
 981                 const char *page, size_t count)
 982 {
 983         struct se_dev_attrib *da = to_attrib(item);
 984         bool flag;
 985         int ret;
 986
 987         ret = kstrtobool(page, &flag);
 988         if (ret < 0)
 989                 return ret;
 990
 991         if (flag != 0) {
 992                 printk(KERN_ERR "dev[%p]: SE Device emulation of restricted"
 993                         " reordering not implemented\n", da->da_dev);
 994                 return -ENOSYS;
 995         }
 996         da->emulate_rest_reord = flag;
 997         pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n",
 998                 da->da_dev, flag);
 999         return count;
1000 }
1001
1002 static ssize_t unmap_zeroes_data_store(struct config_item *item,
1003                 const char *page, size_t count)
1004 {
1005         struct se_dev_attrib *da = to_attrib(item);
1006         struct se_device *dev = da->da_dev;
1007         bool flag;
1008         int ret;
1009
1010         ret = kstrtobool(page, &flag);
1011         if (ret < 0)
1012                 return ret;
1013
1014         if (da->da_dev->export_count) {
1015                 pr_err("dev[%p]: Unable to change SE Device"
1016                        " unmap_zeroes_data while export_count is %d\n",
1017                        da->da_dev, da->da_dev->export_count);
1018                 return -EINVAL;
1019         }
1020         /*
1021          * We expect this value to be non-zero when generic Block Layer
1022          * Discard supported is detected iblock_configure_device().
1023          */
1024         if (flag && !da->max_unmap_block_desc_count) {
1025                 if (!dev->transport->configure_unmap ||
1026                     !dev->transport->configure_unmap(dev)) {
1027                         pr_err("dev[%p]: Thin Provisioning LBPRZ will not be set because max_unmap_block_desc_count is zero\n",
1028                                da->da_dev);
1029                         return -ENOSYS;
1030                 }
1031         }
1032         da->unmap_zeroes_data = flag;
1033         pr_debug("dev[%p]: SE Device Thin Provisioning LBPRZ bit: %d\n",
1034                  da->da_dev, flag);
1035         return count;
1036 }
1037
1038 /*
1039  * Note, this can only be called on unexported SE Device Object.
1040  */
1041 static ssize_t queue_depth_store(struct config_item *item,
1042                 const char *page, size_t count)
1043 {
1044         struct se_dev_attrib *da = to_attrib(item);
1045         struct se_device *dev = da->da_dev;
1046         u32 val;
1047         int ret;
1048
1049         ret = kstrtou32(page, 0, &val);
1050         if (ret < 0)
1051                 return ret;
1052
1053         if (dev->export_count) {
1054                 pr_err("dev[%p]: Unable to change SE Device TCQ while"
1055                         " export_count is %d\n",
1056                         dev, dev->export_count);
1057                 return -EINVAL;
1058         }
1059         if (!val) {
1060                 pr_err("dev[%p]: Illegal ZERO value for queue_depth\n", dev);
1061                 return -EINVAL;
1062         }
1063
1064         if (val > dev->dev_attrib.queue_depth) {
1065                 if (val > dev->dev_attrib.hw_queue_depth) {
1066                         pr_err("dev[%p]: Passed queue_depth:"
1067                                 " %u exceeds TCM/SE_Device MAX"
1068                                 " TCQ: %u\n", dev, val,
1069                                 dev->dev_attrib.hw_queue_depth);
1070                         return -EINVAL;
1071                 }
1072         }
1073         da->queue_depth = dev->queue_depth = val;
1074         pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n", dev, val);
1075         return count;
1076 }
1077
1078 static ssize_t optimal_sectors_store(struct config_item *item,
1079                 const char *page, size_t count)
1080 {
1081         struct se_dev_attrib *da = to_attrib(item);
1082         u32 val;
1083         int ret;
1084
1085         ret = kstrtou32(page, 0, &val);
1086         if (ret < 0)
1087                 return ret;
1088
1089         if (da->da_dev->export_count) {
1090                 pr_err("dev[%p]: Unable to change SE Device"
1091                         " optimal_sectors while export_count is %d\n",
1092                         da->da_dev, da->da_dev->export_count);
1093                 return -EINVAL;
1094         }
1095         if (val > da->hw_max_sectors) {
1096                 pr_err("dev[%p]: Passed optimal_sectors %u cannot be"
1097                         " greater than hw_max_sectors: %u\n",
1098                         da->da_dev, val, da->hw_max_sectors);
1099                 return -EINVAL;
1100         }
1101
1102         da->optimal_sectors = val;
1103         pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",
1104                         da->da_dev, val);
1105         return count;
1106 }
1107
1108 static ssize_t block_size_store(struct config_item *item,
1109                 const char *page, size_t count)
1110 {
1111         struct se_dev_attrib *da = to_attrib(item);
1112         u32 val;
1113         int ret;
1114
1115         ret = kstrtou32(page, 0, &val);
1116         if (ret < 0)
1117                 return ret;
1118
1119         if (da->da_dev->export_count) {
1120                 pr_err("dev[%p]: Unable to change SE Device block_size"
1121                         " while export_count is %d\n",
1122                         da->da_dev, da->da_dev->export_count);
1123                 return -EINVAL;
1124         }
1125
1126         if (val != 512 && val != 1024 && val != 2048 && val != 4096) {
1127                 pr_err("dev[%p]: Illegal value for block_device: %u"
1128                         " for SE device, must be 512, 1024, 2048 or 4096\n",
1129                         da->da_dev, val);
1130                 return -EINVAL;
1131         }
1132
1133         da->block_size = val;
1134
1135         pr_debug("dev[%p]: SE Device block_size changed to %u\n",
1136                         da->da_dev, val);
1137         return count;
1138 }
1139
1140 static ssize_t alua_support_show(struct config_item *item, char *page)
1141 {
1142         struct se_dev_attrib *da = to_attrib(item);
1143         u8 flags = da->da_dev->transport_flags;
1144
1145         return snprintf(page, PAGE_SIZE, "%d\n",
1146                         flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA ? 0 : 1);
1147 }
1148
1149 static ssize_t alua_support_store(struct config_item *item,
1150                 const char *page, size_t count)
1151 {
1152         struct se_dev_attrib *da = to_attrib(item);
1153         struct se_device *dev = da->da_dev;
1154         bool flag, oldflag;
1155         int ret;
1156
1157         ret = kstrtobool(page, &flag);
1158         if (ret < 0)
1159                 return ret;
1160
1161         oldflag = !(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA);
1162         if (flag == oldflag)
1163                 return count;
1164
1165         if (!(dev->transport->transport_flags_changeable &
1166               TRANSPORT_FLAG_PASSTHROUGH_ALUA)) {
1167                 pr_err("dev[%p]: Unable to change SE Device alua_support:"
1168                         " alua_support has fixed value\n", dev);
1169                 return -ENOSYS;
1170         }
1171
1172         if (flag)
1173                 dev->transport_flags &= ~TRANSPORT_FLAG_PASSTHROUGH_ALUA;
1174         else
1175                 dev->transport_flags |= TRANSPORT_FLAG_PASSTHROUGH_ALUA;
1176         return count;
1177 }
1178
1179 static ssize_t pgr_support_show(struct config_item *item, char *page)
1180 {
1181         struct se_dev_attrib *da = to_attrib(item);
1182         u8 flags = da->da_dev->transport_flags;
1183
1184         return snprintf(page, PAGE_SIZE, "%d\n",
1185                         flags & TRANSPORT_FLAG_PASSTHROUGH_PGR ? 0 : 1);
1186 }
1187
1188 static ssize_t pgr_support_store(struct config_item *item,
1189                 const char *page, size_t count)
1190 {
1191         struct se_dev_attrib *da = to_attrib(item);
1192         struct se_device *dev = da->da_dev;
1193         bool flag, oldflag;
1194         int ret;
1195
1196         ret = kstrtobool(page, &flag);
1197         if (ret < 0)
1198                 return ret;
1199
1200         oldflag = !(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR);
1201         if (flag == oldflag)
1202                 return count;
1203
1204         if (!(dev->transport->transport_flags_changeable &
1205               TRANSPORT_FLAG_PASSTHROUGH_PGR)) {
1206                 pr_err("dev[%p]: Unable to change SE Device pgr_support:"
1207                         " pgr_support has fixed value\n", dev);
1208                 return -ENOSYS;
1209         }
1210
1211         if (flag)
1212                 dev->transport_flags &= ~TRANSPORT_FLAG_PASSTHROUGH_PGR;
1213         else
1214                 dev->transport_flags |= TRANSPORT_FLAG_PASSTHROUGH_PGR;
1215         return count;
1216 }
1217
1218 static ssize_t emulate_rsoc_store(struct config_item *item,
1219                 const char *page, size_t count)
1220 {
1221         struct se_dev_attrib *da = to_attrib(item);
1222         bool flag;
1223         int ret;
1224
1225         ret = kstrtobool(page, &flag);
1226         if (ret < 0)
1227                 return ret;
1228
1229         da->emulate_rsoc = flag;
1230         pr_debug("dev[%p]: SE Device REPORT_SUPPORTED_OPERATION_CODES_EMULATION flag: %d\n",
1231                         da->da_dev, flag);
1232         return count;
1233 }
1234
1235 static ssize_t submit_type_store(struct config_item *item, const char *page,
1236                                  size_t count)
1237 {
1238         struct se_dev_attrib *da = to_attrib(item);
1239         int ret;
1240         u8 val;
1241
1242         ret = kstrtou8(page, 0, &val);
1243         if (ret < 0)
1244                 return ret;
1245
1246         if (val > TARGET_QUEUE_SUBMIT)
1247                 return -EINVAL;
1248
1249         da->submit_type = val;
1250         return count;
1251 }
1252
1253 CONFIGFS_ATTR(, emulate_model_alias);
1254 CONFIGFS_ATTR(, emulate_dpo);
1255 CONFIGFS_ATTR(, emulate_fua_write);
1256 CONFIGFS_ATTR(, emulate_fua_read);
1257 CONFIGFS_ATTR(, emulate_write_cache);
1258 CONFIGFS_ATTR(, emulate_ua_intlck_ctrl);
1259 CONFIGFS_ATTR(, emulate_tas);
1260 CONFIGFS_ATTR(, emulate_tpu);
1261 CONFIGFS_ATTR(, emulate_tpws);
1262 CONFIGFS_ATTR(, emulate_caw);
1263 CONFIGFS_ATTR(, emulate_3pc);
1264 CONFIGFS_ATTR(, emulate_pr);
1265 CONFIGFS_ATTR(, emulate_rsoc);
1266 CONFIGFS_ATTR(, pi_prot_type);
1267 CONFIGFS_ATTR_RO(, hw_pi_prot_type);
1268 CONFIGFS_ATTR(, pi_prot_format);
1269 CONFIGFS_ATTR(, pi_prot_verify);
1270 CONFIGFS_ATTR(, enforce_pr_isids);
1271 CONFIGFS_ATTR(, is_nonrot);
1272 CONFIGFS_ATTR(, emulate_rest_reord);
1273 CONFIGFS_ATTR(, force_pr_aptpl);
1274 CONFIGFS_ATTR_RO(, hw_block_size);
1275 CONFIGFS_ATTR(, block_size);
1276 CONFIGFS_ATTR_RO(, hw_max_sectors);
1277 CONFIGFS_ATTR(, optimal_sectors);
1278 CONFIGFS_ATTR_RO(, hw_queue_depth);
1279 CONFIGFS_ATTR(, queue_depth);
1280 CONFIGFS_ATTR(, max_unmap_lba_count);
1281 CONFIGFS_ATTR(, max_unmap_block_desc_count);
1282 CONFIGFS_ATTR(, unmap_granularity);
1283 CONFIGFS_ATTR(, unmap_granularity_alignment);
1284 CONFIGFS_ATTR(, unmap_zeroes_data);
1285 CONFIGFS_ATTR(, max_write_same_len);
1286 CONFIGFS_ATTR(, alua_support);
1287 CONFIGFS_ATTR(, pgr_support);
1288 CONFIGFS_ATTR(, submit_type);
1289
1290 /*
1291  * dev_attrib attributes for devices using the target core SBC/SPC
1292  * interpreter.  Any backend using spc_parse_cdb should be using
1293  * these.
1294  */
1295 struct configfs_attribute *sbc_attrib_attrs[] = {
1296         &attr_emulate_model_alias,
1297         &attr_emulate_dpo,
1298         &attr_emulate_fua_write,
1299         &attr_emulate_fua_read,
1300         &attr_emulate_write_cache,
1301         &attr_emulate_ua_intlck_ctrl,
1302         &attr_emulate_tas,
1303         &attr_emulate_tpu,
1304         &attr_emulate_tpws,
1305         &attr_emulate_caw,
1306         &attr_emulate_3pc,
1307         &attr_emulate_pr,
1308         &attr_pi_prot_type,
1309         &attr_hw_pi_prot_type,
1310         &attr_pi_prot_format,
1311         &attr_pi_prot_verify,
1312         &attr_enforce_pr_isids,
1313         &attr_is_nonrot,
1314         &attr_emulate_rest_reord,
1315         &attr_force_pr_aptpl,
1316         &attr_hw_block_size,
1317         &attr_block_size,
1318         &attr_hw_max_sectors,
1319         &attr_optimal_sectors,
1320         &attr_hw_queue_depth,
1321         &attr_queue_depth,
1322         &attr_max_unmap_lba_count,
1323         &attr_max_unmap_block_desc_count,
1324         &attr_unmap_granularity,
1325         &attr_unmap_granularity_alignment,
1326         &attr_unmap_zeroes_data,
1327         &attr_max_write_same_len,
1328         &attr_alua_support,
1329         &attr_pgr_support,
1330         &attr_emulate_rsoc,
1331         &attr_submit_type,
1332         NULL,
1333 };
1334 EXPORT_SYMBOL(sbc_attrib_attrs);
1335
1336 /*
1337  * Minimal dev_attrib attributes for devices passing through CDBs.
1338  * In this case we only provide a few read-only attributes for
1339  * backwards compatibility.
1340  */
1341 struct configfs_attribute *passthrough_attrib_attrs[] = {
1342         &attr_hw_pi_prot_type,
1343         &attr_hw_block_size,
1344         &attr_hw_max_sectors,
1345         &attr_hw_queue_depth,
1346         &attr_emulate_pr,
1347         &attr_alua_support,
1348         &attr_pgr_support,
1349         &attr_submit_type,
1350         NULL,
1351 };
1352 EXPORT_SYMBOL(passthrough_attrib_attrs);
1353
1354 /*
1355  * pr related dev_attrib attributes for devices passing through CDBs,
1356  * but allowing in core pr emulation.
1357  */
1358 struct configfs_attribute *passthrough_pr_attrib_attrs[] = {
1359         &attr_enforce_pr_isids,
1360         &attr_force_pr_aptpl,
1361         NULL,
1362 };
1363 EXPORT_SYMBOL(passthrough_pr_attrib_attrs);
1364
1365 TB_CIT_SETUP_DRV(dev_attrib, NULL, NULL);
1366 TB_CIT_SETUP_DRV(dev_action, NULL, NULL);
1367
1368 /* End functions for struct config_item_type tb_dev_attrib_cit */
1369
1370 /*  Start functions for struct config_item_type tb_dev_wwn_cit */
1371
1372 static struct t10_wwn *to_t10_wwn(struct config_item *item)
1373 {
1374         return container_of(to_config_group(item), struct t10_wwn, t10_wwn_group);
1375 }
1376
1377 static ssize_t target_check_inquiry_data(char *buf)
1378 {
1379         size_t len;
1380         int i;
1381
1382         len = strlen(buf);
1383
1384         /*
1385          * SPC 4.3.1:
1386          * ASCII data fields shall contain only ASCII printable characters
1387          * (i.e., code values 20h to 7Eh) and may be terminated with one or
1388          * more ASCII null (00h) characters.
1389          */
1390         for (i = 0; i < len; i++) {
1391                 if (buf[i] < 0x20 || buf[i] > 0x7E) {
1392                         pr_err("Emulated T10 Inquiry Data contains non-ASCII-printable characters\n");
1393                         return -EINVAL;
1394                 }
1395         }
1396
1397         return len;
1398 }
1399
1400 /*
1401  * STANDARD and VPD page 0x83 T10 Vendor Identification
1402  */
1403 static ssize_t target_wwn_vendor_id_show(struct config_item *item,
1404                 char *page)
1405 {
1406         return sprintf(page, "%s\n", &to_t10_wwn(item)->vendor[0]);
1407 }
1408
1409 static ssize_t target_wwn_vendor_id_store(struct config_item *item,
1410                 const char *page, size_t count)
1411 {
1412         struct t10_wwn *t10_wwn = to_t10_wwn(item);
1413         struct se_device *dev = t10_wwn->t10_dev;
1414         /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
1415         unsigned char buf[INQUIRY_VENDOR_LEN + 2];
1416         char *stripped = NULL;
1417         ssize_t len;
1418         ssize_t ret;
1419
1420         len = strscpy(buf, page, sizeof(buf));
1421         if (len > 0) {
1422                 /* Strip any newline added from userspace. */
1423                 stripped = strstrip(buf);
1424                 len = strlen(stripped);
1425         }
1426         if (len < 0 || len > INQUIRY_VENDOR_LEN) {
1427                 pr_err("Emulated T10 Vendor Identification exceeds"
1428                         " INQUIRY_VENDOR_LEN: " __stringify(INQUIRY_VENDOR_LEN)
1429                         "\n");
1430                 return -EOVERFLOW;
1431         }
1432
1433         ret = target_check_inquiry_data(stripped);
1434
1435         if (ret < 0)
1436                 return ret;
1437
1438         /*
1439          * Check to see if any active exports exist.  If they do exist, fail
1440          * here as changing this information on the fly (underneath the
1441          * initiator side OS dependent multipath code) could cause negative
1442          * effects.
1443          */
1444         if (dev->export_count) {
1445                 pr_err("Unable to set T10 Vendor Identification while"
1446                         " active %d exports exist\n", dev->export_count);
1447                 return -EINVAL;
1448         }
1449
1450         BUILD_BUG_ON(sizeof(dev->t10_wwn.vendor) != INQUIRY_VENDOR_LEN + 1);
1451         strscpy(dev->t10_wwn.vendor, stripped, sizeof(dev->t10_wwn.vendor));
1452
1453         pr_debug("Target_Core_ConfigFS: Set emulated T10 Vendor Identification:"
1454                  " %s\n", dev->t10_wwn.vendor);
1455
1456         return count;
1457 }
1458
1459 static ssize_t target_wwn_product_id_show(struct config_item *item,
1460                 char *page)
1461 {
1462         return sprintf(page, "%s\n", &to_t10_wwn(item)->model[0]);
1463 }
1464
1465 static ssize_t target_wwn_product_id_store(struct config_item *item,
1466                 const char *page, size_t count)
1467 {
1468         struct t10_wwn *t10_wwn = to_t10_wwn(item);
1469         struct se_device *dev = t10_wwn->t10_dev;
1470         /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
1471         unsigned char buf[INQUIRY_MODEL_LEN + 2];
1472         char *stripped = NULL;
1473         ssize_t len;
1474         ssize_t ret;
1475
1476         len = strscpy(buf, page, sizeof(buf));
1477         if (len > 0) {
1478                 /* Strip any newline added from userspace. */
1479                 stripped = strstrip(buf);
1480                 len = strlen(stripped);
1481         }
1482         if (len < 0 || len > INQUIRY_MODEL_LEN) {
1483                 pr_err("Emulated T10 Vendor exceeds INQUIRY_MODEL_LEN: "
1484                          __stringify(INQUIRY_MODEL_LEN)
1485                         "\n");
1486                 return -EOVERFLOW;
1487         }
1488
1489         ret = target_check_inquiry_data(stripped);
1490
1491         if (ret < 0)
1492                 return ret;
1493
1494         /*
1495          * Check to see if any active exports exist.  If they do exist, fail
1496          * here as changing this information on the fly (underneath the
1497          * initiator side OS dependent multipath code) could cause negative
1498          * effects.
1499          */
1500         if (dev->export_count) {
1501                 pr_err("Unable to set T10 Model while active %d exports exist\n",
1502                         dev->export_count);
1503                 return -EINVAL;
1504         }
1505
1506         BUILD_BUG_ON(sizeof(dev->t10_wwn.model) != INQUIRY_MODEL_LEN + 1);
1507         strscpy(dev->t10_wwn.model, stripped, sizeof(dev->t10_wwn.model));
1508
1509         pr_debug("Target_Core_ConfigFS: Set emulated T10 Model Identification: %s\n",
1510                  dev->t10_wwn.model);
1511
1512         return count;
1513 }
1514
1515 static ssize_t target_wwn_revision_show(struct config_item *item,
1516                 char *page)
1517 {
1518         return sprintf(page, "%s\n", &to_t10_wwn(item)->revision[0]);
1519 }
1520
1521 static ssize_t target_wwn_revision_store(struct config_item *item,
1522                 const char *page, size_t count)
1523 {
1524         struct t10_wwn *t10_wwn = to_t10_wwn(item);
1525         struct se_device *dev = t10_wwn->t10_dev;
1526         /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
1527         unsigned char buf[INQUIRY_REVISION_LEN + 2];
1528         char *stripped = NULL;
1529         ssize_t len;
1530         ssize_t ret;
1531
1532         len = strscpy(buf, page, sizeof(buf));
1533         if (len > 0) {
1534                 /* Strip any newline added from userspace. */
1535                 stripped = strstrip(buf);
1536                 len = strlen(stripped);
1537         }
1538         if (len < 0 || len > INQUIRY_REVISION_LEN) {
1539                 pr_err("Emulated T10 Revision exceeds INQUIRY_REVISION_LEN: "
1540                          __stringify(INQUIRY_REVISION_LEN)
1541                         "\n");
1542                 return -EOVERFLOW;
1543         }
1544
1545         ret = target_check_inquiry_data(stripped);
1546
1547         if (ret < 0)
1548                 return ret;
1549
1550         /*
1551          * Check to see if any active exports exist.  If they do exist, fail
1552          * here as changing this information on the fly (underneath the
1553          * initiator side OS dependent multipath code) could cause negative
1554          * effects.
1555          */
1556         if (dev->export_count) {
1557                 pr_err("Unable to set T10 Revision while active %d exports exist\n",
1558                         dev->export_count);
1559                 return -EINVAL;
1560         }
1561
1562         BUILD_BUG_ON(sizeof(dev->t10_wwn.revision) != INQUIRY_REVISION_LEN + 1);
1563         strscpy(dev->t10_wwn.revision, stripped, sizeof(dev->t10_wwn.revision));
1564
1565         pr_debug("Target_Core_ConfigFS: Set emulated T10 Revision: %s\n",
1566                  dev->t10_wwn.revision);
1567
1568         return count;
1569 }
1570
1571 static ssize_t
1572 target_wwn_company_id_show(struct config_item *item,
1573                                 char *page)
1574 {
1575         return snprintf(page, PAGE_SIZE, "%#08x\n",
1576                         to_t10_wwn(item)->company_id);
1577 }
1578
1579 static ssize_t
1580 target_wwn_company_id_store(struct config_item *item,
1581                                  const char *page, size_t count)
1582 {
1583         struct t10_wwn *t10_wwn = to_t10_wwn(item);
1584         struct se_device *dev = t10_wwn->t10_dev;
1585         u32 val;
1586         int ret;
1587
1588         /*
1589          * The IEEE COMPANY_ID field should contain a 24-bit canonical
1590          * form OUI assigned by the IEEE.
1591          */
1592         ret = kstrtou32(page, 0, &val);
1593         if (ret < 0)
1594                 return ret;
1595
1596         if (val >= 0x1000000)
1597                 return -EOVERFLOW;
1598
1599         /*
1600          * Check to see if any active exports exist. If they do exist, fail
1601          * here as changing this information on the fly (underneath the
1602          * initiator side OS dependent multipath code) could cause negative
1603          * effects.
1604          */
1605         if (dev->export_count) {
1606                 pr_err("Unable to set Company ID while %u exports exist\n",
1607                        dev->export_count);
1608                 return -EINVAL;
1609         }
1610
1611         t10_wwn->company_id = val;
1612
1613         pr_debug("Target_Core_ConfigFS: Set IEEE Company ID: %#08x\n",
1614                  t10_wwn->company_id);
1615
1616         return count;
1617 }
1618
1619 /*
1620  * VPD page 0x80 Unit serial
1621  */
1622 static ssize_t target_wwn_vpd_unit_serial_show(struct config_item *item,
1623                 char *page)
1624 {
1625         return sprintf(page, "T10 VPD Unit Serial Number: %s\n",
1626                 &to_t10_wwn(item)->unit_serial[0]);
1627 }
1628
1629 static ssize_t target_wwn_vpd_unit_serial_store(struct config_item *item,
1630                 const char *page, size_t count)
1631 {
1632         struct t10_wwn *t10_wwn = to_t10_wwn(item);
1633         struct se_device *dev = t10_wwn->t10_dev;
1634         unsigned char buf[INQUIRY_VPD_SERIAL_LEN] = { };
1635
1636         /*
1637          * If Linux/SCSI subsystem_api_t plugin got a VPD Unit Serial
1638          * from the struct scsi_device level firmware, do not allow
1639          * VPD Unit Serial to be emulated.
1640          *
1641          * Note this struct scsi_device could also be emulating VPD
1642          * information from its drivers/scsi LLD.  But for now we assume
1643          * it is doing 'the right thing' wrt a world wide unique
1644          * VPD Unit Serial Number that OS dependent multipath can depend on.
1645          */
1646         if (dev->dev_flags & DF_FIRMWARE_VPD_UNIT_SERIAL) {
1647                 pr_err("Underlying SCSI device firmware provided VPD"
1648                         " Unit Serial, ignoring request\n");
1649                 return -EOPNOTSUPP;
1650         }
1651
1652         if (strlen(page) >= INQUIRY_VPD_SERIAL_LEN) {
1653                 pr_err("Emulated VPD Unit Serial exceeds"
1654                 " INQUIRY_VPD_SERIAL_LEN: %d\n", INQUIRY_VPD_SERIAL_LEN);
1655                 return -EOVERFLOW;
1656         }
1657         /*
1658          * Check to see if any active $FABRIC_MOD exports exist.  If they
1659          * do exist, fail here as changing this information on the fly
1660          * (underneath the initiator side OS dependent multipath code)
1661          * could cause negative effects.
1662          */
1663         if (dev->export_count) {
1664                 pr_err("Unable to set VPD Unit Serial while"
1665                         " active %d $FABRIC_MOD exports exist\n",
1666                         dev->export_count);
1667                 return -EINVAL;
1668         }
1669
1670         /*
1671          * This currently assumes ASCII encoding for emulated VPD Unit Serial.
1672          *
1673          * Also, strip any newline added from the userspace
1674          * echo $UUID > $TARGET/$HBA/$STORAGE_OBJECT/wwn/vpd_unit_serial
1675          */
1676         snprintf(buf, INQUIRY_VPD_SERIAL_LEN, "%s", page);
1677         snprintf(dev->t10_wwn.unit_serial, INQUIRY_VPD_SERIAL_LEN,
1678                         "%s", strstrip(buf));
1679         dev->dev_flags |= DF_EMULATED_VPD_UNIT_SERIAL;
1680
1681         pr_debug("Target_Core_ConfigFS: Set emulated VPD Unit Serial:"
1682                         " %s\n", dev->t10_wwn.unit_serial);
1683
1684         return count;
1685 }
1686
1687 /*
1688  * VPD page 0x83 Protocol Identifier
1689  */
1690 static ssize_t target_wwn_vpd_protocol_identifier_show(struct config_item *item,
1691                 char *page)
1692 {
1693         struct t10_wwn *t10_wwn = to_t10_wwn(item);
1694         struct t10_vpd *vpd;
1695         unsigned char buf[VPD_TMP_BUF_SIZE] = { };
1696         ssize_t len = 0;
1697
1698         spin_lock(&t10_wwn->t10_vpd_lock);
1699         list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) {
1700                 if (!vpd->protocol_identifier_set)
1701                         continue;
1702
1703                 transport_dump_vpd_proto_id(vpd, buf, VPD_TMP_BUF_SIZE);
1704
1705                 if (len + strlen(buf) >= PAGE_SIZE)
1706                         break;
1707
1708                 len += sprintf(page+len, "%s", buf);
1709         }
1710         spin_unlock(&t10_wwn->t10_vpd_lock);
1711
1712         return len;
1713 }
1714
1715 /*
1716  * Generic wrapper for dumping VPD identifiers by association.
1717  */
1718 #define DEF_DEV_WWN_ASSOC_SHOW(_name, _assoc)                           \
1719 static ssize_t target_wwn_##_name##_show(struct config_item *item,      \
1720                 char *page)                                             \
1721 {                                                                       \
1722         struct t10_wwn *t10_wwn = to_t10_wwn(item);                     \
1723         struct t10_vpd *vpd;                                            \
1724         unsigned char buf[VPD_TMP_BUF_SIZE];                            \
1725         ssize_t len = 0;                                                \
1726                                                                         \
1727         spin_lock(&t10_wwn->t10_vpd_lock);                              \
1728         list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) {    \
1729                 if (vpd->association != _assoc)                         \
1730                         continue;                                       \
1731                                                                         \
1732                 memset(buf, 0, VPD_TMP_BUF_SIZE);                       \
1733                 transport_dump_vpd_assoc(vpd, buf, VPD_TMP_BUF_SIZE);   \
1734                 if (len + strlen(buf) >= PAGE_SIZE)                     \
1735                         break;                                          \
1736                 len += sprintf(page+len, "%s", buf);                    \
1737                                                                         \
1738                 memset(buf, 0, VPD_TMP_BUF_SIZE);                       \
1739                 transport_dump_vpd_ident_type(vpd, buf, VPD_TMP_BUF_SIZE); \
1740                 if (len + strlen(buf) >= PAGE_SIZE)                     \
1741                         break;                                          \
1742                 len += sprintf(page+len, "%s", buf);                    \
1743                                                                         \
1744                 memset(buf, 0, VPD_TMP_BUF_SIZE);                       \
1745                 transport_dump_vpd_ident(vpd, buf, VPD_TMP_BUF_SIZE); \
1746                 if (len + strlen(buf) >= PAGE_SIZE)                     \
1747                         break;                                          \
1748                 len += sprintf(page+len, "%s", buf);                    \
1749         }                                                               \
1750         spin_unlock(&t10_wwn->t10_vpd_lock);                            \
1751                                                                         \
1752         return len;                                                     \
1753 }
1754
1755 /* VPD page 0x83 Association: Logical Unit */
1756 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_logical_unit, 0x00);
1757 /* VPD page 0x83 Association: Target Port */
1758 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_target_port, 0x10);
1759 /* VPD page 0x83 Association: SCSI Target Device */
1760 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_scsi_target_device, 0x20);
1761
1762 CONFIGFS_ATTR(target_wwn_, vendor_id);
1763 CONFIGFS_ATTR(target_wwn_, product_id);
1764 CONFIGFS_ATTR(target_wwn_, revision);
1765 CONFIGFS_ATTR(target_wwn_, company_id);
1766 CONFIGFS_ATTR(target_wwn_, vpd_unit_serial);
1767 CONFIGFS_ATTR_RO(target_wwn_, vpd_protocol_identifier);
1768 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_logical_unit);
1769 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_target_port);
1770 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_scsi_target_device);
1771
1772 static struct configfs_attribute *target_core_dev_wwn_attrs[] = {
1773         &target_wwn_attr_vendor_id,
1774         &target_wwn_attr_product_id,
1775         &target_wwn_attr_revision,
1776         &target_wwn_attr_company_id,
1777         &target_wwn_attr_vpd_unit_serial,
1778         &target_wwn_attr_vpd_protocol_identifier,
1779         &target_wwn_attr_vpd_assoc_logical_unit,
1780         &target_wwn_attr_vpd_assoc_target_port,
1781         &target_wwn_attr_vpd_assoc_scsi_target_device,
1782         NULL,
1783 };
1784
1785 TB_CIT_SETUP(dev_wwn, NULL, NULL, target_core_dev_wwn_attrs);
1786
1787 /*  End functions for struct config_item_type tb_dev_wwn_cit */
1788
1789 /*  Start functions for struct config_item_type tb_dev_pr_cit */
1790
1791 static struct se_device *pr_to_dev(struct config_item *item)
1792 {
1793         return container_of(to_config_group(item), struct se_device,
1794                         dev_pr_group);
1795 }
1796
1797 static ssize_t target_core_dev_pr_show_spc3_res(struct se_device *dev,
1798                 char *page)
1799 {
1800         struct se_node_acl *se_nacl;
1801         struct t10_pr_registration *pr_reg;
1802         char i_buf[PR_REG_ISID_ID_LEN] = { };
1803
1804         pr_reg = dev->dev_pr_res_holder;
1805         if (!pr_reg)
1806                 return sprintf(page, "No SPC-3 Reservation holder\n");
1807
1808         se_nacl = pr_reg->pr_reg_nacl;
1809         core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
1810
1811         return sprintf(page, "SPC-3 Reservation: %s Initiator: %s%s\n",
1812                 se_nacl->se_tpg->se_tpg_tfo->fabric_name,
1813                 se_nacl->initiatorname, i_buf);
1814 }
1815
1816 static ssize_t target_core_dev_pr_show_spc2_res(struct se_device *dev,
1817                 char *page)
1818 {
1819         struct se_session *sess = dev->reservation_holder;
1820         struct se_node_acl *se_nacl;
1821         ssize_t len;
1822
1823         if (sess) {
1824                 se_nacl = sess->se_node_acl;
1825                 len = sprintf(page,
1826                               "SPC-2 Reservation: %s Initiator: %s\n",
1827                               se_nacl->se_tpg->se_tpg_tfo->fabric_name,
1828                               se_nacl->initiatorname);
1829         } else {
1830                 len = sprintf(page, "No SPC-2 Reservation holder\n");
1831         }
1832         return len;
1833 }
1834
1835 static ssize_t target_pr_res_holder_show(struct config_item *item, char *page)
1836 {
1837         struct se_device *dev = pr_to_dev(item);
1838         int ret;
1839
1840         if (!dev->dev_attrib.emulate_pr)
1841                 return sprintf(page, "SPC_RESERVATIONS_DISABLED\n");
1842
1843         if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)
1844                 return sprintf(page, "Passthrough\n");
1845
1846         spin_lock(&dev->dev_reservation_lock);
1847         if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
1848                 ret = target_core_dev_pr_show_spc2_res(dev, page);
1849         else
1850                 ret = target_core_dev_pr_show_spc3_res(dev, page);
1851         spin_unlock(&dev->dev_reservation_lock);
1852         return ret;
1853 }
1854
1855 static ssize_t target_pr_res_pr_all_tgt_pts_show(struct config_item *item,
1856                 char *page)
1857 {
1858         struct se_device *dev = pr_to_dev(item);
1859         ssize_t len = 0;
1860
1861         spin_lock(&dev->dev_reservation_lock);
1862         if (!dev->dev_pr_res_holder) {
1863                 len = sprintf(page, "No SPC-3 Reservation holder\n");
1864         } else if (dev->dev_pr_res_holder->pr_reg_all_tg_pt) {
1865                 len = sprintf(page, "SPC-3 Reservation: All Target"
1866                         " Ports registration\n");
1867         } else {
1868                 len = sprintf(page, "SPC-3 Reservation: Single"
1869                         " Target Port registration\n");
1870         }
1871
1872         spin_unlock(&dev->dev_reservation_lock);
1873         return len;
1874 }
1875
1876 static ssize_t target_pr_res_pr_generation_show(struct config_item *item,
1877                 char *page)
1878 {
1879         return sprintf(page, "0x%08x\n", pr_to_dev(item)->t10_pr.pr_generation);
1880 }
1881
1882
1883 static ssize_t target_pr_res_pr_holder_tg_port_show(struct config_item *item,
1884                 char *page)
1885 {
1886         struct se_device *dev = pr_to_dev(item);
1887         struct se_node_acl *se_nacl;
1888         struct se_portal_group *se_tpg;
1889         struct t10_pr_registration *pr_reg;
1890         const struct target_core_fabric_ops *tfo;
1891         ssize_t len = 0;
1892
1893         spin_lock(&dev->dev_reservation_lock);
1894         pr_reg = dev->dev_pr_res_holder;
1895         if (!pr_reg) {
1896                 len = sprintf(page, "No SPC-3 Reservation holder\n");
1897                 goto out_unlock;
1898         }
1899
1900         se_nacl = pr_reg->pr_reg_nacl;
1901         se_tpg = se_nacl->se_tpg;
1902         tfo = se_tpg->se_tpg_tfo;
1903
1904         len += sprintf(page+len, "SPC-3 Reservation: %s"
1905                 " Target Node Endpoint: %s\n", tfo->fabric_name,
1906                 tfo->tpg_get_wwn(se_tpg));
1907         len += sprintf(page+len, "SPC-3 Reservation: Relative Port"
1908                 " Identifier Tag: %hu %s Portal Group Tag: %hu"
1909                 " %s Logical Unit: %llu\n", pr_reg->tg_pt_sep_rtpi,
1910                 tfo->fabric_name, tfo->tpg_get_tag(se_tpg),
1911                 tfo->fabric_name, pr_reg->pr_aptpl_target_lun);
1912
1913 out_unlock:
1914         spin_unlock(&dev->dev_reservation_lock);
1915         return len;
1916 }
1917
1918
1919 static ssize_t target_pr_res_pr_registered_i_pts_show(struct config_item *item,
1920                 char *page)
1921 {
1922         struct se_device *dev = pr_to_dev(item);
1923         const struct target_core_fabric_ops *tfo;
1924         struct t10_pr_registration *pr_reg;
1925         unsigned char buf[384];
1926         char i_buf[PR_REG_ISID_ID_LEN];
1927         ssize_t len = 0;
1928         int reg_count = 0;
1929
1930         len += sprintf(page+len, "SPC-3 PR Registrations:\n");
1931
1932         spin_lock(&dev->t10_pr.registration_lock);
1933         list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
1934                         pr_reg_list) {
1935
1936                 memset(buf, 0, 384);
1937                 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
1938                 tfo = pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
1939                 core_pr_dump_initiator_port(pr_reg, i_buf,
1940                                         PR_REG_ISID_ID_LEN);
1941                 sprintf(buf, "%s Node: %s%s Key: 0x%016Lx PRgen: 0x%08x\n",
1942                         tfo->fabric_name,
1943                         pr_reg->pr_reg_nacl->initiatorname, i_buf, pr_reg->pr_res_key,
1944                         pr_reg->pr_res_generation);
1945
1946                 if (len + strlen(buf) >= PAGE_SIZE)
1947                         break;
1948
1949                 len += sprintf(page+len, "%s", buf);
1950                 reg_count++;
1951         }
1952         spin_unlock(&dev->t10_pr.registration_lock);
1953
1954         if (!reg_count)
1955                 len += sprintf(page+len, "None\n");
1956
1957         return len;
1958 }
1959
1960 static ssize_t target_pr_res_pr_type_show(struct config_item *item, char *page)
1961 {
1962         struct se_device *dev = pr_to_dev(item);
1963         struct t10_pr_registration *pr_reg;
1964         ssize_t len = 0;
1965
1966         spin_lock(&dev->dev_reservation_lock);
1967         pr_reg = dev->dev_pr_res_holder;
1968         if (pr_reg) {
1969                 len = sprintf(page, "SPC-3 Reservation Type: %s\n",
1970                         core_scsi3_pr_dump_type(pr_reg->pr_res_type));
1971         } else {
1972                 len = sprintf(page, "No SPC-3 Reservation holder\n");
1973         }
1974
1975         spin_unlock(&dev->dev_reservation_lock);
1976         return len;
1977 }
1978
1979 static ssize_t target_pr_res_type_show(struct config_item *item, char *page)
1980 {
1981         struct se_device *dev = pr_to_dev(item);
1982
1983         if (!dev->dev_attrib.emulate_pr)
1984                 return sprintf(page, "SPC_RESERVATIONS_DISABLED\n");
1985         if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)
1986                 return sprintf(page, "SPC_PASSTHROUGH\n");
1987         if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
1988                 return sprintf(page, "SPC2_RESERVATIONS\n");
1989
1990         return sprintf(page, "SPC3_PERSISTENT_RESERVATIONS\n");
1991 }
1992
1993 static ssize_t target_pr_res_aptpl_active_show(struct config_item *item,
1994                 char *page)
1995 {
1996         struct se_device *dev = pr_to_dev(item);
1997
1998         if (!dev->dev_attrib.emulate_pr ||
1999             (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
2000                 return 0;
2001
2002         return sprintf(page, "APTPL Bit Status: %s\n",
2003                 (dev->t10_pr.pr_aptpl_active) ? "Activated" : "Disabled");
2004 }
2005
2006 static ssize_t target_pr_res_aptpl_metadata_show(struct config_item *item,
2007                 char *page)
2008 {
2009         struct se_device *dev = pr_to_dev(item);
2010
2011         if (!dev->dev_attrib.emulate_pr ||
2012             (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
2013                 return 0;
2014
2015         return sprintf(page, "Ready to process PR APTPL metadata..\n");
2016 }
2017
2018 enum {
2019         Opt_initiator_fabric, Opt_initiator_node, Opt_initiator_sid,
2020         Opt_sa_res_key, Opt_res_holder, Opt_res_type, Opt_res_scope,
2021         Opt_res_all_tg_pt, Opt_mapped_lun, Opt_target_fabric,
2022         Opt_target_node, Opt_tpgt, Opt_port_rtpi, Opt_target_lun, Opt_err
2023 };
2024
2025 static match_table_t tokens = {
2026         {Opt_initiator_fabric, "initiator_fabric=%s"},
2027         {Opt_initiator_node, "initiator_node=%s"},
2028         {Opt_initiator_sid, "initiator_sid=%s"},
2029         {Opt_sa_res_key, "sa_res_key=%s"},
2030         {Opt_res_holder, "res_holder=%d"},
2031         {Opt_res_type, "res_type=%d"},
2032         {Opt_res_scope, "res_scope=%d"},
2033         {Opt_res_all_tg_pt, "res_all_tg_pt=%d"},
2034         {Opt_mapped_lun, "mapped_lun=%u"},
2035         {Opt_target_fabric, "target_fabric=%s"},
2036         {Opt_target_node, "target_node=%s"},
2037         {Opt_tpgt, "tpgt=%d"},
2038         {Opt_port_rtpi, "port_rtpi=%d"},
2039         {Opt_target_lun, "target_lun=%u"},
2040         {Opt_err, NULL}
2041 };
2042
2043 static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item,
2044                 const char *page, size_t count)
2045 {
2046         struct se_device *dev = pr_to_dev(item);
2047         unsigned char *i_fabric = NULL, *i_port = NULL, *isid = NULL;
2048         unsigned char *t_fabric = NULL, *t_port = NULL;
2049         char *orig, *ptr, *opts;
2050         substring_t args[MAX_OPT_ARGS];
2051         unsigned long long tmp_ll;
2052         u64 sa_res_key = 0;
2053         u64 mapped_lun = 0, target_lun = 0;
2054         int ret = -1, res_holder = 0, all_tg_pt = 0, arg, token;
2055         u16 tpgt = 0;
2056         u8 type = 0;
2057
2058         if (!dev->dev_attrib.emulate_pr ||
2059             (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
2060                 return count;
2061         if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
2062                 return count;
2063
2064         if (dev->export_count) {
2065                 pr_debug("Unable to process APTPL metadata while"
2066                         " active fabric exports exist\n");
2067                 return -EINVAL;
2068         }
2069
2070         opts = kstrdup(page, GFP_KERNEL);
2071         if (!opts)
2072                 return -ENOMEM;
2073
2074         orig = opts;
2075         while ((ptr = strsep(&opts, ",\n")) != NULL) {
2076                 if (!*ptr)
2077                         continue;
2078
2079                 token = match_token(ptr, tokens, args);
2080                 switch (token) {
2081                 case Opt_initiator_fabric:
2082                         i_fabric = match_strdup(args);
2083                         if (!i_fabric) {
2084                                 ret = -ENOMEM;
2085                                 goto out;
2086                         }
2087                         break;
2088                 case Opt_initiator_node:
2089                         i_port = match_strdup(args);
2090                         if (!i_port) {
2091                                 ret = -ENOMEM;
2092                                 goto out;
2093                         }
2094                         if (strlen(i_port) >= PR_APTPL_MAX_IPORT_LEN) {
2095                                 pr_err("APTPL metadata initiator_node="
2096                                         " exceeds PR_APTPL_MAX_IPORT_LEN: %d\n",
2097                                         PR_APTPL_MAX_IPORT_LEN);
2098                                 ret = -EINVAL;
2099                                 break;
2100                         }
2101                         break;
2102                 case Opt_initiator_sid:
2103                         isid = match_strdup(args);
2104                         if (!isid) {
2105                                 ret = -ENOMEM;
2106                                 goto out;
2107                         }
2108                         if (strlen(isid) >= PR_REG_ISID_LEN) {
2109                                 pr_err("APTPL metadata initiator_isid"
2110                                         "= exceeds PR_REG_ISID_LEN: %d\n",
2111                                         PR_REG_ISID_LEN);
2112                                 ret = -EINVAL;
2113                                 break;
2114                         }
2115                         break;
2116                 case Opt_sa_res_key:
2117                         ret = match_u64(args,  &tmp_ll);
2118                         if (ret < 0) {
2119                                 pr_err("kstrtoull() failed for sa_res_key=\n");
2120                                 goto out;
2121                         }
2122                         sa_res_key = (u64)tmp_ll;
2123                         break;
2124                 /*
2125                  * PR APTPL Metadata for Reservation
2126                  */
2127                 case Opt_res_holder:
2128                         ret = match_int(args, &arg);
2129                         if (ret)
2130                                 goto out;
2131                         res_holder = arg;
2132                         break;
2133                 case Opt_res_type:
2134                         ret = match_int(args, &arg);
2135                         if (ret)
2136                                 goto out;
2137                         type = (u8)arg;
2138                         break;
2139                 case Opt_res_scope:
2140                         ret = match_int(args, &arg);
2141                         if (ret)
2142                                 goto out;
2143                         break;
2144                 case Opt_res_all_tg_pt:
2145                         ret = match_int(args, &arg);
2146                         if (ret)
2147                                 goto out;
2148                         all_tg_pt = (int)arg;
2149                         break;
2150                 case Opt_mapped_lun:
2151                         ret = match_u64(args, &tmp_ll);
2152                         if (ret)
2153                                 goto out;
2154                         mapped_lun = (u64)tmp_ll;
2155                         break;
2156                 /*
2157                  * PR APTPL Metadata for Target Port
2158                  */
2159                 case Opt_target_fabric:
2160                         t_fabric = match_strdup(args);
2161                         if (!t_fabric) {
2162                                 ret = -ENOMEM;
2163                                 goto out;
2164                         }
2165                         break;
2166                 case Opt_target_node:
2167                         t_port = match_strdup(args);
2168                         if (!t_port) {
2169                                 ret = -ENOMEM;
2170                                 goto out;
2171                         }
2172                         if (strlen(t_port) >= PR_APTPL_MAX_TPORT_LEN) {
2173                                 pr_err("APTPL metadata target_node="
2174                                         " exceeds PR_APTPL_MAX_TPORT_LEN: %d\n",
2175                                         PR_APTPL_MAX_TPORT_LEN);
2176                                 ret = -EINVAL;
2177                                 break;
2178                         }
2179                         break;
2180                 case Opt_tpgt:
2181                         ret = match_int(args, &arg);
2182                         if (ret)
2183                                 goto out;
2184                         tpgt = (u16)arg;
2185                         break;
2186                 case Opt_port_rtpi:
2187                         ret = match_int(args, &arg);
2188                         if (ret)
2189                                 goto out;
2190                         break;
2191                 case Opt_target_lun:
2192                         ret = match_u64(args, &tmp_ll);
2193                         if (ret)
2194                                 goto out;
2195                         target_lun = (u64)tmp_ll;
2196                         break;
2197                 default:
2198                         break;
2199                 }
2200         }
2201
2202         if (!i_port || !t_port || !sa_res_key) {
2203                 pr_err("Illegal parameters for APTPL registration\n");
2204                 ret = -EINVAL;
2205                 goto out;
2206         }
2207
2208         if (res_holder && !(type)) {
2209                 pr_err("Illegal PR type: 0x%02x for reservation"
2210                                 " holder\n", type);
2211                 ret = -EINVAL;
2212                 goto out;
2213         }
2214
2215         ret = core_scsi3_alloc_aptpl_registration(&dev->t10_pr, sa_res_key,
2216                         i_port, isid, mapped_lun, t_port, tpgt, target_lun,
2217                         res_holder, all_tg_pt, type);
2218 out:
2219         kfree(i_fabric);
2220         kfree(i_port);
2221         kfree(isid);
2222         kfree(t_fabric);
2223         kfree(t_port);
2224         kfree(orig);
2225         return (ret == 0) ? count : ret;
2226 }
2227
2228
2229 CONFIGFS_ATTR_RO(target_pr_, res_holder);
2230 CONFIGFS_ATTR_RO(target_pr_, res_pr_all_tgt_pts);
2231 CONFIGFS_ATTR_RO(target_pr_, res_pr_generation);
2232 CONFIGFS_ATTR_RO(target_pr_, res_pr_holder_tg_port);
2233 CONFIGFS_ATTR_RO(target_pr_, res_pr_registered_i_pts);
2234 CONFIGFS_ATTR_RO(target_pr_, res_pr_type);
2235 CONFIGFS_ATTR_RO(target_pr_, res_type);
2236 CONFIGFS_ATTR_RO(target_pr_, res_aptpl_active);
2237 CONFIGFS_ATTR(target_pr_, res_aptpl_metadata);
2238
2239 static struct configfs_attribute *target_core_dev_pr_attrs[] = {
2240         &target_pr_attr_res_holder,
2241         &target_pr_attr_res_pr_all_tgt_pts,
2242         &target_pr_attr_res_pr_generation,
2243         &target_pr_attr_res_pr_holder_tg_port,
2244         &target_pr_attr_res_pr_registered_i_pts,
2245         &target_pr_attr_res_pr_type,
2246         &target_pr_attr_res_type,
2247         &target_pr_attr_res_aptpl_active,
2248         &target_pr_attr_res_aptpl_metadata,
2249         NULL,
2250 };
2251
2252 TB_CIT_SETUP(dev_pr, NULL, NULL, target_core_dev_pr_attrs);
2253
2254 /*  End functions for struct config_item_type tb_dev_pr_cit */
2255
2256 /*  Start functions for struct config_item_type tb_dev_cit */
2257
2258 static inline struct se_device *to_device(struct config_item *item)
2259 {
2260         return container_of(to_config_group(item), struct se_device, dev_group);
2261 }
2262
2263 static ssize_t target_dev_info_show(struct config_item *item, char *page)
2264 {
2265         struct se_device *dev = to_device(item);
2266         int bl = 0;
2267         ssize_t read_bytes = 0;
2268
2269         transport_dump_dev_state(dev, page, &bl);
2270         read_bytes += bl;
2271         read_bytes += dev->transport->show_configfs_dev_params(dev,
2272                         page+read_bytes);
2273         return read_bytes;
2274 }
2275
2276 static ssize_t target_dev_control_store(struct config_item *item,
2277                 const char *page, size_t count)
2278 {
2279         struct se_device *dev = to_device(item);
2280
2281         return dev->transport->set_configfs_dev_params(dev, page, count);
2282 }
2283
2284 static ssize_t target_dev_alias_show(struct config_item *item, char *page)
2285 {
2286         struct se_device *dev = to_device(item);
2287
2288         if (!(dev->dev_flags & DF_USING_ALIAS))
2289                 return 0;
2290
2291         return snprintf(page, PAGE_SIZE, "%s\n", dev->dev_alias);
2292 }
2293
2294 static ssize_t target_dev_alias_store(struct config_item *item,
2295                 const char *page, size_t count)
2296 {
2297         struct se_device *dev = to_device(item);
2298         struct se_hba *hba = dev->se_hba;
2299         ssize_t read_bytes;
2300
2301         if (count > (SE_DEV_ALIAS_LEN-1)) {
2302                 pr_err("alias count: %d exceeds"
2303                         " SE_DEV_ALIAS_LEN-1: %u\n", (int)count,
2304                         SE_DEV_ALIAS_LEN-1);
2305                 return -EINVAL;
2306         }
2307
2308         read_bytes = snprintf(&dev->dev_alias[0], SE_DEV_ALIAS_LEN, "%s", page);
2309         if (!read_bytes)
2310                 return -EINVAL;
2311         if (dev->dev_alias[read_bytes - 1] == '\n')
2312                 dev->dev_alias[read_bytes - 1] = '\0';
2313
2314         dev->dev_flags |= DF_USING_ALIAS;
2315
2316         pr_debug("Target_Core_ConfigFS: %s/%s set alias: %s\n",
2317                 config_item_name(&hba->hba_group.cg_item),
2318                 config_item_name(&dev->dev_group.cg_item),
2319                 dev->dev_alias);
2320
2321         return read_bytes;
2322 }
2323
2324 static ssize_t target_dev_udev_path_show(struct config_item *item, char *page)
2325 {
2326         struct se_device *dev = to_device(item);
2327
2328         if (!(dev->dev_flags & DF_USING_UDEV_PATH))
2329                 return 0;
2330
2331         return snprintf(page, PAGE_SIZE, "%s\n", dev->udev_path);
2332 }
2333
2334 static ssize_t target_dev_udev_path_store(struct config_item *item,
2335                 const char *page, size_t count)
2336 {
2337         struct se_device *dev = to_device(item);
2338         struct se_hba *hba = dev->se_hba;
2339         ssize_t read_bytes;
2340
2341         if (count > (SE_UDEV_PATH_LEN-1)) {
2342                 pr_err("udev_path count: %d exceeds"
2343                         " SE_UDEV_PATH_LEN-1: %u\n", (int)count,
2344                         SE_UDEV_PATH_LEN-1);
2345                 return -EINVAL;
2346         }
2347
2348         read_bytes = snprintf(&dev->udev_path[0], SE_UDEV_PATH_LEN,
2349                         "%s", page);
2350         if (!read_bytes)
2351                 return -EINVAL;
2352         if (dev->udev_path[read_bytes - 1] == '\n')
2353                 dev->udev_path[read_bytes - 1] = '\0';
2354
2355         dev->dev_flags |= DF_USING_UDEV_PATH;
2356
2357         pr_debug("Target_Core_ConfigFS: %s/%s set udev_path: %s\n",
2358                 config_item_name(&hba->hba_group.cg_item),
2359                 config_item_name(&dev->dev_group.cg_item),
2360                 dev->udev_path);
2361
2362         return read_bytes;
2363 }
2364
2365 static ssize_t target_dev_enable_show(struct config_item *item, char *page)
2366 {
2367         struct se_device *dev = to_device(item);
2368
2369         return snprintf(page, PAGE_SIZE, "%d\n", target_dev_configured(dev));
2370 }
2371
2372 static ssize_t target_dev_enable_store(struct config_item *item,
2373                 const char *page, size_t count)
2374 {
2375         struct se_device *dev = to_device(item);
2376         char *ptr;
2377         int ret;
2378
2379         ptr = strstr(page, "1");
2380         if (!ptr) {
2381                 pr_err("For dev_enable ops, only valid value"
2382                                 " is \"1\"\n");
2383                 return -EINVAL;
2384         }
2385
2386         ret = target_configure_device(dev);
2387         if (ret)
2388                 return ret;
2389         return count;
2390 }
2391
2392 static ssize_t target_dev_alua_lu_gp_show(struct config_item *item, char *page)
2393 {
2394         struct se_device *dev = to_device(item);
2395         struct config_item *lu_ci;
2396         struct t10_alua_lu_gp *lu_gp;
2397         struct t10_alua_lu_gp_member *lu_gp_mem;
2398         ssize_t len = 0;
2399
2400         lu_gp_mem = dev->dev_alua_lu_gp_mem;
2401         if (!lu_gp_mem)
2402                 return 0;
2403
2404         spin_lock(&lu_gp_mem->lu_gp_mem_lock);
2405         lu_gp = lu_gp_mem->lu_gp;
2406         if (lu_gp) {
2407                 lu_ci = &lu_gp->lu_gp_group.cg_item;
2408                 len += sprintf(page, "LU Group Alias: %s\nLU Group ID: %hu\n",
2409                         config_item_name(lu_ci), lu_gp->lu_gp_id);
2410         }
2411         spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
2412
2413         return len;
2414 }
2415
2416 static ssize_t target_dev_alua_lu_gp_store(struct config_item *item,
2417                 const char *page, size_t count)
2418 {
2419         struct se_device *dev = to_device(item);
2420         struct se_hba *hba = dev->se_hba;
2421         struct t10_alua_lu_gp *lu_gp = NULL, *lu_gp_new = NULL;
2422         struct t10_alua_lu_gp_member *lu_gp_mem;
2423         unsigned char buf[LU_GROUP_NAME_BUF] = { };
2424         int move = 0;
2425
2426         lu_gp_mem = dev->dev_alua_lu_gp_mem;
2427         if (!lu_gp_mem)
2428                 return count;
2429
2430         if (count > LU_GROUP_NAME_BUF) {
2431                 pr_err("ALUA LU Group Alias too large!\n");
2432                 return -EINVAL;
2433         }
2434         memcpy(buf, page, count);
2435         /*
2436          * Any ALUA logical unit alias besides "NULL" means we will be
2437          * making a new group association.
2438          */
2439         if (strcmp(strstrip(buf), "NULL")) {
2440                 /*
2441                  * core_alua_get_lu_gp_by_name() will increment reference to
2442                  * struct t10_alua_lu_gp.  This reference is released with
2443                  * core_alua_get_lu_gp_by_name below().
2444                  */
2445                 lu_gp_new = core_alua_get_lu_gp_by_name(strstrip(buf));
2446                 if (!lu_gp_new)
2447                         return -ENODEV;
2448         }
2449
2450         spin_lock(&lu_gp_mem->lu_gp_mem_lock);
2451         lu_gp = lu_gp_mem->lu_gp;
2452         if (lu_gp) {
2453                 /*
2454                  * Clearing an existing lu_gp association, and replacing
2455                  * with NULL
2456                  */
2457                 if (!lu_gp_new) {
2458                         pr_debug("Target_Core_ConfigFS: Releasing %s/%s"
2459                                 " from ALUA LU Group: core/alua/lu_gps/%s, ID:"
2460                                 " %hu\n",
2461                                 config_item_name(&hba->hba_group.cg_item),
2462                                 config_item_name(&dev->dev_group.cg_item),
2463                                 config_item_name(&lu_gp->lu_gp_group.cg_item),
2464                                 lu_gp->lu_gp_id);
2465
2466                         __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp);
2467                         spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
2468
2469                         return count;
2470                 }
2471                 /*
2472                  * Removing existing association of lu_gp_mem with lu_gp
2473                  */
2474                 __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp);
2475                 move = 1;
2476         }
2477         /*
2478          * Associate lu_gp_mem with lu_gp_new.
2479          */
2480         __core_alua_attach_lu_gp_mem(lu_gp_mem, lu_gp_new);
2481         spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
2482
2483         pr_debug("Target_Core_ConfigFS: %s %s/%s to ALUA LU Group:"
2484                 " core/alua/lu_gps/%s, ID: %hu\n",
2485                 (move) ? "Moving" : "Adding",
2486                 config_item_name(&hba->hba_group.cg_item),
2487                 config_item_name(&dev->dev_group.cg_item),
2488                 config_item_name(&lu_gp_new->lu_gp_group.cg_item),
2489                 lu_gp_new->lu_gp_id);
2490
2491         core_alua_put_lu_gp_from_name(lu_gp_new);
2492         return count;
2493 }
2494
2495 static ssize_t target_dev_lba_map_show(struct config_item *item, char *page)
2496 {
2497         struct se_device *dev = to_device(item);
2498         struct t10_alua_lba_map *map;
2499         struct t10_alua_lba_map_member *mem;
2500         char *b = page;
2501         int bl = 0;
2502         char state;
2503
2504         spin_lock(&dev->t10_alua.lba_map_lock);
2505         if (!list_empty(&dev->t10_alua.lba_map_list))
2506             bl += sprintf(b + bl, "%u %u\n",
2507                           dev->t10_alua.lba_map_segment_size,
2508                           dev->t10_alua.lba_map_segment_multiplier);
2509         list_for_each_entry(map, &dev->t10_alua.lba_map_list, lba_map_list) {
2510                 bl += sprintf(b + bl, "%llu %llu",
2511                               map->lba_map_first_lba, map->lba_map_last_lba);
2512                 list_for_each_entry(mem, &map->lba_map_mem_list,
2513                                     lba_map_mem_list) {
2514                         switch (mem->lba_map_mem_alua_state) {
2515                         case ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED:
2516                                 state = 'O';
2517                                 break;
2518                         case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED:
2519                                 state = 'A';
2520                                 break;
2521                         case ALUA_ACCESS_STATE_STANDBY:
2522                                 state = 'S';
2523                                 break;
2524                         case ALUA_ACCESS_STATE_UNAVAILABLE:
2525                                 state = 'U';
2526                                 break;
2527                         default:
2528                                 state = '.';
2529                                 break;
2530                         }
2531                         bl += sprintf(b + bl, " %d:%c",
2532                                       mem->lba_map_mem_alua_pg_id, state);
2533                 }
2534                 bl += sprintf(b + bl, "\n");
2535         }
2536         spin_unlock(&dev->t10_alua.lba_map_lock);
2537         return bl;
2538 }
2539
2540 static ssize_t target_dev_lba_map_store(struct config_item *item,
2541                 const char *page, size_t count)
2542 {
2543         struct se_device *dev = to_device(item);
2544         struct t10_alua_lba_map *lba_map = NULL;
2545         struct list_head lba_list;
2546         char *map_entries, *orig, *ptr;
2547         char state;
2548         int pg_num = -1, pg;
2549         int ret = 0, num = 0, pg_id, alua_state;
2550         unsigned long start_lba = -1, end_lba = -1;
2551         unsigned long segment_size = -1, segment_mult = -1;
2552
2553         orig = map_entries = kstrdup(page, GFP_KERNEL);
2554         if (!map_entries)
2555                 return -ENOMEM;
2556
2557         INIT_LIST_HEAD(&lba_list);
2558         while ((ptr = strsep(&map_entries, "\n")) != NULL) {
2559                 if (!*ptr)
2560                         continue;
2561
2562                 if (num == 0) {
2563                         if (sscanf(ptr, "%lu %lu\n",
2564                                    &segment_size, &segment_mult) != 2) {
2565                                 pr_err("Invalid line %d\n", num);
2566                                 ret = -EINVAL;
2567                                 break;
2568                         }
2569                         num++;
2570                         continue;
2571                 }
2572                 if (sscanf(ptr, "%lu %lu", &start_lba, &end_lba) != 2) {
2573                         pr_err("Invalid line %d\n", num);
2574                         ret = -EINVAL;
2575                         break;
2576                 }
2577                 ptr = strchr(ptr, ' ');
2578                 if (!ptr) {
2579                         pr_err("Invalid line %d, missing end lba\n", num);
2580                         ret = -EINVAL;
2581                         break;
2582                 }
2583                 ptr++;
2584                 ptr = strchr(ptr, ' ');
2585                 if (!ptr) {
2586                         pr_err("Invalid line %d, missing state definitions\n",
2587                                num);
2588                         ret = -EINVAL;
2589                         break;
2590                 }
2591                 ptr++;
2592                 lba_map = core_alua_allocate_lba_map(&lba_list,
2593                                                      start_lba, end_lba);
2594                 if (IS_ERR(lba_map)) {
2595                         ret = PTR_ERR(lba_map);
2596                         break;
2597                 }
2598                 pg = 0;
2599                 while (sscanf(ptr, "%d:%c", &pg_id, &state) == 2) {
2600                         switch (state) {
2601                         case 'O':
2602                                 alua_state = ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED;
2603                                 break;
2604                         case 'A':
2605                                 alua_state = ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED;
2606                                 break;
2607                         case 'S':
2608                                 alua_state = ALUA_ACCESS_STATE_STANDBY;
2609                                 break;
2610                         case 'U':
2611                                 alua_state = ALUA_ACCESS_STATE_UNAVAILABLE;
2612                                 break;
2613                         default:
2614                                 pr_err("Invalid ALUA state '%c'\n", state);
2615                                 ret = -EINVAL;
2616                                 goto out;
2617                         }
2618
2619                         ret = core_alua_allocate_lba_map_mem(lba_map,
2620                                                              pg_id, alua_state);
2621                         if (ret) {
2622                                 pr_err("Invalid target descriptor %d:%c "
2623                                        "at line %d\n",
2624                                        pg_id, state, num);
2625                                 break;
2626                         }
2627                         pg++;
2628                         ptr = strchr(ptr, ' ');
2629                         if (ptr)
2630                                 ptr++;
2631                         else
2632                                 break;
2633                 }
2634                 if (pg_num == -1)
2635                     pg_num = pg;
2636                 else if (pg != pg_num) {
2637                         pr_err("Only %d from %d port groups definitions "
2638                                "at line %d\n", pg, pg_num, num);
2639                         ret = -EINVAL;
2640                         break;
2641                 }
2642                 num++;
2643         }
2644 out:
2645         if (ret) {
2646                 core_alua_free_lba_map(&lba_list);
2647                 count = ret;
2648         } else
2649                 core_alua_set_lba_map(dev, &lba_list,
2650                                       segment_size, segment_mult);
2651         kfree(orig);
2652         return count;
2653 }
2654
2655 CONFIGFS_ATTR_RO(target_dev_, info);
2656 CONFIGFS_ATTR_WO(target_dev_, control);
2657 CONFIGFS_ATTR(target_dev_, alias);
2658 CONFIGFS_ATTR(target_dev_, udev_path);
2659 CONFIGFS_ATTR(target_dev_, enable);
2660 CONFIGFS_ATTR(target_dev_, alua_lu_gp);
2661 CONFIGFS_ATTR(target_dev_, lba_map);
2662
2663 static struct configfs_attribute *target_core_dev_attrs[] = {
2664         &target_dev_attr_info,
2665         &target_dev_attr_control,
2666         &target_dev_attr_alias,
2667         &target_dev_attr_udev_path,
2668         &target_dev_attr_enable,
2669         &target_dev_attr_alua_lu_gp,
2670         &target_dev_attr_lba_map,
2671         NULL,
2672 };
2673
2674 static void target_core_dev_release(struct config_item *item)
2675 {
2676         struct config_group *dev_cg = to_config_group(item);
2677         struct se_device *dev =
2678                 container_of(dev_cg, struct se_device, dev_group);
2679
2680         target_free_device(dev);
2681 }
2682
2683 /*
2684  * Used in target_core_fabric_configfs.c to verify valid se_device symlink
2685  * within target_fabric_port_link()
2686  */
2687 struct configfs_item_operations target_core_dev_item_ops = {
2688         .release                = target_core_dev_release,
2689 };
2690
2691 TB_CIT_SETUP(dev, &target_core_dev_item_ops, NULL, target_core_dev_attrs);
2692
2693 /* End functions for struct config_item_type tb_dev_cit */
2694
2695 /* Start functions for struct config_item_type target_core_alua_lu_gp_cit */
2696
2697 static inline struct t10_alua_lu_gp *to_lu_gp(struct config_item *item)
2698 {
2699         return container_of(to_config_group(item), struct t10_alua_lu_gp,
2700                         lu_gp_group);
2701 }
2702
2703 static ssize_t target_lu_gp_lu_gp_id_show(struct config_item *item, char *page)
2704 {
2705         struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
2706
2707         if (!lu_gp->lu_gp_valid_id)
2708                 return 0;
2709         return sprintf(page, "%hu\n", lu_gp->lu_gp_id);
2710 }
2711
2712 static ssize_t target_lu_gp_lu_gp_id_store(struct config_item *item,
2713                 const char *page, size_t count)
2714 {
2715         struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
2716         struct config_group *alua_lu_gp_cg = &lu_gp->lu_gp_group;
2717         unsigned long lu_gp_id;
2718         int ret;
2719
2720         ret = kstrtoul(page, 0, &lu_gp_id);
2721         if (ret < 0) {
2722                 pr_err("kstrtoul() returned %d for"
2723                         " lu_gp_id\n", ret);
2724                 return ret;
2725         }
2726         if (lu_gp_id > 0x0000ffff) {
2727                 pr_err("ALUA lu_gp_id: %lu exceeds maximum:"
2728                         " 0x0000ffff\n", lu_gp_id);
2729                 return -EINVAL;
2730         }
2731
2732         ret = core_alua_set_lu_gp_id(lu_gp, (u16)lu_gp_id);
2733         if (ret < 0)
2734                 return -EINVAL;
2735
2736         pr_debug("Target_Core_ConfigFS: Set ALUA Logical Unit"
2737                 " Group: core/alua/lu_gps/%s to ID: %hu\n",
2738                 config_item_name(&alua_lu_gp_cg->cg_item),
2739                 lu_gp->lu_gp_id);
2740
2741         return count;
2742 }
2743
2744 static ssize_t target_lu_gp_members_show(struct config_item *item, char *page)
2745 {
2746         struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
2747         struct se_device *dev;
2748         struct se_hba *hba;
2749         struct t10_alua_lu_gp_member *lu_gp_mem;
2750         ssize_t len = 0, cur_len;
2751         unsigned char buf[LU_GROUP_NAME_BUF] = { };
2752
2753         spin_lock(&lu_gp->lu_gp_lock);
2754         list_for_each_entry(lu_gp_mem, &lu_gp->lu_gp_mem_list, lu_gp_mem_list) {
2755                 dev = lu_gp_mem->lu_gp_mem_dev;
2756                 hba = dev->se_hba;
2757
2758                 cur_len = snprintf(buf, LU_GROUP_NAME_BUF, "%s/%s\n",
2759                         config_item_name(&hba->hba_group.cg_item),
2760                         config_item_name(&dev->dev_group.cg_item));
2761                 cur_len++; /* Extra byte for NULL terminator */
2762
2763                 if ((cur_len + len) > PAGE_SIZE) {
2764                         pr_warn("Ran out of lu_gp_show_attr"
2765                                 "_members buffer\n");
2766                         break;
2767                 }
2768                 memcpy(page+len, buf, cur_len);
2769                 len += cur_len;
2770         }
2771         spin_unlock(&lu_gp->lu_gp_lock);
2772
2773         return len;
2774 }
2775
2776 CONFIGFS_ATTR(target_lu_gp_, lu_gp_id);
2777 CONFIGFS_ATTR_RO(target_lu_gp_, members);
2778
2779 static struct configfs_attribute *target_core_alua_lu_gp_attrs[] = {
2780         &target_lu_gp_attr_lu_gp_id,
2781         &target_lu_gp_attr_members,
2782         NULL,
2783 };
2784
2785 static void target_core_alua_lu_gp_release(struct config_item *item)
2786 {
2787         struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
2788                         struct t10_alua_lu_gp, lu_gp_group);
2789
2790         core_alua_free_lu_gp(lu_gp);
2791 }
2792
2793 static struct configfs_item_operations target_core_alua_lu_gp_ops = {
2794         .release                = target_core_alua_lu_gp_release,
2795 };
2796
2797 static const struct config_item_type target_core_alua_lu_gp_cit = {
2798         .ct_item_ops            = &target_core_alua_lu_gp_ops,
2799         .ct_attrs               = target_core_alua_lu_gp_attrs,
2800         .ct_owner               = THIS_MODULE,
2801 };
2802
2803 /* End functions for struct config_item_type target_core_alua_lu_gp_cit */
2804
2805 /* Start functions for struct config_item_type target_core_alua_lu_gps_cit */
2806
2807 static struct config_group *target_core_alua_create_lu_gp(
2808         struct config_group *group,
2809         const char *name)
2810 {
2811         struct t10_alua_lu_gp *lu_gp;
2812         struct config_group *alua_lu_gp_cg = NULL;
2813         struct config_item *alua_lu_gp_ci = NULL;
2814
2815         lu_gp = core_alua_allocate_lu_gp(name, 0);
2816         if (IS_ERR(lu_gp))
2817                 return NULL;
2818
2819         alua_lu_gp_cg = &lu_gp->lu_gp_group;
2820         alua_lu_gp_ci = &alua_lu_gp_cg->cg_item;
2821
2822         config_group_init_type_name(alua_lu_gp_cg, name,
2823                         &target_core_alua_lu_gp_cit);
2824
2825         pr_debug("Target_Core_ConfigFS: Allocated ALUA Logical Unit"
2826                 " Group: core/alua/lu_gps/%s\n",
2827                 config_item_name(alua_lu_gp_ci));
2828
2829         return alua_lu_gp_cg;
2830
2831 }
2832
2833 static void target_core_alua_drop_lu_gp(
2834         struct config_group *group,
2835         struct config_item *item)
2836 {
2837         struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
2838                         struct t10_alua_lu_gp, lu_gp_group);
2839
2840         pr_debug("Target_Core_ConfigFS: Releasing ALUA Logical Unit"
2841                 " Group: core/alua/lu_gps/%s, ID: %hu\n",
2842                 config_item_name(item), lu_gp->lu_gp_id);
2843         /*
2844          * core_alua_free_lu_gp() is called from target_core_alua_lu_gp_ops->release()
2845          * -> target_core_alua_lu_gp_release()
2846          */
2847         config_item_put(item);
2848 }
2849
2850 static struct configfs_group_operations target_core_alua_lu_gps_group_ops = {
2851         .make_group             = &target_core_alua_create_lu_gp,
2852         .drop_item              = &target_core_alua_drop_lu_gp,
2853 };
2854
2855 static const struct config_item_type target_core_alua_lu_gps_cit = {
2856         .ct_item_ops            = NULL,
2857         .ct_group_ops           = &target_core_alua_lu_gps_group_ops,
2858         .ct_owner               = THIS_MODULE,
2859 };
2860
2861 /* End functions for struct config_item_type target_core_alua_lu_gps_cit */
2862
2863 /* Start functions for struct config_item_type target_core_alua_tg_pt_gp_cit */
2864
2865 static inline struct t10_alua_tg_pt_gp *to_tg_pt_gp(struct config_item *item)
2866 {
2867         return container_of(to_config_group(item), struct t10_alua_tg_pt_gp,
2868                         tg_pt_gp_group);
2869 }
2870
2871 static ssize_t target_tg_pt_gp_alua_access_state_show(struct config_item *item,
2872                 char *page)
2873 {
2874         return sprintf(page, "%d\n",
2875                        to_tg_pt_gp(item)->tg_pt_gp_alua_access_state);
2876 }
2877
2878 static ssize_t target_tg_pt_gp_alua_access_state_store(struct config_item *item,
2879                 const char *page, size_t count)
2880 {
2881         struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
2882         struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
2883         unsigned long tmp;
2884         int new_state, ret;
2885
2886         if (!tg_pt_gp->tg_pt_gp_valid_id) {
2887                 pr_err("Unable to do implicit ALUA on invalid tg_pt_gp ID\n");
2888                 return -EINVAL;
2889         }
2890         if (!target_dev_configured(dev)) {
2891                 pr_err("Unable to set alua_access_state while device is"
2892                        " not configured\n");
2893                 return -ENODEV;
2894         }
2895
2896         ret = kstrtoul(page, 0, &tmp);
2897         if (ret < 0) {
2898                 pr_err("Unable to extract new ALUA access state from"
2899                                 " %s\n", page);
2900                 return ret;
2901         }
2902         new_state = (int)tmp;
2903
2904         if (!(tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_IMPLICIT_ALUA)) {
2905                 pr_err("Unable to process implicit configfs ALUA"
2906                         " transition while TPGS_IMPLICIT_ALUA is disabled\n");
2907                 return -EINVAL;
2908         }
2909         if (tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA &&
2910             new_state == ALUA_ACCESS_STATE_LBA_DEPENDENT) {
2911                 /* LBA DEPENDENT is only allowed with implicit ALUA */
2912                 pr_err("Unable to process implicit configfs ALUA transition"
2913                        " while explicit ALUA management is enabled\n");
2914                 return -EINVAL;
2915         }
2916
2917         ret = core_alua_do_port_transition(tg_pt_gp, dev,
2918                                         NULL, NULL, new_state, 0);
2919         return (!ret) ? count : -EINVAL;
2920 }
2921
2922 static ssize_t target_tg_pt_gp_alua_access_status_show(struct config_item *item,
2923                 char *page)
2924 {
2925         struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
2926         return sprintf(page, "%s\n",
2927                 core_alua_dump_status(tg_pt_gp->tg_pt_gp_alua_access_status));
2928 }
2929
2930 static ssize_t target_tg_pt_gp_alua_access_status_store(
2931                 struct config_item *item, const char *page, size_t count)
2932 {
2933         struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
2934         unsigned long tmp;
2935         int new_status, ret;
2936
2937         if (!tg_pt_gp->tg_pt_gp_valid_id) {
2938                 pr_err("Unable to set ALUA access status on invalid tg_pt_gp ID\n");
2939                 return -EINVAL;
2940         }
2941
2942         ret = kstrtoul(page, 0, &tmp);
2943         if (ret < 0) {
2944                 pr_err("Unable to extract new ALUA access status"
2945                                 " from %s\n", page);
2946                 return ret;
2947         }
2948         new_status = (int)tmp;
2949
2950         if ((new_status != ALUA_STATUS_NONE) &&
2951             (new_status != ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG) &&
2952             (new_status != ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA)) {
2953                 pr_err("Illegal ALUA access status: 0x%02x\n",
2954                                 new_status);
2955                 return -EINVAL;
2956         }
2957
2958         tg_pt_gp->tg_pt_gp_alua_access_status = new_status;
2959         return count;
2960 }
2961
2962 static ssize_t target_tg_pt_gp_alua_access_type_show(struct config_item *item,
2963                 char *page)
2964 {
2965         return core_alua_show_access_type(to_tg_pt_gp(item), page);
2966 }
2967
2968 static ssize_t target_tg_pt_gp_alua_access_type_store(struct config_item *item,
2969                 const char *page, size_t count)
2970 {
2971         return core_alua_store_access_type(to_tg_pt_gp(item), page, count);
2972 }
2973
2974 #define ALUA_SUPPORTED_STATE_ATTR(_name, _bit)                          \
2975 static ssize_t target_tg_pt_gp_alua_support_##_name##_show(             \
2976                 struct config_item *item, char *p)                      \
2977 {                                                                       \
2978         struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item);                \
2979         return sprintf(p, "%d\n",                                       \
2980                 !!(t->tg_pt_gp_alua_supported_states & _bit));          \
2981 }                                                                       \
2982                                                                         \
2983 static ssize_t target_tg_pt_gp_alua_support_##_name##_store(            \
2984                 struct config_item *item, const char *p, size_t c)      \
2985 {                                                                       \
2986         struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item);                \
2987         unsigned long tmp;                                              \
2988         int ret;                                                        \
2989                                                                         \
2990         if (!t->tg_pt_gp_valid_id) {                                    \
2991                 pr_err("Unable to set " #_name " ALUA state on invalid tg_pt_gp ID\n"); \
2992                 return -EINVAL;                                         \
2993         }                                                               \
2994                                                                         \
2995         ret = kstrtoul(p, 0, &tmp);                                     \
2996         if (ret < 0) {                                                  \
2997                 pr_err("Invalid value '%s', must be '0' or '1'\n", p);  \
2998                 return -EINVAL;                                         \
2999         }                                                               \
3000         if (tmp > 1) {                                                  \
3001                 pr_err("Invalid value '%ld', must be '0' or '1'\n", tmp); \
3002                 return -EINVAL;                                         \
3003         }                                                               \
3004         if (tmp)                                                        \
3005                 t->tg_pt_gp_alua_supported_states |= _bit;              \
3006         else                                                            \
3007                 t->tg_pt_gp_alua_supported_states &= ~_bit;             \
3008                                                                         \
3009         return c;                                                       \
3010 }
3011
3012 ALUA_SUPPORTED_STATE_ATTR(transitioning, ALUA_T_SUP);
3013 ALUA_SUPPORTED_STATE_ATTR(offline, ALUA_O_SUP);
3014 ALUA_SUPPORTED_STATE_ATTR(lba_dependent, ALUA_LBD_SUP);
3015 ALUA_SUPPORTED_STATE_ATTR(unavailable, ALUA_U_SUP);
3016 ALUA_SUPPORTED_STATE_ATTR(standby, ALUA_S_SUP);
3017 ALUA_SUPPORTED_STATE_ATTR(active_optimized, ALUA_AO_SUP);
3018 ALUA_SUPPORTED_STATE_ATTR(active_nonoptimized, ALUA_AN_SUP);
3019
3020 static ssize_t target_tg_pt_gp_alua_write_metadata_show(
3021                 struct config_item *item, char *page)
3022 {
3023         return sprintf(page, "%d\n",
3024                 to_tg_pt_gp(item)->tg_pt_gp_write_metadata);
3025 }
3026
3027 static ssize_t target_tg_pt_gp_alua_write_metadata_store(
3028                 struct config_item *item, const char *page, size_t count)
3029 {
3030         struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
3031         unsigned long tmp;
3032         int ret;
3033
3034         ret = kstrtoul(page, 0, &tmp);
3035         if (ret < 0) {
3036                 pr_err("Unable to extract alua_write_metadata\n");
3037                 return ret;
3038         }
3039
3040         if ((tmp != 0) && (tmp != 1)) {
3041                 pr_err("Illegal value for alua_write_metadata:"
3042                         " %lu\n", tmp);
3043                 return -EINVAL;
3044         }
3045         tg_pt_gp->tg_pt_gp_write_metadata = (int)tmp;
3046
3047         return count;
3048 }
3049
3050 static ssize_t target_tg_pt_gp_nonop_delay_msecs_show(struct config_item *item,
3051                 char *page)
3052 {
3053         return core_alua_show_nonop_delay_msecs(to_tg_pt_gp(item), page);
3054 }
3055
3056 static ssize_t target_tg_pt_gp_nonop_delay_msecs_store(struct config_item *item,
3057                 const char *page, size_t count)
3058 {
3059         return core_alua_store_nonop_delay_msecs(to_tg_pt_gp(item), page,
3060                         count);
3061 }
3062
3063 static ssize_t target_tg_pt_gp_trans_delay_msecs_show(struct config_item *item,
3064                 char *page)
3065 {
3066         return core_alua_show_trans_delay_msecs(to_tg_pt_gp(item), page);
3067 }
3068
3069 static ssize_t target_tg_pt_gp_trans_delay_msecs_store(struct config_item *item,
3070                 const char *page, size_t count)
3071 {
3072         return core_alua_store_trans_delay_msecs(to_tg_pt_gp(item), page,
3073                         count);
3074 }
3075
3076 static ssize_t target_tg_pt_gp_implicit_trans_secs_show(
3077                 struct config_item *item, char *page)
3078 {
3079         return core_alua_show_implicit_trans_secs(to_tg_pt_gp(item), page);
3080 }
3081
3082 static ssize_t target_tg_pt_gp_implicit_trans_secs_store(
3083                 struct config_item *item, const char *page, size_t count)
3084 {
3085         return core_alua_store_implicit_trans_secs(to_tg_pt_gp(item), page,
3086                         count);
3087 }
3088
3089 static ssize_t target_tg_pt_gp_preferred_show(struct config_item *item,
3090                 char *page)
3091 {
3092         return core_alua_show_preferred_bit(to_tg_pt_gp(item), page);
3093 }
3094
3095 static ssize_t target_tg_pt_gp_preferred_store(struct config_item *item,
3096                 const char *page, size_t count)
3097 {
3098         return core_alua_store_preferred_bit(to_tg_pt_gp(item), page, count);
3099 }
3100
3101 static ssize_t target_tg_pt_gp_tg_pt_gp_id_show(struct config_item *item,
3102                 char *page)
3103 {
3104         struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
3105
3106         if (!tg_pt_gp->tg_pt_gp_valid_id)
3107                 return 0;
3108         return sprintf(page, "%hu\n", tg_pt_gp->tg_pt_gp_id);
3109 }
3110
3111 static ssize_t target_tg_pt_gp_tg_pt_gp_id_store(struct config_item *item,
3112                 const char *page, size_t count)
3113 {
3114         struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
3115         struct config_group *alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group;
3116         unsigned long tg_pt_gp_id;
3117         int ret;
3118
3119         ret = kstrtoul(page, 0, &tg_pt_gp_id);
3120         if (ret < 0) {
3121                 pr_err("ALUA tg_pt_gp_id: invalid value '%s' for tg_pt_gp_id\n",
3122                        page);
3123                 return ret;
3124         }
3125         if (tg_pt_gp_id > 0x0000ffff) {
3126                 pr_err("ALUA tg_pt_gp_id: %lu exceeds maximum: 0x0000ffff\n",
3127                        tg_pt_gp_id);
3128                 return -EINVAL;
3129         }
3130
3131         ret = core_alua_set_tg_pt_gp_id(tg_pt_gp, (u16)tg_pt_gp_id);
3132         if (ret < 0)
3133                 return -EINVAL;
3134
3135         pr_debug("Target_Core_ConfigFS: Set ALUA Target Port Group: "
3136                 "core/alua/tg_pt_gps/%s to ID: %hu\n",
3137                 config_item_name(&alua_tg_pt_gp_cg->cg_item),
3138                 tg_pt_gp->tg_pt_gp_id);
3139
3140         return count;
3141 }
3142
3143 static ssize_t target_tg_pt_gp_members_show(struct config_item *item,
3144                 char *page)
3145 {
3146         struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
3147         struct se_lun *lun;
3148         ssize_t len = 0, cur_len;
3149         unsigned char buf[TG_PT_GROUP_NAME_BUF] = { };
3150
3151         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
3152         list_for_each_entry(lun, &tg_pt_gp->tg_pt_gp_lun_list,
3153                         lun_tg_pt_gp_link) {
3154                 struct se_portal_group *tpg = lun->lun_tpg;
3155
3156                 cur_len = snprintf(buf, TG_PT_GROUP_NAME_BUF, "%s/%s/tpgt_%hu"
3157                         "/%s\n", tpg->se_tpg_tfo->fabric_name,
3158                         tpg->se_tpg_tfo->tpg_get_wwn(tpg),
3159                         tpg->se_tpg_tfo->tpg_get_tag(tpg),
3160                         config_item_name(&lun->lun_group.cg_item));
3161                 cur_len++; /* Extra byte for NULL terminator */
3162
3163                 if ((cur_len + len) > PAGE_SIZE) {
3164                         pr_warn("Ran out of lu_gp_show_attr"
3165                                 "_members buffer\n");
3166                         break;
3167                 }
3168                 memcpy(page+len, buf, cur_len);
3169                 len += cur_len;
3170         }
3171         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
3172
3173         return len;
3174 }
3175
3176 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_state);
3177 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_status);
3178 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_type);
3179 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_transitioning);
3180 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_offline);
3181 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_lba_dependent);
3182 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_unavailable);
3183 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_standby);
3184 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_optimized);
3185 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_nonoptimized);
3186 CONFIGFS_ATTR(target_tg_pt_gp_, alua_write_metadata);
3187 CONFIGFS_ATTR(target_tg_pt_gp_, nonop_delay_msecs);
3188 CONFIGFS_ATTR(target_tg_pt_gp_, trans_delay_msecs);
3189 CONFIGFS_ATTR(target_tg_pt_gp_, implicit_trans_secs);
3190 CONFIGFS_ATTR(target_tg_pt_gp_, preferred);
3191 CONFIGFS_ATTR(target_tg_pt_gp_, tg_pt_gp_id);
3192 CONFIGFS_ATTR_RO(target_tg_pt_gp_, members);
3193
3194 static struct configfs_attribute *target_core_alua_tg_pt_gp_attrs[] = {
3195         &target_tg_pt_gp_attr_alua_access_state,
3196         &target_tg_pt_gp_attr_alua_access_status,
3197         &target_tg_pt_gp_attr_alua_access_type,
3198         &target_tg_pt_gp_attr_alua_support_transitioning,
3199         &target_tg_pt_gp_attr_alua_support_offline,
3200         &target_tg_pt_gp_attr_alua_support_lba_dependent,
3201         &target_tg_pt_gp_attr_alua_support_unavailable,
3202         &target_tg_pt_gp_attr_alua_support_standby,
3203         &target_tg_pt_gp_attr_alua_support_active_nonoptimized,
3204         &target_tg_pt_gp_attr_alua_support_active_optimized,
3205         &target_tg_pt_gp_attr_alua_write_metadata,
3206         &target_tg_pt_gp_attr_nonop_delay_msecs,
3207         &target_tg_pt_gp_attr_trans_delay_msecs,
3208         &target_tg_pt_gp_attr_implicit_trans_secs,
3209         &target_tg_pt_gp_attr_preferred,
3210         &target_tg_pt_gp_attr_tg_pt_gp_id,
3211         &target_tg_pt_gp_attr_members,
3212         NULL,
3213 };
3214
3215 static void target_core_alua_tg_pt_gp_release(struct config_item *item)
3216 {
3217         struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
3218                         struct t10_alua_tg_pt_gp, tg_pt_gp_group);
3219
3220         core_alua_free_tg_pt_gp(tg_pt_gp);
3221 }
3222
3223 static struct configfs_item_operations target_core_alua_tg_pt_gp_ops = {
3224         .release                = target_core_alua_tg_pt_gp_release,
3225 };
3226
3227 static const struct config_item_type target_core_alua_tg_pt_gp_cit = {
3228         .ct_item_ops            = &target_core_alua_tg_pt_gp_ops,
3229         .ct_attrs               = target_core_alua_tg_pt_gp_attrs,
3230         .ct_owner               = THIS_MODULE,
3231 };
3232
3233 /* End functions for struct config_item_type target_core_alua_tg_pt_gp_cit */
3234
3235 /* Start functions for struct config_item_type tb_alua_tg_pt_gps_cit */
3236
3237 static struct config_group *target_core_alua_create_tg_pt_gp(
3238         struct config_group *group,
3239         const char *name)
3240 {
3241         struct t10_alua *alua = container_of(group, struct t10_alua,
3242                                         alua_tg_pt_gps_group);
3243         struct t10_alua_tg_pt_gp *tg_pt_gp;
3244         struct config_group *alua_tg_pt_gp_cg = NULL;
3245         struct config_item *alua_tg_pt_gp_ci = NULL;
3246
3247         tg_pt_gp = core_alua_allocate_tg_pt_gp(alua->t10_dev, name, 0);
3248         if (!tg_pt_gp)
3249                 return NULL;
3250
3251         alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group;
3252         alua_tg_pt_gp_ci = &alua_tg_pt_gp_cg->cg_item;
3253
3254         config_group_init_type_name(alua_tg_pt_gp_cg, name,
3255                         &target_core_alua_tg_pt_gp_cit);
3256
3257         pr_debug("Target_Core_ConfigFS: Allocated ALUA Target Port"
3258                 " Group: alua/tg_pt_gps/%s\n",
3259                 config_item_name(alua_tg_pt_gp_ci));
3260
3261         return alua_tg_pt_gp_cg;
3262 }
3263
3264 static void target_core_alua_drop_tg_pt_gp(
3265         struct config_group *group,
3266         struct config_item *item)
3267 {
3268         struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
3269                         struct t10_alua_tg_pt_gp, tg_pt_gp_group);
3270
3271         pr_debug("Target_Core_ConfigFS: Releasing ALUA Target Port"
3272                 " Group: alua/tg_pt_gps/%s, ID: %hu\n",
3273                 config_item_name(item), tg_pt_gp->tg_pt_gp_id);
3274         /*
3275          * core_alua_free_tg_pt_gp() is called from target_core_alua_tg_pt_gp_ops->release()
3276          * -> target_core_alua_tg_pt_gp_release().
3277          */
3278         config_item_put(item);
3279 }
3280
3281 static struct configfs_group_operations target_core_alua_tg_pt_gps_group_ops = {
3282         .make_group             = &target_core_alua_create_tg_pt_gp,
3283         .drop_item              = &target_core_alua_drop_tg_pt_gp,
3284 };
3285
3286 TB_CIT_SETUP(dev_alua_tg_pt_gps, NULL, &target_core_alua_tg_pt_gps_group_ops, NULL);
3287
3288 /* End functions for struct config_item_type tb_alua_tg_pt_gps_cit */
3289
3290 /* Start functions for struct config_item_type target_core_alua_cit */
3291
3292 /*
3293  * target_core_alua_cit is a ConfigFS group that lives under
3294  * /sys/kernel/config/target/core/alua.  There are default groups
3295  * core/alua/lu_gps and core/alua/tg_pt_gps that are attached to
3296  * target_core_alua_cit in target_core_init_configfs() below.
3297  */
3298 static const struct config_item_type target_core_alua_cit = {
3299         .ct_item_ops            = NULL,
3300         .ct_attrs               = NULL,
3301         .ct_owner               = THIS_MODULE,
3302 };
3303
3304 /* End functions for struct config_item_type target_core_alua_cit */
3305
3306 /* Start functions for struct config_item_type tb_dev_stat_cit */
3307
3308 static struct config_group *target_core_stat_mkdir(
3309         struct config_group *group,
3310         const char *name)
3311 {
3312         return ERR_PTR(-ENOSYS);
3313 }
3314
3315 static void target_core_stat_rmdir(
3316         struct config_group *group,
3317         struct config_item *item)
3318 {
3319         return;
3320 }
3321
3322 static struct configfs_group_operations target_core_stat_group_ops = {
3323         .make_group             = &target_core_stat_mkdir,
3324         .drop_item              = &target_core_stat_rmdir,
3325 };
3326
3327 TB_CIT_SETUP(dev_stat, NULL, &target_core_stat_group_ops, NULL);
3328
3329 /* End functions for struct config_item_type tb_dev_stat_cit */
3330
3331 /* Start functions for struct config_item_type target_core_hba_cit */
3332
3333 static struct config_group *target_core_make_subdev(
3334         struct config_group *group,
3335         const char *name)
3336 {
3337         struct t10_alua_tg_pt_gp *tg_pt_gp;
3338         struct config_item *hba_ci = &group->cg_item;
3339         struct se_hba *hba = item_to_hba(hba_ci);
3340         struct target_backend *tb = hba->backend;
3341         struct se_device *dev;
3342         int errno = -ENOMEM, ret;
3343
3344         ret = mutex_lock_interruptible(&hba->hba_access_mutex);
3345         if (ret)
3346                 return ERR_PTR(ret);
3347
3348         dev = target_alloc_device(hba, name);
3349         if (!dev)
3350                 goto out_unlock;
3351
3352         config_group_init_type_name(&dev->dev_group, name, &tb->tb_dev_cit);
3353
3354         config_group_init_type_name(&dev->dev_action_group, "action",
3355                         &tb->tb_dev_action_cit);
3356         configfs_add_default_group(&dev->dev_action_group, &dev->dev_group);
3357
3358         config_group_init_type_name(&dev->dev_attrib.da_group, "attrib",
3359                         &tb->tb_dev_attrib_cit);
3360         configfs_add_default_group(&dev->dev_attrib.da_group, &dev->dev_group);
3361
3362         config_group_init_type_name(&dev->dev_pr_group, "pr",
3363                         &tb->tb_dev_pr_cit);
3364         configfs_add_default_group(&dev->dev_pr_group, &dev->dev_group);
3365
3366         config_group_init_type_name(&dev->t10_wwn.t10_wwn_group, "wwn",
3367                         &tb->tb_dev_wwn_cit);
3368         configfs_add_default_group(&dev->t10_wwn.t10_wwn_group,
3369                         &dev->dev_group);
3370
3371         config_group_init_type_name(&dev->t10_alua.alua_tg_pt_gps_group,
3372                         "alua", &tb->tb_dev_alua_tg_pt_gps_cit);
3373         configfs_add_default_group(&dev->t10_alua.alua_tg_pt_gps_group,
3374                         &dev->dev_group);
3375
3376         config_group_init_type_name(&dev->dev_stat_grps.stat_group,
3377                         "statistics", &tb->tb_dev_stat_cit);
3378         configfs_add_default_group(&dev->dev_stat_grps.stat_group,
3379                         &dev->dev_group);
3380
3381         /*
3382          * Add core/$HBA/$DEV/alua/default_tg_pt_gp
3383          */
3384         tg_pt_gp = core_alua_allocate_tg_pt_gp(dev, "default_tg_pt_gp", 1);
3385         if (!tg_pt_gp)
3386                 goto out_free_device;
3387         dev->t10_alua.default_tg_pt_gp = tg_pt_gp;
3388
3389         config_group_init_type_name(&tg_pt_gp->tg_pt_gp_group,
3390                         "default_tg_pt_gp", &target_core_alua_tg_pt_gp_cit);
3391         configfs_add_default_group(&tg_pt_gp->tg_pt_gp_group,
3392                         &dev->t10_alua.alua_tg_pt_gps_group);
3393
3394         /*
3395          * Add core/$HBA/$DEV/statistics/ default groups
3396          */
3397         target_stat_setup_dev_default_groups(dev);
3398
3399         mutex_lock(&target_devices_lock);
3400         target_devices++;
3401         mutex_unlock(&target_devices_lock);
3402
3403         mutex_unlock(&hba->hba_access_mutex);
3404         return &dev->dev_group;
3405
3406 out_free_device:
3407         target_free_device(dev);
3408 out_unlock:
3409         mutex_unlock(&hba->hba_access_mutex);
3410         return ERR_PTR(errno);
3411 }
3412
3413 static void target_core_drop_subdev(
3414         struct config_group *group,
3415         struct config_item *item)
3416 {
3417         struct config_group *dev_cg = to_config_group(item);
3418         struct se_device *dev =
3419                 container_of(dev_cg, struct se_device, dev_group);
3420         struct se_hba *hba;
3421
3422         hba = item_to_hba(&dev->se_hba->hba_group.cg_item);
3423
3424         mutex_lock(&hba->hba_access_mutex);
3425
3426         configfs_remove_default_groups(&dev->dev_stat_grps.stat_group);
3427         configfs_remove_default_groups(&dev->t10_alua.alua_tg_pt_gps_group);
3428
3429         /*
3430          * core_alua_free_tg_pt_gp() is called from ->default_tg_pt_gp
3431          * directly from target_core_alua_tg_pt_gp_release().
3432          */
3433         dev->t10_alua.default_tg_pt_gp = NULL;
3434
3435         configfs_remove_default_groups(dev_cg);
3436
3437         /*
3438          * se_dev is released from target_core_dev_item_ops->release()
3439          */
3440         config_item_put(item);
3441
3442         mutex_lock(&target_devices_lock);
3443         target_devices--;
3444         mutex_unlock(&target_devices_lock);
3445
3446         mutex_unlock(&hba->hba_access_mutex);
3447 }
3448
3449 static struct configfs_group_operations target_core_hba_group_ops = {
3450         .make_group             = target_core_make_subdev,
3451         .drop_item              = target_core_drop_subdev,
3452 };
3453
3454
3455 static inline struct se_hba *to_hba(struct config_item *item)
3456 {
3457         return container_of(to_config_group(item), struct se_hba, hba_group);
3458 }
3459
3460 static ssize_t target_hba_info_show(struct config_item *item, char *page)
3461 {
3462         struct se_hba *hba = to_hba(item);
3463
3464         return sprintf(page, "HBA Index: %d plugin: %s version: %s\n",
3465                         hba->hba_id, hba->backend->ops->name,
3466                         TARGET_CORE_VERSION);
3467 }
3468
3469 static ssize_t target_hba_mode_show(struct config_item *item, char *page)
3470 {
3471         struct se_hba *hba = to_hba(item);
3472         int hba_mode = 0;
3473
3474         if (hba->hba_flags & HBA_FLAGS_PSCSI_MODE)
3475                 hba_mode = 1;
3476
3477         return sprintf(page, "%d\n", hba_mode);
3478 }
3479
3480 static ssize_t target_hba_mode_store(struct config_item *item,
3481                 const char *page, size_t count)
3482 {
3483         struct se_hba *hba = to_hba(item);
3484         unsigned long mode_flag;
3485         int ret;
3486
3487         if (hba->backend->ops->pmode_enable_hba == NULL)
3488                 return -EINVAL;
3489
3490         ret = kstrtoul(page, 0, &mode_flag);
3491         if (ret < 0) {
3492                 pr_err("Unable to extract hba mode flag: %d\n", ret);
3493                 return ret;
3494         }
3495
3496         if (hba->dev_count) {
3497                 pr_err("Unable to set hba_mode with active devices\n");
3498                 return -EINVAL;
3499         }
3500
3501         ret = hba->backend->ops->pmode_enable_hba(hba, mode_flag);
3502         if (ret < 0)
3503                 return -EINVAL;
3504         if (ret > 0)
3505                 hba->hba_flags |= HBA_FLAGS_PSCSI_MODE;
3506         else if (ret == 0)
3507                 hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE;
3508
3509         return count;
3510 }
3511
3512 CONFIGFS_ATTR_RO(target_, hba_info);
3513 CONFIGFS_ATTR(target_, hba_mode);
3514
3515 static void target_core_hba_release(struct config_item *item)
3516 {
3517         struct se_hba *hba = container_of(to_config_group(item),
3518                                 struct se_hba, hba_group);
3519         core_delete_hba(hba);
3520 }
3521
3522 static struct configfs_attribute *target_core_hba_attrs[] = {
3523         &target_attr_hba_info,
3524         &target_attr_hba_mode,
3525         NULL,
3526 };
3527
3528 static struct configfs_item_operations target_core_hba_item_ops = {
3529         .release                = target_core_hba_release,
3530 };
3531
3532 static const struct config_item_type target_core_hba_cit = {
3533         .ct_item_ops            = &target_core_hba_item_ops,
3534         .ct_group_ops           = &target_core_hba_group_ops,
3535         .ct_attrs               = target_core_hba_attrs,
3536         .ct_owner               = THIS_MODULE,
3537 };
3538
3539 static struct config_group *target_core_call_addhbatotarget(
3540         struct config_group *group,
3541         const char *name)
3542 {
3543         char *se_plugin_str, *str, *str2;
3544         struct se_hba *hba;
3545         char buf[TARGET_CORE_NAME_MAX_LEN] = { };
3546         unsigned long plugin_dep_id = 0;
3547         int ret;
3548
3549         if (strlen(name) >= TARGET_CORE_NAME_MAX_LEN) {
3550                 pr_err("Passed *name strlen(): %d exceeds"
3551                         " TARGET_CORE_NAME_MAX_LEN: %d\n", (int)strlen(name),
3552                         TARGET_CORE_NAME_MAX_LEN);
3553                 return ERR_PTR(-ENAMETOOLONG);
3554         }
3555         snprintf(buf, TARGET_CORE_NAME_MAX_LEN, "%s", name);
3556
3557         str = strstr(buf, "_");
3558         if (!str) {
3559                 pr_err("Unable to locate \"_\" for $SUBSYSTEM_PLUGIN_$HOST_ID\n");
3560                 return ERR_PTR(-EINVAL);
3561         }
3562         se_plugin_str = buf;
3563         /*
3564          * Special case for subsystem plugins that have "_" in their names.
3565          * Namely rd_direct and rd_mcp..
3566          */
3567         str2 = strstr(str+1, "_");
3568         if (str2) {
3569                 *str2 = '\0'; /* Terminate for *se_plugin_str */
3570                 str2++; /* Skip to start of plugin dependent ID */
3571                 str = str2;
3572         } else {
3573                 *str = '\0'; /* Terminate for *se_plugin_str */
3574                 str++; /* Skip to start of plugin dependent ID */
3575         }
3576
3577         ret = kstrtoul(str, 0, &plugin_dep_id);
3578         if (ret < 0) {
3579                 pr_err("kstrtoul() returned %d for"
3580                                 " plugin_dep_id\n", ret);
3581                 return ERR_PTR(ret);
3582         }
3583         /*
3584          * Load up TCM subsystem plugins if they have not already been loaded.
3585          */
3586         transport_subsystem_check_init();
3587
3588         hba = core_alloc_hba(se_plugin_str, plugin_dep_id, 0);
3589         if (IS_ERR(hba))
3590                 return ERR_CAST(hba);
3591
3592         config_group_init_type_name(&hba->hba_group, name,
3593                         &target_core_hba_cit);
3594
3595         return &hba->hba_group;
3596 }
3597
3598 static void target_core_call_delhbafromtarget(
3599         struct config_group *group,
3600         struct config_item *item)
3601 {
3602         /*
3603          * core_delete_hba() is called from target_core_hba_item_ops->release()
3604          * -> target_core_hba_release()
3605          */
3606         config_item_put(item);
3607 }
3608
3609 static struct configfs_group_operations target_core_group_ops = {
3610         .make_group     = target_core_call_addhbatotarget,
3611         .drop_item      = target_core_call_delhbafromtarget,
3612 };
3613
3614 static const struct config_item_type target_core_cit = {
3615         .ct_item_ops    = NULL,
3616         .ct_group_ops   = &target_core_group_ops,
3617         .ct_attrs       = NULL,
3618         .ct_owner       = THIS_MODULE,
3619 };
3620
3621 /* Stop functions for struct config_item_type target_core_hba_cit */
3622
3623 void target_setup_backend_cits(struct target_backend *tb)
3624 {
3625         target_core_setup_dev_cit(tb);
3626         target_core_setup_dev_action_cit(tb);
3627         target_core_setup_dev_attrib_cit(tb);
3628         target_core_setup_dev_pr_cit(tb);
3629         target_core_setup_dev_wwn_cit(tb);
3630         target_core_setup_dev_alua_tg_pt_gps_cit(tb);
3631         target_core_setup_dev_stat_cit(tb);
3632 }
3633
3634 static void target_init_dbroot(void)
3635 {
3636         struct file *fp;
3637
3638         snprintf(db_root_stage, DB_ROOT_LEN, DB_ROOT_PREFERRED);
3639         fp = filp_open(db_root_stage, O_RDONLY, 0);
3640         if (IS_ERR(fp)) {
3641                 pr_err("db_root: cannot open: %s\n", db_root_stage);
3642                 return;
3643         }
3644         if (!S_ISDIR(file_inode(fp)->i_mode)) {
3645                 filp_close(fp, NULL);
3646                 pr_err("db_root: not a valid directory: %s\n", db_root_stage);
3647                 return;
3648         }
3649         filp_close(fp, NULL);
3650
3651         strncpy(db_root, db_root_stage, DB_ROOT_LEN);
3652         pr_debug("Target_Core_ConfigFS: db_root set to %s\n", db_root);
3653 }
3654
3655 static int __init target_core_init_configfs(void)
3656 {
3657         struct configfs_subsystem *subsys = &target_core_fabrics;
3658         struct t10_alua_lu_gp *lu_gp;
3659         int ret;
3660
3661         pr_debug("TARGET_CORE[0]: Loading Generic Kernel Storage"
3662                 " Engine: %s on %s/%s on "UTS_RELEASE"\n",
3663                 TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine);
3664
3665         config_group_init(&subsys->su_group);
3666         mutex_init(&subsys->su_mutex);
3667
3668         ret = init_se_kmem_caches();
3669         if (ret < 0)
3670                 return ret;
3671         /*
3672          * Create $CONFIGFS/target/core default group for HBA <-> Storage Object
3673          * and ALUA Logical Unit Group and Target Port Group infrastructure.
3674          */
3675         config_group_init_type_name(&target_core_hbagroup, "core",
3676                         &target_core_cit);
3677         configfs_add_default_group(&target_core_hbagroup, &subsys->su_group);
3678
3679         /*
3680          * Create ALUA infrastructure under /sys/kernel/config/target/core/alua/
3681          */
3682         config_group_init_type_name(&alua_group, "alua", &target_core_alua_cit);
3683         configfs_add_default_group(&alua_group, &target_core_hbagroup);
3684
3685         /*
3686          * Add ALUA Logical Unit Group and Target Port Group ConfigFS
3687          * groups under /sys/kernel/config/target/core/alua/
3688          */
3689         config_group_init_type_name(&alua_lu_gps_group, "lu_gps",
3690                         &target_core_alua_lu_gps_cit);
3691         configfs_add_default_group(&alua_lu_gps_group, &alua_group);
3692
3693         /*
3694          * Add core/alua/lu_gps/default_lu_gp
3695          */
3696         lu_gp = core_alua_allocate_lu_gp("default_lu_gp", 1);
3697         if (IS_ERR(lu_gp)) {
3698                 ret = -ENOMEM;
3699                 goto out_global;
3700         }
3701
3702         config_group_init_type_name(&lu_gp->lu_gp_group, "default_lu_gp",
3703                                 &target_core_alua_lu_gp_cit);
3704         configfs_add_default_group(&lu_gp->lu_gp_group, &alua_lu_gps_group);
3705
3706         default_lu_gp = lu_gp;
3707
3708         /*
3709          * Register the target_core_mod subsystem with configfs.
3710          */
3711         ret = configfs_register_subsystem(subsys);
3712         if (ret < 0) {
3713                 pr_err("Error %d while registering subsystem %s\n",
3714                         ret, subsys->su_group.cg_item.ci_namebuf);
3715                 goto out_global;
3716         }
3717         pr_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric"
3718                 " Infrastructure: "TARGET_CORE_VERSION" on %s/%s"
3719                 " on "UTS_RELEASE"\n", utsname()->sysname, utsname()->machine);
3720         /*
3721          * Register built-in RAMDISK subsystem logic for virtual LUN 0
3722          */
3723         ret = rd_module_init();
3724         if (ret < 0)
3725                 goto out;
3726
3727         ret = core_dev_setup_virtual_lun0();
3728         if (ret < 0)
3729                 goto out;
3730
3731         ret = target_xcopy_setup_pt();
3732         if (ret < 0)
3733                 goto out;
3734
3735         target_init_dbroot();
3736
3737         return 0;
3738
3739 out:
3740         configfs_unregister_subsystem(subsys);
3741         core_dev_release_virtual_lun0();
3742         rd_module_exit();
3743 out_global:
3744         if (default_lu_gp) {
3745                 core_alua_free_lu_gp(default_lu_gp);
3746                 default_lu_gp = NULL;
3747         }
3748         release_se_kmem_caches();
3749         return ret;
3750 }
3751
3752 static void __exit target_core_exit_configfs(void)
3753 {
3754         configfs_remove_default_groups(&alua_lu_gps_group);
3755         configfs_remove_default_groups(&alua_group);
3756         configfs_remove_default_groups(&target_core_hbagroup);
3757
3758         /*
3759          * We expect subsys->su_group.default_groups to be released
3760          * by configfs subsystem provider logic..
3761          */
3762         configfs_unregister_subsystem(&target_core_fabrics);
3763
3764         core_alua_free_lu_gp(default_lu_gp);
3765         default_lu_gp = NULL;
3766
3767         pr_debug("TARGET_CORE[0]: Released ConfigFS Fabric"
3768                         " Infrastructure\n");
3769
3770         core_dev_release_virtual_lun0();
3771         rd_module_exit();
3772         target_xcopy_release_pt();
3773         release_se_kmem_caches();
3774 }
3775
3776 MODULE_DESCRIPTION("Target_Core_Mod/ConfigFS");
3777 MODULE_AUTHOR("[email protected]");
3778 MODULE_LICENSE("GPL");
3779
3780 module_init(target_core_init_configfs);
3781 module_exit(target_core_exit_configfs);