Pileus Git - ~andy/linux/blob - drivers/target/target_core_configfs.c

   1 /*******************************************************************************
   2  * Filename:  target_core_configfs.c
   3  *
   4  * This file contains ConfigFS logic for the Generic Target Engine project.
   5  *
   6  * Copyright (c) 2008-2011 Rising Tide Systems
   7  * Copyright (c) 2008-2011 Linux-iSCSI.org
   8  *
   9  * Nicholas A. Bellinger <nab@kernel.org>
  10  *
  11  * based on configfs Copyright (C) 2005 Oracle.  All rights reserved.
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  ****************************************************************************/
  23
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <generated/utsrelease.h>
  27 #include <linux/utsname.h>
  28 #include <linux/init.h>
  29 #include <linux/fs.h>
  30 #include <linux/namei.h>
  31 #include <linux/slab.h>
  32 #include <linux/types.h>
  33 #include <linux/delay.h>
  34 #include <linux/unistd.h>
  35 #include <linux/string.h>
  36 #include <linux/parser.h>
  37 #include <linux/syscalls.h>
  38 #include <linux/configfs.h>
  39 #include <linux/spinlock.h>
  40
  41 #include <target/target_core_base.h>
  42 #include <target/target_core_device.h>
  43 #include <target/target_core_transport.h>
  44 #include <target/target_core_fabric_ops.h>
  45 #include <target/target_core_fabric_configfs.h>
  46 #include <target/target_core_configfs.h>
  47 #include <target/configfs_macros.h>
  48
  49 #include "target_core_alua.h"
  50 #include "target_core_hba.h"
  51 #include "target_core_pr.h"
  52 #include "target_core_rd.h"
  53 #include "target_core_stat.h"
  54
  55 extern struct t10_alua_lu_gp *default_lu_gp;
  56
  57 static struct list_head g_tf_list;
  58 static struct mutex g_tf_lock;
  59
  60 struct target_core_configfs_attribute {
  61         struct configfs_attribute attr;
  62         ssize_t (*show)(void *, char *);
  63         ssize_t (*store)(void *, const char *, size_t);
  64 };
  65
  66 static struct config_group target_core_hbagroup;
  67 static struct config_group alua_group;
  68 static struct config_group alua_lu_gps_group;
  69
  70 static DEFINE_SPINLOCK(se_device_lock);
  71 static LIST_HEAD(se_dev_list);
  72
  73 static inline struct se_hba *
  74 item_to_hba(struct config_item *item)
  75 {
  76         return container_of(to_config_group(item), struct se_hba, hba_group);
  77 }
  78
  79 /*
  80  * Attributes for /sys/kernel/config/target/
  81  */
  82 static ssize_t target_core_attr_show(struct config_item *item,
  83                                       struct configfs_attribute *attr,
  84                                       char *page)
  85 {
  86         return sprintf(page, "Target Engine Core ConfigFS Infrastructure %s"
  87                 " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_CONFIGFS_VERSION,
  88                 utsname()->sysname, utsname()->machine);
  89 }
  90
  91 static struct configfs_item_operations target_core_fabric_item_ops = {
  92         .show_attribute = target_core_attr_show,
  93 };
  94
  95 static struct configfs_attribute target_core_item_attr_version = {
  96         .ca_owner       = THIS_MODULE,
  97         .ca_name        = "version",
  98         .ca_mode        = S_IRUGO,
  99 };
 100
 101 static struct target_fabric_configfs *target_core_get_fabric(
 102         const char *name)
 103 {
 104         struct target_fabric_configfs *tf;
 105
 106         if (!name)
 107                 return NULL;
 108
 109         mutex_lock(&g_tf_lock);
 110         list_for_each_entry(tf, &g_tf_list, tf_list) {
 111                 if (!strcmp(tf->tf_name, name)) {
 112                         atomic_inc(&tf->tf_access_cnt);
 113                         mutex_unlock(&g_tf_lock);
 114                         return tf;
 115                 }
 116         }
 117         mutex_unlock(&g_tf_lock);
 118
 119         return NULL;
 120 }
 121
 122 /*
 123  * Called from struct target_core_group_ops->make_group()
 124  */
 125 static struct config_group *target_core_register_fabric(
 126         struct config_group *group,
 127         const char *name)
 128 {
 129         struct target_fabric_configfs *tf;
 130         int ret;
 131
 132         pr_debug("Target_Core_ConfigFS: REGISTER -> group: %p name:"
 133                         " %s\n", group, name);
 134         /*
 135          * Ensure that TCM subsystem plugins are loaded at this point for
 136          * using the RAMDISK_DR virtual LUN 0 and all other struct se_port
 137          * LUN symlinks.
 138          */
 139         if (transport_subsystem_check_init() < 0)
 140                 return ERR_PTR(-EINVAL);
 141
 142         /*
 143          * Below are some hardcoded request_module() calls to automatically
 144          * local fabric modules when the following is called:
 145          *
 146          * mkdir -p /sys/kernel/config/target/$MODULE_NAME
 147          *
 148          * Note that this does not limit which TCM fabric module can be
 149          * registered, but simply provids auto loading logic for modules with
 150          * mkdir(2) system calls with known TCM fabric modules.
 151          */
 152         if (!strncmp(name, "iscsi", 5)) {
 153                 /*
 154                  * Automatically load the LIO Target fabric module when the
 155                  * following is called:
 156                  *
 157                  * mkdir -p $CONFIGFS/target/iscsi
 158                  */
 159                 ret = request_module("iscsi_target_mod");
 160                 if (ret < 0) {
 161                         pr_err("request_module() failed for"
 162                                 " iscsi_target_mod.ko: %d\n", ret);
 163                         return ERR_PTR(-EINVAL);
 164                 }
 165         } else if (!strncmp(name, "loopback", 8)) {
 166                 /*
 167                  * Automatically load the tcm_loop fabric module when the
 168                  * following is called:
 169                  *
 170                  * mkdir -p $CONFIGFS/target/loopback
 171                  */
 172                 ret = request_module("tcm_loop");
 173                 if (ret < 0) {
 174                         pr_err("request_module() failed for"
 175                                 " tcm_loop.ko: %d\n", ret);
 176                         return ERR_PTR(-EINVAL);
 177                 }
 178         }
 179
 180         tf = target_core_get_fabric(name);
 181         if (!tf) {
 182                 pr_err("target_core_get_fabric() failed for %s\n",
 183                         name);
 184                 return ERR_PTR(-EINVAL);
 185         }
 186         pr_debug("Target_Core_ConfigFS: REGISTER -> Located fabric:"
 187                         " %s\n", tf->tf_name);
 188         /*
 189          * On a successful target_core_get_fabric() look, the returned
 190          * struct target_fabric_configfs *tf will contain a usage reference.
 191          */
 192         pr_debug("Target_Core_ConfigFS: REGISTER tfc_wwn_cit -> %p\n",
 193                         &TF_CIT_TMPL(tf)->tfc_wwn_cit);
 194
 195         tf->tf_group.default_groups = tf->tf_default_groups;
 196         tf->tf_group.default_groups[0] = &tf->tf_disc_group;
 197         tf->tf_group.default_groups[1] = NULL;
 198
 199         config_group_init_type_name(&tf->tf_group, name,
 200                         &TF_CIT_TMPL(tf)->tfc_wwn_cit);
 201         config_group_init_type_name(&tf->tf_disc_group, "discovery_auth",
 202                         &TF_CIT_TMPL(tf)->tfc_discovery_cit);
 203
 204         pr_debug("Target_Core_ConfigFS: REGISTER -> Allocated Fabric:"
 205                         " %s\n", tf->tf_group.cg_item.ci_name);
 206         /*
 207          * Setup tf_ops.tf_subsys pointer for usage with configfs_depend_item()
 208          */
 209         tf->tf_ops.tf_subsys = tf->tf_subsys;
 210         tf->tf_fabric = &tf->tf_group.cg_item;
 211         pr_debug("Target_Core_ConfigFS: REGISTER -> Set tf->tf_fabric"
 212                         " for %s\n", name);
 213
 214         return &tf->tf_group;
 215 }
 216
 217 /*
 218  * Called from struct target_core_group_ops->drop_item()
 219  */
 220 static void target_core_deregister_fabric(
 221         struct config_group *group,
 222         struct config_item *item)
 223 {
 224         struct target_fabric_configfs *tf = container_of(
 225                 to_config_group(item), struct target_fabric_configfs, tf_group);
 226         struct config_group *tf_group;
 227         struct config_item *df_item;
 228         int i;
 229
 230         pr_debug("Target_Core_ConfigFS: DEREGISTER -> Looking up %s in"
 231                 " tf list\n", config_item_name(item));
 232
 233         pr_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric:"
 234                         " %s\n", tf->tf_name);
 235         atomic_dec(&tf->tf_access_cnt);
 236
 237         pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing"
 238                         " tf->tf_fabric for %s\n", tf->tf_name);
 239         tf->tf_fabric = NULL;
 240
 241         pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci"
 242                         " %s\n", config_item_name(item));
 243
 244         tf_group = &tf->tf_group;
 245         for (i = 0; tf_group->default_groups[i]; i++) {
 246                 df_item = &tf_group->default_groups[i]->cg_item;
 247                 tf_group->default_groups[i] = NULL;
 248                 config_item_put(df_item);
 249         }
 250         config_item_put(item);
 251 }
 252
 253 static struct configfs_group_operations target_core_fabric_group_ops = {
 254         .make_group     = &target_core_register_fabric,
 255         .drop_item      = &target_core_deregister_fabric,
 256 };
 257
 258 /*
 259  * All item attributes appearing in /sys/kernel/target/ appear here.
 260  */
 261 static struct configfs_attribute *target_core_fabric_item_attrs[] = {
 262         &target_core_item_attr_version,
 263         NULL,
 264 };
 265
 266 /*
 267  * Provides Fabrics Groups and Item Attributes for /sys/kernel/config/target/
 268  */
 269 static struct config_item_type target_core_fabrics_item = {
 270         .ct_item_ops    = &target_core_fabric_item_ops,
 271         .ct_group_ops   = &target_core_fabric_group_ops,
 272         .ct_attrs       = target_core_fabric_item_attrs,
 273         .ct_owner       = THIS_MODULE,
 274 };
 275
 276 static struct configfs_subsystem target_core_fabrics = {
 277         .su_group = {
 278                 .cg_item = {
 279                         .ci_namebuf = "target",
 280                         .ci_type = &target_core_fabrics_item,
 281                 },
 282         },
 283 };
 284
 285 static struct configfs_subsystem *target_core_subsystem[] = {
 286         &target_core_fabrics,
 287         NULL,
 288 };
 289
 290 /*##############################################################################
 291 // Start functions called by external Target Fabrics Modules
 292 //############################################################################*/
 293
 294 /*
 295  * First function called by fabric modules to:
 296  *
 297  * 1) Allocate a struct target_fabric_configfs and save the *fabric_cit pointer.
 298  * 2) Add struct target_fabric_configfs to g_tf_list
 299  * 3) Return struct target_fabric_configfs to fabric module to be passed
 300  *    into target_fabric_configfs_register().
 301  */
 302 struct target_fabric_configfs *target_fabric_configfs_init(
 303         struct module *fabric_mod,
 304         const char *name)
 305 {
 306         struct target_fabric_configfs *tf;
 307
 308         if (!(name)) {
 309                 pr_err("Unable to locate passed fabric name\n");
 310                 return ERR_PTR(-EINVAL);
 311         }
 312         if (strlen(name) >= TARGET_FABRIC_NAME_SIZE) {
 313                 pr_err("Passed name: %s exceeds TARGET_FABRIC"
 314                         "_NAME_SIZE\n", name);
 315                 return ERR_PTR(-EINVAL);
 316         }
 317
 318         tf = kzalloc(sizeof(struct target_fabric_configfs), GFP_KERNEL);
 319         if (!tf)
 320                 return ERR_PTR(-ENOMEM);
 321
 322         INIT_LIST_HEAD(&tf->tf_list);
 323         atomic_set(&tf->tf_access_cnt, 0);
 324         /*
 325          * Setup the default generic struct config_item_type's (cits) in
 326          * struct target_fabric_configfs->tf_cit_tmpl
 327          */
 328         tf->tf_module = fabric_mod;
 329         target_fabric_setup_cits(tf);
 330
 331         tf->tf_subsys = target_core_subsystem[0];
 332         snprintf(tf->tf_name, TARGET_FABRIC_NAME_SIZE, "%s", name);
 333
 334         mutex_lock(&g_tf_lock);
 335         list_add_tail(&tf->tf_list, &g_tf_list);
 336         mutex_unlock(&g_tf_lock);
 337
 338         pr_debug("<<<<<<<<<<<<<<<<<<<<<< BEGIN FABRIC API >>>>>>>>"
 339                         ">>>>>>>>>>>>>>\n");
 340         pr_debug("Initialized struct target_fabric_configfs: %p for"
 341                         " %s\n", tf, tf->tf_name);
 342         return tf;
 343 }
 344 EXPORT_SYMBOL(target_fabric_configfs_init);
 345
 346 /*
 347  * Called by fabric plugins after FAILED target_fabric_configfs_register() call.
 348  */
 349 void target_fabric_configfs_free(
 350         struct target_fabric_configfs *tf)
 351 {
 352         mutex_lock(&g_tf_lock);
 353         list_del(&tf->tf_list);
 354         mutex_unlock(&g_tf_lock);
 355
 356         kfree(tf);
 357 }
 358 EXPORT_SYMBOL(target_fabric_configfs_free);
 359
 360 /*
 361  * Perform a sanity check of the passed tf->tf_ops before completing
 362  * TCM fabric module registration.
 363  */
 364 static int target_fabric_tf_ops_check(
 365         struct target_fabric_configfs *tf)
 366 {
 367         struct target_core_fabric_ops *tfo = &tf->tf_ops;
 368
 369         if (!tfo->get_fabric_name) {
 370                 pr_err("Missing tfo->get_fabric_name()\n");
 371                 return -EINVAL;
 372         }
 373         if (!tfo->get_fabric_proto_ident) {
 374                 pr_err("Missing tfo->get_fabric_proto_ident()\n");
 375                 return -EINVAL;
 376         }
 377         if (!tfo->tpg_get_wwn) {
 378                 pr_err("Missing tfo->tpg_get_wwn()\n");
 379                 return -EINVAL;
 380         }
 381         if (!tfo->tpg_get_tag) {
 382                 pr_err("Missing tfo->tpg_get_tag()\n");
 383                 return -EINVAL;
 384         }
 385         if (!tfo->tpg_get_default_depth) {
 386                 pr_err("Missing tfo->tpg_get_default_depth()\n");
 387                 return -EINVAL;
 388         }
 389         if (!tfo->tpg_get_pr_transport_id) {
 390                 pr_err("Missing tfo->tpg_get_pr_transport_id()\n");
 391                 return -EINVAL;
 392         }
 393         if (!tfo->tpg_get_pr_transport_id_len) {
 394                 pr_err("Missing tfo->tpg_get_pr_transport_id_len()\n");
 395                 return -EINVAL;
 396         }
 397         if (!tfo->tpg_check_demo_mode) {
 398                 pr_err("Missing tfo->tpg_check_demo_mode()\n");
 399                 return -EINVAL;
 400         }
 401         if (!tfo->tpg_check_demo_mode_cache) {
 402                 pr_err("Missing tfo->tpg_check_demo_mode_cache()\n");
 403                 return -EINVAL;
 404         }
 405         if (!tfo->tpg_check_demo_mode_write_protect) {
 406                 pr_err("Missing tfo->tpg_check_demo_mode_write_protect()\n");
 407                 return -EINVAL;
 408         }
 409         if (!tfo->tpg_check_prod_mode_write_protect) {
 410                 pr_err("Missing tfo->tpg_check_prod_mode_write_protect()\n");
 411                 return -EINVAL;
 412         }
 413         if (!tfo->tpg_alloc_fabric_acl) {
 414                 pr_err("Missing tfo->tpg_alloc_fabric_acl()\n");
 415                 return -EINVAL;
 416         }
 417         if (!tfo->tpg_release_fabric_acl) {
 418                 pr_err("Missing tfo->tpg_release_fabric_acl()\n");
 419                 return -EINVAL;
 420         }
 421         if (!tfo->tpg_get_inst_index) {
 422                 pr_err("Missing tfo->tpg_get_inst_index()\n");
 423                 return -EINVAL;
 424         }
 425         if (!tfo->release_cmd) {
 426                 pr_err("Missing tfo->release_cmd()\n");
 427                 return -EINVAL;
 428         }
 429         if (!tfo->shutdown_session) {
 430                 pr_err("Missing tfo->shutdown_session()\n");
 431                 return -EINVAL;
 432         }
 433         if (!tfo->close_session) {
 434                 pr_err("Missing tfo->close_session()\n");
 435                 return -EINVAL;
 436         }
 437         if (!tfo->stop_session) {
 438                 pr_err("Missing tfo->stop_session()\n");
 439                 return -EINVAL;
 440         }
 441         if (!tfo->fall_back_to_erl0) {
 442                 pr_err("Missing tfo->fall_back_to_erl0()\n");
 443                 return -EINVAL;
 444         }
 445         if (!tfo->sess_logged_in) {
 446                 pr_err("Missing tfo->sess_logged_in()\n");
 447                 return -EINVAL;
 448         }
 449         if (!tfo->sess_get_index) {
 450                 pr_err("Missing tfo->sess_get_index()\n");
 451                 return -EINVAL;
 452         }
 453         if (!tfo->write_pending) {
 454                 pr_err("Missing tfo->write_pending()\n");
 455                 return -EINVAL;
 456         }
 457         if (!tfo->write_pending_status) {
 458                 pr_err("Missing tfo->write_pending_status()\n");
 459                 return -EINVAL;
 460         }
 461         if (!tfo->set_default_node_attributes) {
 462                 pr_err("Missing tfo->set_default_node_attributes()\n");
 463                 return -EINVAL;
 464         }
 465         if (!tfo->get_task_tag) {
 466                 pr_err("Missing tfo->get_task_tag()\n");
 467                 return -EINVAL;
 468         }
 469         if (!tfo->get_cmd_state) {
 470                 pr_err("Missing tfo->get_cmd_state()\n");
 471                 return -EINVAL;
 472         }
 473         if (!tfo->queue_data_in) {
 474                 pr_err("Missing tfo->queue_data_in()\n");
 475                 return -EINVAL;
 476         }
 477         if (!tfo->queue_status) {
 478                 pr_err("Missing tfo->queue_status()\n");
 479                 return -EINVAL;
 480         }
 481         if (!tfo->queue_tm_rsp) {
 482                 pr_err("Missing tfo->queue_tm_rsp()\n");
 483                 return -EINVAL;
 484         }
 485         if (!tfo->set_fabric_sense_len) {
 486                 pr_err("Missing tfo->set_fabric_sense_len()\n");
 487                 return -EINVAL;
 488         }
 489         if (!tfo->get_fabric_sense_len) {
 490                 pr_err("Missing tfo->get_fabric_sense_len()\n");
 491                 return -EINVAL;
 492         }
 493         if (!tfo->is_state_remove) {
 494                 pr_err("Missing tfo->is_state_remove()\n");
 495                 return -EINVAL;
 496         }
 497         /*
 498          * We at least require tfo->fabric_make_wwn(), tfo->fabric_drop_wwn()
 499          * tfo->fabric_make_tpg() and tfo->fabric_drop_tpg() in
 500          * target_core_fabric_configfs.c WWN+TPG group context code.
 501          */
 502         if (!tfo->fabric_make_wwn) {
 503                 pr_err("Missing tfo->fabric_make_wwn()\n");
 504                 return -EINVAL;
 505         }
 506         if (!tfo->fabric_drop_wwn) {
 507                 pr_err("Missing tfo->fabric_drop_wwn()\n");
 508                 return -EINVAL;
 509         }
 510         if (!tfo->fabric_make_tpg) {
 511                 pr_err("Missing tfo->fabric_make_tpg()\n");
 512                 return -EINVAL;
 513         }
 514         if (!tfo->fabric_drop_tpg) {
 515                 pr_err("Missing tfo->fabric_drop_tpg()\n");
 516                 return -EINVAL;
 517         }
 518
 519         return 0;
 520 }
 521
 522 /*
 523  * Called 2nd from fabric module with returned parameter of
 524  * struct target_fabric_configfs * from target_fabric_configfs_init().
 525  *
 526  * Upon a successful registration, the new fabric's struct config_item is
 527  * return.  Also, a pointer to this struct is set in the passed
 528  * struct target_fabric_configfs.
 529  */
 530 int target_fabric_configfs_register(
 531         struct target_fabric_configfs *tf)
 532 {
 533         int ret;
 534
 535         if (!tf) {
 536                 pr_err("Unable to locate target_fabric_configfs"
 537                         " pointer\n");
 538                 return -EINVAL;
 539         }
 540         if (!tf->tf_subsys) {
 541                 pr_err("Unable to target struct config_subsystem"
 542                         " pointer\n");
 543                 return -EINVAL;
 544         }
 545         ret = target_fabric_tf_ops_check(tf);
 546         if (ret < 0)
 547                 return ret;
 548
 549         pr_debug("<<<<<<<<<<<<<<<<<<<<<< END FABRIC API >>>>>>>>>>>>"
 550                 ">>>>>>>>>>\n");
 551         return 0;
 552 }
 553 EXPORT_SYMBOL(target_fabric_configfs_register);
 554
 555 void target_fabric_configfs_deregister(
 556         struct target_fabric_configfs *tf)
 557 {
 558         struct configfs_subsystem *su;
 559
 560         if (!tf) {
 561                 pr_err("Unable to locate passed target_fabric_"
 562                         "configfs\n");
 563                 return;
 564         }
 565         su = tf->tf_subsys;
 566         if (!su) {
 567                 pr_err("Unable to locate passed tf->tf_subsys"
 568                         " pointer\n");
 569                 return;
 570         }
 571         pr_debug("<<<<<<<<<<<<<<<<<<<<<< BEGIN FABRIC API >>>>>>>>>>"
 572                         ">>>>>>>>>>>>\n");
 573         mutex_lock(&g_tf_lock);
 574         if (atomic_read(&tf->tf_access_cnt)) {
 575                 mutex_unlock(&g_tf_lock);
 576                 pr_err("Non zero tf->tf_access_cnt for fabric %s\n",
 577                         tf->tf_name);
 578                 BUG();
 579         }
 580         list_del(&tf->tf_list);
 581         mutex_unlock(&g_tf_lock);
 582
 583         pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing tf:"
 584                         " %s\n", tf->tf_name);
 585         tf->tf_module = NULL;
 586         tf->tf_subsys = NULL;
 587         kfree(tf);
 588
 589         pr_debug("<<<<<<<<<<<<<<<<<<<<<< END FABRIC API >>>>>>>>>>>>>>>>>"
 590                         ">>>>>\n");
 591 }
 592 EXPORT_SYMBOL(target_fabric_configfs_deregister);
 593
 594 /*##############################################################################
 595 // Stop functions called by external Target Fabrics Modules
 596 //############################################################################*/
 597
 598 /* Start functions for struct config_item_type target_core_dev_attrib_cit */
 599
 600 #define DEF_DEV_ATTRIB_SHOW(_name)                                      \
 601 static ssize_t target_core_dev_show_attr_##_name(                       \
 602         struct se_dev_attrib *da,                                       \
 603         char *page)                                                     \
 604 {                                                                       \
 605         struct se_device *dev;                                          \
 606         struct se_subsystem_dev *se_dev = da->da_sub_dev;                       \
 607         ssize_t rb;                                                     \
 608                                                                         \
 609         spin_lock(&se_dev->se_dev_lock);                                \
 610         dev = se_dev->se_dev_ptr;                                       \
 611         if (!dev) {                                                     \
 612                 spin_unlock(&se_dev->se_dev_lock);                      \
 613                 return -ENODEV;                                         \
 614         }                                                               \
 615         rb = snprintf(page, PAGE_SIZE, "%u\n",                          \
 616                 (u32)dev->se_sub_dev->se_dev_attrib._name);             \
 617         spin_unlock(&se_dev->se_dev_lock);                              \
 618                                                                         \
 619         return rb;                                                      \
 620 }
 621
 622 #define DEF_DEV_ATTRIB_STORE(_name)                                     \
 623 static ssize_t target_core_dev_store_attr_##_name(                      \
 624         struct se_dev_attrib *da,                                       \
 625         const char *page,                                               \
 626         size_t count)                                                   \
 627 {                                                                       \
 628         struct se_device *dev;                                          \
 629         struct se_subsystem_dev *se_dev = da->da_sub_dev;                       \
 630         unsigned long val;                                              \
 631         int ret;                                                        \
 632                                                                         \
 633         spin_lock(&se_dev->se_dev_lock);                                \
 634         dev = se_dev->se_dev_ptr;                                       \
 635         if (!dev) {                                                     \
 636                 spin_unlock(&se_dev->se_dev_lock);                      \
 637                 return -ENODEV;                                         \
 638         }                                                               \
 639         ret = strict_strtoul(page, 0, &val);                            \
 640         if (ret < 0) {                                                  \
 641                 spin_unlock(&se_dev->se_dev_lock);                      \
 642                 pr_err("strict_strtoul() failed with"           \
 643                         " ret: %d\n", ret);                             \
 644                 return -EINVAL;                                         \
 645         }                                                               \
 646         ret = se_dev_set_##_name(dev, (u32)val);                        \
 647         spin_unlock(&se_dev->se_dev_lock);                              \
 648                                                                         \
 649         return (!ret) ? count : -EINVAL;                                \
 650 }
 651
 652 #define DEF_DEV_ATTRIB(_name)                                           \
 653 DEF_DEV_ATTRIB_SHOW(_name);                                             \
 654 DEF_DEV_ATTRIB_STORE(_name);
 655
 656 #define DEF_DEV_ATTRIB_RO(_name)                                        \
 657 DEF_DEV_ATTRIB_SHOW(_name);
 658
 659 CONFIGFS_EATTR_STRUCT(target_core_dev_attrib, se_dev_attrib);
 660 #define SE_DEV_ATTR(_name, _mode)                                       \
 661 static struct target_core_dev_attrib_attribute                          \
 662                         target_core_dev_attrib_##_name =                \
 663                 __CONFIGFS_EATTR(_name, _mode,                          \
 664                 target_core_dev_show_attr_##_name,                      \
 665                 target_core_dev_store_attr_##_name);
 666
 667 #define SE_DEV_ATTR_RO(_name);                                          \
 668 static struct target_core_dev_attrib_attribute                          \
 669                         target_core_dev_attrib_##_name =                \
 670         __CONFIGFS_EATTR_RO(_name,                                      \
 671         target_core_dev_show_attr_##_name);
 672
 673 DEF_DEV_ATTRIB(emulate_dpo);
 674 SE_DEV_ATTR(emulate_dpo, S_IRUGO | S_IWUSR);
 675
 676 DEF_DEV_ATTRIB(emulate_fua_write);
 677 SE_DEV_ATTR(emulate_fua_write, S_IRUGO | S_IWUSR);
 678
 679 DEF_DEV_ATTRIB(emulate_fua_read);
 680 SE_DEV_ATTR(emulate_fua_read, S_IRUGO | S_IWUSR);
 681
 682 DEF_DEV_ATTRIB(emulate_write_cache);
 683 SE_DEV_ATTR(emulate_write_cache, S_IRUGO | S_IWUSR);
 684
 685 DEF_DEV_ATTRIB(emulate_ua_intlck_ctrl);
 686 SE_DEV_ATTR(emulate_ua_intlck_ctrl, S_IRUGO | S_IWUSR);
 687
 688 DEF_DEV_ATTRIB(emulate_tas);
 689 SE_DEV_ATTR(emulate_tas, S_IRUGO | S_IWUSR);
 690
 691 DEF_DEV_ATTRIB(emulate_tpu);
 692 SE_DEV_ATTR(emulate_tpu, S_IRUGO | S_IWUSR);
 693
 694 DEF_DEV_ATTRIB(emulate_tpws);
 695 SE_DEV_ATTR(emulate_tpws, S_IRUGO | S_IWUSR);
 696
 697 DEF_DEV_ATTRIB(enforce_pr_isids);
 698 SE_DEV_ATTR(enforce_pr_isids, S_IRUGO | S_IWUSR);
 699
 700 DEF_DEV_ATTRIB(is_nonrot);
 701 SE_DEV_ATTR(is_nonrot, S_IRUGO | S_IWUSR);
 702
 703 DEF_DEV_ATTRIB(emulate_rest_reord);
 704 SE_DEV_ATTR(emulate_rest_reord, S_IRUGO | S_IWUSR);
 705
 706 DEF_DEV_ATTRIB_RO(hw_block_size);
 707 SE_DEV_ATTR_RO(hw_block_size);
 708
 709 DEF_DEV_ATTRIB(block_size);
 710 SE_DEV_ATTR(block_size, S_IRUGO | S_IWUSR);
 711
 712 DEF_DEV_ATTRIB_RO(hw_max_sectors);
 713 SE_DEV_ATTR_RO(hw_max_sectors);
 714
 715 DEF_DEV_ATTRIB(max_sectors);
 716 SE_DEV_ATTR(max_sectors, S_IRUGO | S_IWUSR);
 717
 718 DEF_DEV_ATTRIB(optimal_sectors);
 719 SE_DEV_ATTR(optimal_sectors, S_IRUGO | S_IWUSR);
 720
 721 DEF_DEV_ATTRIB_RO(hw_queue_depth);
 722 SE_DEV_ATTR_RO(hw_queue_depth);
 723
 724 DEF_DEV_ATTRIB(queue_depth);
 725 SE_DEV_ATTR(queue_depth, S_IRUGO | S_IWUSR);
 726
 727 DEF_DEV_ATTRIB(task_timeout);
 728 SE_DEV_ATTR(task_timeout, S_IRUGO | S_IWUSR);
 729
 730 DEF_DEV_ATTRIB(max_unmap_lba_count);
 731 SE_DEV_ATTR(max_unmap_lba_count, S_IRUGO | S_IWUSR);
 732
 733 DEF_DEV_ATTRIB(max_unmap_block_desc_count);
 734 SE_DEV_ATTR(max_unmap_block_desc_count, S_IRUGO | S_IWUSR);
 735
 736 DEF_DEV_ATTRIB(unmap_granularity);
 737 SE_DEV_ATTR(unmap_granularity, S_IRUGO | S_IWUSR);
 738
 739 DEF_DEV_ATTRIB(unmap_granularity_alignment);
 740 SE_DEV_ATTR(unmap_granularity_alignment, S_IRUGO | S_IWUSR);
 741
 742 CONFIGFS_EATTR_OPS(target_core_dev_attrib, se_dev_attrib, da_group);
 743
 744 static struct configfs_attribute *target_core_dev_attrib_attrs[] = {
 745         &target_core_dev_attrib_emulate_dpo.attr,
 746         &target_core_dev_attrib_emulate_fua_write.attr,
 747         &target_core_dev_attrib_emulate_fua_read.attr,
 748         &target_core_dev_attrib_emulate_write_cache.attr,
 749         &target_core_dev_attrib_emulate_ua_intlck_ctrl.attr,
 750         &target_core_dev_attrib_emulate_tas.attr,
 751         &target_core_dev_attrib_emulate_tpu.attr,
 752         &target_core_dev_attrib_emulate_tpws.attr,
 753         &target_core_dev_attrib_enforce_pr_isids.attr,
 754         &target_core_dev_attrib_is_nonrot.attr,
 755         &target_core_dev_attrib_emulate_rest_reord.attr,
 756         &target_core_dev_attrib_hw_block_size.attr,
 757         &target_core_dev_attrib_block_size.attr,
 758         &target_core_dev_attrib_hw_max_sectors.attr,
 759         &target_core_dev_attrib_max_sectors.attr,
 760         &target_core_dev_attrib_optimal_sectors.attr,
 761         &target_core_dev_attrib_hw_queue_depth.attr,
 762         &target_core_dev_attrib_queue_depth.attr,
 763         &target_core_dev_attrib_task_timeout.attr,
 764         &target_core_dev_attrib_max_unmap_lba_count.attr,
 765         &target_core_dev_attrib_max_unmap_block_desc_count.attr,
 766         &target_core_dev_attrib_unmap_granularity.attr,
 767         &target_core_dev_attrib_unmap_granularity_alignment.attr,
 768         NULL,
 769 };
 770
 771 static struct configfs_item_operations target_core_dev_attrib_ops = {
 772         .show_attribute         = target_core_dev_attrib_attr_show,
 773         .store_attribute        = target_core_dev_attrib_attr_store,
 774 };
 775
 776 static struct config_item_type target_core_dev_attrib_cit = {
 777         .ct_item_ops            = &target_core_dev_attrib_ops,
 778         .ct_attrs               = target_core_dev_attrib_attrs,
 779         .ct_owner               = THIS_MODULE,
 780 };
 781
 782 /* End functions for struct config_item_type target_core_dev_attrib_cit */
 783
 784 /*  Start functions for struct config_item_type target_core_dev_wwn_cit */
 785
 786 CONFIGFS_EATTR_STRUCT(target_core_dev_wwn, t10_wwn);
 787 #define SE_DEV_WWN_ATTR(_name, _mode)                                   \
 788 static struct target_core_dev_wwn_attribute target_core_dev_wwn_##_name = \
 789                 __CONFIGFS_EATTR(_name, _mode,                          \
 790                 target_core_dev_wwn_show_attr_##_name,                  \
 791                 target_core_dev_wwn_store_attr_##_name);
 792
 793 #define SE_DEV_WWN_ATTR_RO(_name);                                      \
 794 do {                                                                    \
 795         static struct target_core_dev_wwn_attribute                     \
 796                         target_core_dev_wwn_##_name =                   \
 797                 __CONFIGFS_EATTR_RO(_name,                              \
 798                 target_core_dev_wwn_show_attr_##_name);                 \
 799 } while (0);
 800
 801 /*
 802  * VPD page 0x80 Unit serial
 803  */
 804 static ssize_t target_core_dev_wwn_show_attr_vpd_unit_serial(
 805         struct t10_wwn *t10_wwn,
 806         char *page)
 807 {
 808         struct se_subsystem_dev *se_dev = t10_wwn->t10_sub_dev;
 809         struct se_device *dev;
 810
 811         dev = se_dev->se_dev_ptr;
 812         if (!dev)
 813                 return -ENODEV;
 814
 815         return sprintf(page, "T10 VPD Unit Serial Number: %s\n",
 816                 &t10_wwn->unit_serial[0]);
 817 }
 818
 819 static ssize_t target_core_dev_wwn_store_attr_vpd_unit_serial(
 820         struct t10_wwn *t10_wwn,
 821         const char *page,
 822         size_t count)
 823 {
 824         struct se_subsystem_dev *su_dev = t10_wwn->t10_sub_dev;
 825         struct se_device *dev;
 826         unsigned char buf[INQUIRY_VPD_SERIAL_LEN];
 827
 828         /*
 829          * If Linux/SCSI subsystem_api_t plugin got a VPD Unit Serial
 830          * from the struct scsi_device level firmware, do not allow
 831          * VPD Unit Serial to be emulated.
 832          *
 833          * Note this struct scsi_device could also be emulating VPD
 834          * information from its drivers/scsi LLD.  But for now we assume
 835          * it is doing 'the right thing' wrt a world wide unique
 836          * VPD Unit Serial Number that OS dependent multipath can depend on.
 837          */
 838         if (su_dev->su_dev_flags & SDF_FIRMWARE_VPD_UNIT_SERIAL) {
 839                 pr_err("Underlying SCSI device firmware provided VPD"
 840                         " Unit Serial, ignoring request\n");
 841                 return -EOPNOTSUPP;
 842         }
 843
 844         if (strlen(page) >= INQUIRY_VPD_SERIAL_LEN) {
 845                 pr_err("Emulated VPD Unit Serial exceeds"
 846                 " INQUIRY_VPD_SERIAL_LEN: %d\n", INQUIRY_VPD_SERIAL_LEN);
 847                 return -EOVERFLOW;
 848         }
 849         /*
 850          * Check to see if any active $FABRIC_MOD exports exist.  If they
 851          * do exist, fail here as changing this information on the fly
 852          * (underneath the initiator side OS dependent multipath code)
 853          * could cause negative effects.
 854          */
 855         dev = su_dev->se_dev_ptr;
 856         if (dev) {
 857                 if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
 858                         pr_err("Unable to set VPD Unit Serial while"
 859                                 " active %d $FABRIC_MOD exports exist\n",
 860                                 atomic_read(&dev->dev_export_obj.obj_access_count));
 861                         return -EINVAL;
 862                 }
 863         }
 864         /*
 865          * This currently assumes ASCII encoding for emulated VPD Unit Serial.
 866          *
 867          * Also, strip any newline added from the userspace
 868          * echo $UUID > $TARGET/$HBA/$STORAGE_OBJECT/wwn/vpd_unit_serial
 869          */
 870         memset(buf, 0, INQUIRY_VPD_SERIAL_LEN);
 871         snprintf(buf, INQUIRY_VPD_SERIAL_LEN, "%s", page);
 872         snprintf(su_dev->t10_wwn.unit_serial, INQUIRY_VPD_SERIAL_LEN,
 873                         "%s", strstrip(buf));
 874         su_dev->su_dev_flags |= SDF_EMULATED_VPD_UNIT_SERIAL;
 875
 876         pr_debug("Target_Core_ConfigFS: Set emulated VPD Unit Serial:"
 877                         " %s\n", su_dev->t10_wwn.unit_serial);
 878
 879         return count;
 880 }
 881
 882 SE_DEV_WWN_ATTR(vpd_unit_serial, S_IRUGO | S_IWUSR);
 883
 884 /*
 885  * VPD page 0x83 Protocol Identifier
 886  */
 887 static ssize_t target_core_dev_wwn_show_attr_vpd_protocol_identifier(
 888         struct t10_wwn *t10_wwn,
 889         char *page)
 890 {
 891         struct se_subsystem_dev *se_dev = t10_wwn->t10_sub_dev;
 892         struct se_device *dev;
 893         struct t10_vpd *vpd;
 894         unsigned char buf[VPD_TMP_BUF_SIZE];
 895         ssize_t len = 0;
 896
 897         dev = se_dev->se_dev_ptr;
 898         if (!dev)
 899                 return -ENODEV;
 900
 901         memset(buf, 0, VPD_TMP_BUF_SIZE);
 902
 903         spin_lock(&t10_wwn->t10_vpd_lock);
 904         list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) {
 905                 if (!vpd->protocol_identifier_set)
 906                         continue;
 907
 908                 transport_dump_vpd_proto_id(vpd, buf, VPD_TMP_BUF_SIZE);
 909
 910                 if (len + strlen(buf) >= PAGE_SIZE)
 911                         break;
 912
 913                 len += sprintf(page+len, "%s", buf);
 914         }
 915         spin_unlock(&t10_wwn->t10_vpd_lock);
 916
 917         return len;
 918 }
 919
 920 static ssize_t target_core_dev_wwn_store_attr_vpd_protocol_identifier(
 921         struct t10_wwn *t10_wwn,
 922         const char *page,
 923         size_t count)
 924 {
 925         return -ENOSYS;
 926 }
 927
 928 SE_DEV_WWN_ATTR(vpd_protocol_identifier, S_IRUGO | S_IWUSR);
 929
 930 /*
 931  * Generic wrapper for dumping VPD identifiers by association.
 932  */
 933 #define DEF_DEV_WWN_ASSOC_SHOW(_name, _assoc)                           \
 934 static ssize_t target_core_dev_wwn_show_attr_##_name(                   \
 935         struct t10_wwn *t10_wwn,                                        \
 936         char *page)                                                     \
 937 {                                                                       \
 938         struct se_subsystem_dev *se_dev = t10_wwn->t10_sub_dev;         \
 939         struct se_device *dev;                                          \
 940         struct t10_vpd *vpd;                                                    \
 941         unsigned char buf[VPD_TMP_BUF_SIZE];                            \
 942         ssize_t len = 0;                                                \
 943                                                                         \
 944         dev = se_dev->se_dev_ptr;                                       \
 945         if (!dev)                                                       \
 946                 return -ENODEV;                                         \
 947                                                                         \
 948         spin_lock(&t10_wwn->t10_vpd_lock);                              \
 949         list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) {    \
 950                 if (vpd->association != _assoc)                         \
 951                         continue;                                       \
 952                                                                         \
 953                 memset(buf, 0, VPD_TMP_BUF_SIZE);                       \
 954                 transport_dump_vpd_assoc(vpd, buf, VPD_TMP_BUF_SIZE);   \
 955                 if (len + strlen(buf) >= PAGE_SIZE)                     \
 956                         break;                                          \
 957                 len += sprintf(page+len, "%s", buf);                    \
 958                                                                         \
 959                 memset(buf, 0, VPD_TMP_BUF_SIZE);                       \
 960                 transport_dump_vpd_ident_type(vpd, buf, VPD_TMP_BUF_SIZE); \
 961                 if (len + strlen(buf) >= PAGE_SIZE)                     \
 962                         break;                                          \
 963                 len += sprintf(page+len, "%s", buf);                    \
 964                                                                         \
 965                 memset(buf, 0, VPD_TMP_BUF_SIZE);                       \
 966                 transport_dump_vpd_ident(vpd, buf, VPD_TMP_BUF_SIZE); \
 967                 if (len + strlen(buf) >= PAGE_SIZE)                     \
 968                         break;                                          \
 969                 len += sprintf(page+len, "%s", buf);                    \
 970         }                                                               \
 971         spin_unlock(&t10_wwn->t10_vpd_lock);                            \
 972                                                                         \
 973         return len;                                                     \
 974 }
 975
 976 /*
 977  * VPD page 0x83 Association: Logical Unit
 978  */
 979 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_logical_unit, 0x00);
 980
 981 static ssize_t target_core_dev_wwn_store_attr_vpd_assoc_logical_unit(
 982         struct t10_wwn *t10_wwn,
 983         const char *page,
 984         size_t count)
 985 {
 986         return -ENOSYS;
 987 }
 988
 989 SE_DEV_WWN_ATTR(vpd_assoc_logical_unit, S_IRUGO | S_IWUSR);
 990
 991 /*
 992  * VPD page 0x83 Association: Target Port
 993  */
 994 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_target_port, 0x10);
 995
 996 static ssize_t target_core_dev_wwn_store_attr_vpd_assoc_target_port(
 997         struct t10_wwn *t10_wwn,
 998         const char *page,
 999         size_t count)
1000 {
1001         return -ENOSYS;
1002 }
1003
1004 SE_DEV_WWN_ATTR(vpd_assoc_target_port, S_IRUGO | S_IWUSR);
1005
1006 /*
1007  * VPD page 0x83 Association: SCSI Target Device
1008  */
1009 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_scsi_target_device, 0x20);
1010
1011 static ssize_t target_core_dev_wwn_store_attr_vpd_assoc_scsi_target_device(
1012         struct t10_wwn *t10_wwn,
1013         const char *page,
1014         size_t count)
1015 {
1016         return -ENOSYS;
1017 }
1018
1019 SE_DEV_WWN_ATTR(vpd_assoc_scsi_target_device, S_IRUGO | S_IWUSR);
1020
1021 CONFIGFS_EATTR_OPS(target_core_dev_wwn, t10_wwn, t10_wwn_group);
1022
1023 static struct configfs_attribute *target_core_dev_wwn_attrs[] = {
1024         &target_core_dev_wwn_vpd_unit_serial.attr,
1025         &target_core_dev_wwn_vpd_protocol_identifier.attr,
1026         &target_core_dev_wwn_vpd_assoc_logical_unit.attr,
1027         &target_core_dev_wwn_vpd_assoc_target_port.attr,
1028         &target_core_dev_wwn_vpd_assoc_scsi_target_device.attr,
1029         NULL,
1030 };
1031
1032 static struct configfs_item_operations target_core_dev_wwn_ops = {
1033         .show_attribute         = target_core_dev_wwn_attr_show,
1034         .store_attribute        = target_core_dev_wwn_attr_store,
1035 };
1036
1037 static struct config_item_type target_core_dev_wwn_cit = {
1038         .ct_item_ops            = &target_core_dev_wwn_ops,
1039         .ct_attrs               = target_core_dev_wwn_attrs,
1040         .ct_owner               = THIS_MODULE,
1041 };
1042
1043 /*  End functions for struct config_item_type target_core_dev_wwn_cit */
1044
1045 /*  Start functions for struct config_item_type target_core_dev_pr_cit */
1046
1047 CONFIGFS_EATTR_STRUCT(target_core_dev_pr, se_subsystem_dev);
1048 #define SE_DEV_PR_ATTR(_name, _mode)                                    \
1049 static struct target_core_dev_pr_attribute target_core_dev_pr_##_name = \
1050         __CONFIGFS_EATTR(_name, _mode,                                  \
1051         target_core_dev_pr_show_attr_##_name,                           \
1052         target_core_dev_pr_store_attr_##_name);
1053
1054 #define SE_DEV_PR_ATTR_RO(_name);                                       \
1055 static struct target_core_dev_pr_attribute target_core_dev_pr_##_name = \
1056         __CONFIGFS_EATTR_RO(_name,                                      \
1057         target_core_dev_pr_show_attr_##_name);
1058
1059 /*
1060  * res_holder
1061  */
1062 static ssize_t target_core_dev_pr_show_spc3_res(
1063         struct se_device *dev,
1064         char *page,
1065         ssize_t *len)
1066 {
1067         struct se_node_acl *se_nacl;
1068         struct t10_pr_registration *pr_reg;
1069         char i_buf[PR_REG_ISID_ID_LEN];
1070         int prf_isid;
1071
1072         memset(i_buf, 0, PR_REG_ISID_ID_LEN);
1073
1074         spin_lock(&dev->dev_reservation_lock);
1075         pr_reg = dev->dev_pr_res_holder;
1076         if (!pr_reg) {
1077                 *len += sprintf(page + *len, "No SPC-3 Reservation holder\n");
1078                 spin_unlock(&dev->dev_reservation_lock);
1079                 return *len;
1080         }
1081         se_nacl = pr_reg->pr_reg_nacl;
1082         prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0],
1083                                 PR_REG_ISID_ID_LEN);
1084
1085         *len += sprintf(page + *len, "SPC-3 Reservation: %s Initiator: %s%s\n",
1086                 se_nacl->se_tpg->se_tpg_tfo->get_fabric_name(),
1087                 se_nacl->initiatorname, (prf_isid) ? &i_buf[0] : "");
1088         spin_unlock(&dev->dev_reservation_lock);
1089
1090         return *len;
1091 }
1092
1093 static ssize_t target_core_dev_pr_show_spc2_res(
1094         struct se_device *dev,
1095         char *page,
1096         ssize_t *len)
1097 {
1098         struct se_node_acl *se_nacl;
1099
1100         spin_lock(&dev->dev_reservation_lock);
1101         se_nacl = dev->dev_reserved_node_acl;
1102         if (!se_nacl) {
1103                 *len += sprintf(page + *len, "No SPC-2 Reservation holder\n");
1104                 spin_unlock(&dev->dev_reservation_lock);
1105                 return *len;
1106         }
1107         *len += sprintf(page + *len, "SPC-2 Reservation: %s Initiator: %s\n",
1108                 se_nacl->se_tpg->se_tpg_tfo->get_fabric_name(),
1109                 se_nacl->initiatorname);
1110         spin_unlock(&dev->dev_reservation_lock);
1111
1112         return *len;
1113 }
1114
1115 static ssize_t target_core_dev_pr_show_attr_res_holder(
1116         struct se_subsystem_dev *su_dev,
1117         char *page)
1118 {
1119         ssize_t len = 0;
1120
1121         if (!su_dev->se_dev_ptr)
1122                 return -ENODEV;
1123
1124         switch (su_dev->t10_pr.res_type) {
1125         case SPC3_PERSISTENT_RESERVATIONS:
1126                 target_core_dev_pr_show_spc3_res(su_dev->se_dev_ptr,
1127                                 page, &len);
1128                 break;
1129         case SPC2_RESERVATIONS:
1130                 target_core_dev_pr_show_spc2_res(su_dev->se_dev_ptr,
1131                                 page, &len);
1132                 break;
1133         case SPC_PASSTHROUGH:
1134                 len += sprintf(page+len, "Passthrough\n");
1135                 break;
1136         default:
1137                 len += sprintf(page+len, "Unknown\n");
1138                 break;
1139         }
1140
1141         return len;
1142 }
1143
1144 SE_DEV_PR_ATTR_RO(res_holder);
1145
1146 /*
1147  * res_pr_all_tgt_pts
1148  */
1149 static ssize_t target_core_dev_pr_show_attr_res_pr_all_tgt_pts(
1150         struct se_subsystem_dev *su_dev,
1151         char *page)
1152 {
1153         struct se_device *dev;
1154         struct t10_pr_registration *pr_reg;
1155         ssize_t len = 0;
1156
1157         dev = su_dev->se_dev_ptr;
1158         if (!dev)
1159                 return -ENODEV;
1160
1161         if (su_dev->t10_pr.res_type != SPC3_PERSISTENT_RESERVATIONS)
1162                 return len;
1163
1164         spin_lock(&dev->dev_reservation_lock);
1165         pr_reg = dev->dev_pr_res_holder;
1166         if (!pr_reg) {
1167                 len = sprintf(page, "No SPC-3 Reservation holder\n");
1168                 spin_unlock(&dev->dev_reservation_lock);
1169                 return len;
1170         }
1171         /*
1172          * See All Target Ports (ALL_TG_PT) bit in spcr17, section 6.14.3
1173          * Basic PERSISTENT RESERVER OUT parameter list, page 290
1174          */
1175         if (pr_reg->pr_reg_all_tg_pt)
1176                 len = sprintf(page, "SPC-3 Reservation: All Target"
1177                         " Ports registration\n");
1178         else
1179                 len = sprintf(page, "SPC-3 Reservation: Single"
1180                         " Target Port registration\n");
1181         spin_unlock(&dev->dev_reservation_lock);
1182
1183         return len;
1184 }
1185
1186 SE_DEV_PR_ATTR_RO(res_pr_all_tgt_pts);
1187
1188 /*
1189  * res_pr_generation
1190  */
1191 static ssize_t target_core_dev_pr_show_attr_res_pr_generation(
1192         struct se_subsystem_dev *su_dev,
1193         char *page)
1194 {
1195         if (!su_dev->se_dev_ptr)
1196                 return -ENODEV;
1197
1198         if (su_dev->t10_pr.res_type != SPC3_PERSISTENT_RESERVATIONS)
1199                 return 0;
1200
1201         return sprintf(page, "0x%08x\n", su_dev->t10_pr.pr_generation);
1202 }
1203
1204 SE_DEV_PR_ATTR_RO(res_pr_generation);
1205
1206 /*
1207  * res_pr_holder_tg_port
1208  */
1209 static ssize_t target_core_dev_pr_show_attr_res_pr_holder_tg_port(
1210         struct se_subsystem_dev *su_dev,
1211         char *page)
1212 {
1213         struct se_device *dev;
1214         struct se_node_acl *se_nacl;
1215         struct se_lun *lun;
1216         struct se_portal_group *se_tpg;
1217         struct t10_pr_registration *pr_reg;
1218         struct target_core_fabric_ops *tfo;
1219         ssize_t len = 0;
1220
1221         dev = su_dev->se_dev_ptr;
1222         if (!dev)
1223                 return -ENODEV;
1224
1225         if (su_dev->t10_pr.res_type != SPC3_PERSISTENT_RESERVATIONS)
1226                 return len;
1227
1228         spin_lock(&dev->dev_reservation_lock);
1229         pr_reg = dev->dev_pr_res_holder;
1230         if (!pr_reg) {
1231                 len = sprintf(page, "No SPC-3 Reservation holder\n");
1232                 spin_unlock(&dev->dev_reservation_lock);
1233                 return len;
1234         }
1235         se_nacl = pr_reg->pr_reg_nacl;
1236         se_tpg = se_nacl->se_tpg;
1237         lun = pr_reg->pr_reg_tg_pt_lun;
1238         tfo = se_tpg->se_tpg_tfo;
1239
1240         len += sprintf(page+len, "SPC-3 Reservation: %s"
1241                 " Target Node Endpoint: %s\n", tfo->get_fabric_name(),
1242                 tfo->tpg_get_wwn(se_tpg));
1243         len += sprintf(page+len, "SPC-3 Reservation: Relative Port"
1244                 " Identifer Tag: %hu %s Portal Group Tag: %hu"
1245                 " %s Logical Unit: %u\n", lun->lun_sep->sep_rtpi,
1246                 tfo->get_fabric_name(), tfo->tpg_get_tag(se_tpg),
1247                 tfo->get_fabric_name(), lun->unpacked_lun);
1248         spin_unlock(&dev->dev_reservation_lock);
1249
1250         return len;
1251 }
1252
1253 SE_DEV_PR_ATTR_RO(res_pr_holder_tg_port);
1254
1255 /*
1256  * res_pr_registered_i_pts
1257  */
1258 static ssize_t target_core_dev_pr_show_attr_res_pr_registered_i_pts(
1259         struct se_subsystem_dev *su_dev,
1260         char *page)
1261 {
1262         struct target_core_fabric_ops *tfo;
1263         struct t10_pr_registration *pr_reg;
1264         unsigned char buf[384];
1265         char i_buf[PR_REG_ISID_ID_LEN];
1266         ssize_t len = 0;
1267         int reg_count = 0, prf_isid;
1268
1269         if (!su_dev->se_dev_ptr)
1270                 return -ENODEV;
1271
1272         if (su_dev->t10_pr.res_type != SPC3_PERSISTENT_RESERVATIONS)
1273                 return len;
1274
1275         len += sprintf(page+len, "SPC-3 PR Registrations:\n");
1276
1277         spin_lock(&su_dev->t10_pr.registration_lock);
1278         list_for_each_entry(pr_reg, &su_dev->t10_pr.registration_list,
1279                         pr_reg_list) {
1280
1281                 memset(buf, 0, 384);
1282                 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
1283                 tfo = pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
1284                 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0],
1285                                         PR_REG_ISID_ID_LEN);
1286                 sprintf(buf, "%s Node: %s%s Key: 0x%016Lx PRgen: 0x%08x\n",
1287                         tfo->get_fabric_name(),
1288                         pr_reg->pr_reg_nacl->initiatorname, (prf_isid) ?
1289                         &i_buf[0] : "", pr_reg->pr_res_key,
1290                         pr_reg->pr_res_generation);
1291
1292                 if (len + strlen(buf) >= PAGE_SIZE)
1293                         break;
1294
1295                 len += sprintf(page+len, "%s", buf);
1296                 reg_count++;
1297         }
1298         spin_unlock(&su_dev->t10_pr.registration_lock);
1299
1300         if (!reg_count)
1301                 len += sprintf(page+len, "None\n");
1302
1303         return len;
1304 }
1305
1306 SE_DEV_PR_ATTR_RO(res_pr_registered_i_pts);
1307
1308 /*
1309  * res_pr_type
1310  */
1311 static ssize_t target_core_dev_pr_show_attr_res_pr_type(
1312         struct se_subsystem_dev *su_dev,
1313         char *page)
1314 {
1315         struct se_device *dev;
1316         struct t10_pr_registration *pr_reg;
1317         ssize_t len = 0;
1318
1319         dev = su_dev->se_dev_ptr;
1320         if (!dev)
1321                 return -ENODEV;
1322
1323         if (su_dev->t10_pr.res_type != SPC3_PERSISTENT_RESERVATIONS)
1324                 return len;
1325
1326         spin_lock(&dev->dev_reservation_lock);
1327         pr_reg = dev->dev_pr_res_holder;
1328         if (!pr_reg) {
1329                 len = sprintf(page, "No SPC-3 Reservation holder\n");
1330                 spin_unlock(&dev->dev_reservation_lock);
1331                 return len;
1332         }
1333         len = sprintf(page, "SPC-3 Reservation Type: %s\n",
1334                 core_scsi3_pr_dump_type(pr_reg->pr_res_type));
1335         spin_unlock(&dev->dev_reservation_lock);
1336
1337         return len;
1338 }
1339
1340 SE_DEV_PR_ATTR_RO(res_pr_type);
1341
1342 /*
1343  * res_type
1344  */
1345 static ssize_t target_core_dev_pr_show_attr_res_type(
1346         struct se_subsystem_dev *su_dev,
1347         char *page)
1348 {
1349         ssize_t len = 0;
1350
1351         if (!su_dev->se_dev_ptr)
1352                 return -ENODEV;
1353
1354         switch (su_dev->t10_pr.res_type) {
1355         case SPC3_PERSISTENT_RESERVATIONS:
1356                 len = sprintf(page, "SPC3_PERSISTENT_RESERVATIONS\n");
1357                 break;
1358         case SPC2_RESERVATIONS:
1359                 len = sprintf(page, "SPC2_RESERVATIONS\n");
1360                 break;
1361         case SPC_PASSTHROUGH:
1362                 len = sprintf(page, "SPC_PASSTHROUGH\n");
1363                 break;
1364         default:
1365                 len = sprintf(page, "UNKNOWN\n");
1366                 break;
1367         }
1368
1369         return len;
1370 }
1371
1372 SE_DEV_PR_ATTR_RO(res_type);
1373
1374 /*
1375  * res_aptpl_active
1376  */
1377
1378 static ssize_t target_core_dev_pr_show_attr_res_aptpl_active(
1379         struct se_subsystem_dev *su_dev,
1380         char *page)
1381 {
1382         if (!su_dev->se_dev_ptr)
1383                 return -ENODEV;
1384
1385         if (su_dev->t10_pr.res_type != SPC3_PERSISTENT_RESERVATIONS)
1386                 return 0;
1387
1388         return sprintf(page, "APTPL Bit Status: %s\n",
1389                 (su_dev->t10_pr.pr_aptpl_active) ? "Activated" : "Disabled");
1390 }
1391
1392 SE_DEV_PR_ATTR_RO(res_aptpl_active);
1393
1394 /*
1395  * res_aptpl_metadata
1396  */
1397 static ssize_t target_core_dev_pr_show_attr_res_aptpl_metadata(
1398         struct se_subsystem_dev *su_dev,
1399         char *page)
1400 {
1401         if (!su_dev->se_dev_ptr)
1402                 return -ENODEV;
1403
1404         if (su_dev->t10_pr.res_type != SPC3_PERSISTENT_RESERVATIONS)
1405                 return 0;
1406
1407         return sprintf(page, "Ready to process PR APTPL metadata..\n");
1408 }
1409
1410 enum {
1411         Opt_initiator_fabric, Opt_initiator_node, Opt_initiator_sid,
1412         Opt_sa_res_key, Opt_res_holder, Opt_res_type, Opt_res_scope,
1413         Opt_res_all_tg_pt, Opt_mapped_lun, Opt_target_fabric,
1414         Opt_target_node, Opt_tpgt, Opt_port_rtpi, Opt_target_lun, Opt_err
1415 };
1416
1417 static match_table_t tokens = {
1418         {Opt_initiator_fabric, "initiator_fabric=%s"},
1419         {Opt_initiator_node, "initiator_node=%s"},
1420         {Opt_initiator_sid, "initiator_sid=%s"},
1421         {Opt_sa_res_key, "sa_res_key=%s"},
1422         {Opt_res_holder, "res_holder=%d"},
1423         {Opt_res_type, "res_type=%d"},
1424         {Opt_res_scope, "res_scope=%d"},
1425         {Opt_res_all_tg_pt, "res_all_tg_pt=%d"},
1426         {Opt_mapped_lun, "mapped_lun=%d"},
1427         {Opt_target_fabric, "target_fabric=%s"},
1428         {Opt_target_node, "target_node=%s"},
1429         {Opt_tpgt, "tpgt=%d"},
1430         {Opt_port_rtpi, "port_rtpi=%d"},
1431         {Opt_target_lun, "target_lun=%d"},
1432         {Opt_err, NULL}
1433 };
1434
1435 static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
1436         struct se_subsystem_dev *su_dev,
1437         const char *page,
1438         size_t count)
1439 {
1440         struct se_device *dev;
1441         unsigned char *i_fabric = NULL, *i_port = NULL, *isid = NULL;
1442         unsigned char *t_fabric = NULL, *t_port = NULL;
1443         char *orig, *ptr, *arg_p, *opts;
1444         substring_t args[MAX_OPT_ARGS];
1445         unsigned long long tmp_ll;
1446         u64 sa_res_key = 0;
1447         u32 mapped_lun = 0, target_lun = 0;
1448         int ret = -1, res_holder = 0, all_tg_pt = 0, arg, token;
1449         u16 port_rpti = 0, tpgt = 0;
1450         u8 type = 0, scope;
1451
1452         dev = su_dev->se_dev_ptr;
1453         if (!dev)
1454                 return -ENODEV;
1455
1456         if (su_dev->t10_pr.res_type != SPC3_PERSISTENT_RESERVATIONS)
1457                 return 0;
1458
1459         if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1460                 pr_debug("Unable to process APTPL metadata while"
1461                         " active fabric exports exist\n");
1462                 return -EINVAL;
1463         }
1464
1465         opts = kstrdup(page, GFP_KERNEL);
1466         if (!opts)
1467                 return -ENOMEM;
1468
1469         orig = opts;
1470         while ((ptr = strsep(&opts, ",")) != NULL) {
1471                 if (!*ptr)
1472                         continue;
1473
1474                 token = match_token(ptr, tokens, args);
1475                 switch (token) {
1476                 case Opt_initiator_fabric:
1477                         i_fabric = match_strdup(&args[0]);
1478                         if (!i_fabric) {
1479                                 ret = -ENOMEM;
1480                                 goto out;
1481                         }
1482                         break;
1483                 case Opt_initiator_node:
1484                         i_port = match_strdup(&args[0]);
1485                         if (!i_port) {
1486                                 ret = -ENOMEM;
1487                                 goto out;
1488                         }
1489                         if (strlen(i_port) >= PR_APTPL_MAX_IPORT_LEN) {
1490                                 pr_err("APTPL metadata initiator_node="
1491                                         " exceeds PR_APTPL_MAX_IPORT_LEN: %d\n",
1492                                         PR_APTPL_MAX_IPORT_LEN);
1493                                 ret = -EINVAL;
1494                                 break;
1495                         }
1496                         break;
1497                 case Opt_initiator_sid:
1498                         isid = match_strdup(&args[0]);
1499                         if (!isid) {
1500                                 ret = -ENOMEM;
1501                                 goto out;
1502                         }
1503                         if (strlen(isid) >= PR_REG_ISID_LEN) {
1504                                 pr_err("APTPL metadata initiator_isid"
1505                                         "= exceeds PR_REG_ISID_LEN: %d\n",
1506                                         PR_REG_ISID_LEN);
1507                                 ret = -EINVAL;
1508                                 break;
1509                         }
1510                         break;
1511                 case Opt_sa_res_key:
1512                         arg_p = match_strdup(&args[0]);
1513                         if (!arg_p) {
1514                                 ret = -ENOMEM;
1515                                 goto out;
1516                         }
1517                         ret = strict_strtoull(arg_p, 0, &tmp_ll);
1518                         if (ret < 0) {
1519                                 pr_err("strict_strtoull() failed for"
1520                                         " sa_res_key=\n");
1521                                 goto out;
1522                         }
1523                         sa_res_key = (u64)tmp_ll;
1524                         break;
1525                 /*
1526                  * PR APTPL Metadata for Reservation
1527                  */
1528                 case Opt_res_holder:
1529                         match_int(args, &arg);
1530                         res_holder = arg;
1531                         break;
1532                 case Opt_res_type:
1533                         match_int(args, &arg);
1534                         type = (u8)arg;
1535                         break;
1536                 case Opt_res_scope:
1537                         match_int(args, &arg);
1538                         scope = (u8)arg;
1539                         break;
1540                 case Opt_res_all_tg_pt:
1541                         match_int(args, &arg);
1542                         all_tg_pt = (int)arg;
1543                         break;
1544                 case Opt_mapped_lun:
1545                         match_int(args, &arg);
1546                         mapped_lun = (u32)arg;
1547                         break;
1548                 /*
1549                  * PR APTPL Metadata for Target Port
1550                  */
1551                 case Opt_target_fabric:
1552                         t_fabric = match_strdup(&args[0]);
1553                         if (!t_fabric) {
1554                                 ret = -ENOMEM;
1555                                 goto out;
1556                         }
1557                         break;
1558                 case Opt_target_node:
1559                         t_port = match_strdup(&args[0]);
1560                         if (!t_port) {
1561                                 ret = -ENOMEM;
1562                                 goto out;
1563                         }
1564                         if (strlen(t_port) >= PR_APTPL_MAX_TPORT_LEN) {
1565                                 pr_err("APTPL metadata target_node="
1566                                         " exceeds PR_APTPL_MAX_TPORT_LEN: %d\n",
1567                                         PR_APTPL_MAX_TPORT_LEN);
1568                                 ret = -EINVAL;
1569                                 break;
1570                         }
1571                         break;
1572                 case Opt_tpgt:
1573                         match_int(args, &arg);
1574                         tpgt = (u16)arg;
1575                         break;
1576                 case Opt_port_rtpi:
1577                         match_int(args, &arg);
1578                         port_rpti = (u16)arg;
1579                         break;
1580                 case Opt_target_lun:
1581                         match_int(args, &arg);
1582                         target_lun = (u32)arg;
1583                         break;
1584                 default:
1585                         break;
1586                 }
1587         }
1588
1589         if (!i_port || !t_port || !sa_res_key) {
1590                 pr_err("Illegal parameters for APTPL registration\n");
1591                 ret = -EINVAL;
1592                 goto out;
1593         }
1594
1595         if (res_holder && !(type)) {
1596                 pr_err("Illegal PR type: 0x%02x for reservation"
1597                                 " holder\n", type);
1598                 ret = -EINVAL;
1599                 goto out;
1600         }
1601
1602         ret = core_scsi3_alloc_aptpl_registration(&su_dev->t10_pr, sa_res_key,
1603                         i_port, isid, mapped_lun, t_port, tpgt, target_lun,
1604                         res_holder, all_tg_pt, type);
1605 out:
1606         kfree(i_fabric);
1607         kfree(i_port);
1608         kfree(isid);
1609         kfree(t_fabric);
1610         kfree(t_port);
1611         kfree(orig);
1612         return (ret == 0) ? count : ret;
1613 }
1614
1615 SE_DEV_PR_ATTR(res_aptpl_metadata, S_IRUGO | S_IWUSR);
1616
1617 CONFIGFS_EATTR_OPS(target_core_dev_pr, se_subsystem_dev, se_dev_pr_group);
1618
1619 static struct configfs_attribute *target_core_dev_pr_attrs[] = {
1620         &target_core_dev_pr_res_holder.attr,
1621         &target_core_dev_pr_res_pr_all_tgt_pts.attr,
1622         &target_core_dev_pr_res_pr_generation.attr,
1623         &target_core_dev_pr_res_pr_holder_tg_port.attr,
1624         &target_core_dev_pr_res_pr_registered_i_pts.attr,
1625         &target_core_dev_pr_res_pr_type.attr,
1626         &target_core_dev_pr_res_type.attr,
1627         &target_core_dev_pr_res_aptpl_active.attr,
1628         &target_core_dev_pr_res_aptpl_metadata.attr,
1629         NULL,
1630 };
1631
1632 static struct configfs_item_operations target_core_dev_pr_ops = {
1633         .show_attribute         = target_core_dev_pr_attr_show,
1634         .store_attribute        = target_core_dev_pr_attr_store,
1635 };
1636
1637 static struct config_item_type target_core_dev_pr_cit = {
1638         .ct_item_ops            = &target_core_dev_pr_ops,
1639         .ct_attrs               = target_core_dev_pr_attrs,
1640         .ct_owner               = THIS_MODULE,
1641 };
1642
1643 /*  End functions for struct config_item_type target_core_dev_pr_cit */
1644
1645 /*  Start functions for struct config_item_type target_core_dev_cit */
1646
1647 static ssize_t target_core_show_dev_info(void *p, char *page)
1648 {
1649         struct se_subsystem_dev *se_dev = (struct se_subsystem_dev *)p;
1650         struct se_hba *hba = se_dev->se_dev_hba;
1651         struct se_subsystem_api *t = hba->transport;
1652         int bl = 0;
1653         ssize_t read_bytes = 0;
1654
1655         if (!se_dev->se_dev_ptr)
1656                 return -ENODEV;
1657
1658         transport_dump_dev_state(se_dev->se_dev_ptr, page, &bl);
1659         read_bytes += bl;
1660         read_bytes += t->show_configfs_dev_params(hba, se_dev, page+read_bytes);
1661         return read_bytes;
1662 }
1663
1664 static struct target_core_configfs_attribute target_core_attr_dev_info = {
1665         .attr   = { .ca_owner = THIS_MODULE,
1666                     .ca_name = "info",
1667                     .ca_mode = S_IRUGO },
1668         .show   = target_core_show_dev_info,
1669         .store  = NULL,
1670 };
1671
1672 static ssize_t target_core_store_dev_control(
1673         void *p,
1674         const char *page,
1675         size_t count)
1676 {
1677         struct se_subsystem_dev *se_dev = (struct se_subsystem_dev *)p;
1678         struct se_hba *hba = se_dev->se_dev_hba;
1679         struct se_subsystem_api *t = hba->transport;
1680
1681         if (!se_dev->se_dev_su_ptr) {
1682                 pr_err("Unable to locate struct se_subsystem_dev>se"
1683                                 "_dev_su_ptr\n");
1684                 return -EINVAL;
1685         }
1686
1687         return t->set_configfs_dev_params(hba, se_dev, page, count);
1688 }
1689
1690 static struct target_core_configfs_attribute target_core_attr_dev_control = {
1691         .attr   = { .ca_owner = THIS_MODULE,
1692                     .ca_name = "control",
1693                     .ca_mode = S_IWUSR },
1694         .show   = NULL,
1695         .store  = target_core_store_dev_control,
1696 };
1697
1698 static ssize_t target_core_show_dev_alias(void *p, char *page)
1699 {
1700         struct se_subsystem_dev *se_dev = (struct se_subsystem_dev *)p;
1701
1702         if (!(se_dev->su_dev_flags & SDF_USING_ALIAS))
1703                 return 0;
1704
1705         return snprintf(page, PAGE_SIZE, "%s\n", se_dev->se_dev_alias);
1706 }
1707
1708 static ssize_t target_core_store_dev_alias(
1709         void *p,
1710         const char *page,
1711         size_t count)
1712 {
1713         struct se_subsystem_dev *se_dev = (struct se_subsystem_dev *)p;
1714         struct se_hba *hba = se_dev->se_dev_hba;
1715         ssize_t read_bytes;
1716
1717         if (count > (SE_DEV_ALIAS_LEN-1)) {
1718                 pr_err("alias count: %d exceeds"
1719                         " SE_DEV_ALIAS_LEN-1: %u\n", (int)count,
1720                         SE_DEV_ALIAS_LEN-1);
1721                 return -EINVAL;
1722         }
1723
1724         se_dev->su_dev_flags |= SDF_USING_ALIAS;
1725         read_bytes = snprintf(&se_dev->se_dev_alias[0], SE_DEV_ALIAS_LEN,
1726                         "%s", page);
1727
1728         pr_debug("Target_Core_ConfigFS: %s/%s set alias: %s\n",
1729                 config_item_name(&hba->hba_group.cg_item),
1730                 config_item_name(&se_dev->se_dev_group.cg_item),
1731                 se_dev->se_dev_alias);
1732
1733         return read_bytes;
1734 }
1735
1736 static struct target_core_configfs_attribute target_core_attr_dev_alias = {
1737         .attr   = { .ca_owner = THIS_MODULE,
1738                     .ca_name = "alias",
1739                     .ca_mode =  S_IRUGO | S_IWUSR },
1740         .show   = target_core_show_dev_alias,
1741         .store  = target_core_store_dev_alias,
1742 };
1743
1744 static ssize_t target_core_show_dev_udev_path(void *p, char *page)
1745 {
1746         struct se_subsystem_dev *se_dev = (struct se_subsystem_dev *)p;
1747
1748         if (!(se_dev->su_dev_flags & SDF_USING_UDEV_PATH))
1749                 return 0;
1750
1751         return snprintf(page, PAGE_SIZE, "%s\n", se_dev->se_dev_udev_path);
1752 }
1753
1754 static ssize_t target_core_store_dev_udev_path(
1755         void *p,
1756         const char *page,
1757         size_t count)
1758 {
1759         struct se_subsystem_dev *se_dev = (struct se_subsystem_dev *)p;
1760         struct se_hba *hba = se_dev->se_dev_hba;
1761         ssize_t read_bytes;
1762
1763         if (count > (SE_UDEV_PATH_LEN-1)) {
1764                 pr_err("udev_path count: %d exceeds"
1765                         " SE_UDEV_PATH_LEN-1: %u\n", (int)count,
1766                         SE_UDEV_PATH_LEN-1);
1767                 return -EINVAL;
1768         }
1769
1770         se_dev->su_dev_flags |= SDF_USING_UDEV_PATH;
1771         read_bytes = snprintf(&se_dev->se_dev_udev_path[0], SE_UDEV_PATH_LEN,
1772                         "%s", page);
1773
1774         pr_debug("Target_Core_ConfigFS: %s/%s set udev_path: %s\n",
1775                 config_item_name(&hba->hba_group.cg_item),
1776                 config_item_name(&se_dev->se_dev_group.cg_item),
1777                 se_dev->se_dev_udev_path);
1778
1779         return read_bytes;
1780 }
1781
1782 static struct target_core_configfs_attribute target_core_attr_dev_udev_path = {
1783         .attr   = { .ca_owner = THIS_MODULE,
1784                     .ca_name = "udev_path",
1785                     .ca_mode =  S_IRUGO | S_IWUSR },
1786         .show   = target_core_show_dev_udev_path,
1787         .store  = target_core_store_dev_udev_path,
1788 };
1789
1790 static ssize_t target_core_store_dev_enable(
1791         void *p,
1792         const char *page,
1793         size_t count)
1794 {
1795         struct se_subsystem_dev *se_dev = (struct se_subsystem_dev *)p;
1796         struct se_device *dev;
1797         struct se_hba *hba = se_dev->se_dev_hba;
1798         struct se_subsystem_api *t = hba->transport;
1799         char *ptr;
1800
1801         ptr = strstr(page, "1");
1802         if (!ptr) {
1803                 pr_err("For dev_enable ops, only valid value"
1804                                 " is \"1\"\n");
1805                 return -EINVAL;
1806         }
1807         if (se_dev->se_dev_ptr) {
1808                 pr_err("se_dev->se_dev_ptr already set for storage"
1809                                 " object\n");
1810                 return -EEXIST;
1811         }
1812
1813         if (t->check_configfs_dev_params(hba, se_dev) < 0)
1814                 return -EINVAL;
1815
1816         dev = t->create_virtdevice(hba, se_dev, se_dev->se_dev_su_ptr);
1817         if (IS_ERR(dev))
1818                 return PTR_ERR(dev);
1819         else if (!dev)
1820                 return -EINVAL;
1821
1822         se_dev->se_dev_ptr = dev;
1823         pr_debug("Target_Core_ConfigFS: Registered se_dev->se_dev_ptr:"
1824                 " %p\n", se_dev->se_dev_ptr);
1825
1826         return count;
1827 }
1828
1829 static struct target_core_configfs_attribute target_core_attr_dev_enable = {
1830         .attr   = { .ca_owner = THIS_MODULE,
1831                     .ca_name = "enable",
1832                     .ca_mode = S_IWUSR },
1833         .show   = NULL,
1834         .store  = target_core_store_dev_enable,
1835 };
1836
1837 static ssize_t target_core_show_alua_lu_gp(void *p, char *page)
1838 {
1839         struct se_device *dev;
1840         struct se_subsystem_dev *su_dev = (struct se_subsystem_dev *)p;
1841         struct config_item *lu_ci;
1842         struct t10_alua_lu_gp *lu_gp;
1843         struct t10_alua_lu_gp_member *lu_gp_mem;
1844         ssize_t len = 0;
1845
1846         dev = su_dev->se_dev_ptr;
1847         if (!dev)
1848                 return -ENODEV;
1849
1850         if (su_dev->t10_alua.alua_type != SPC3_ALUA_EMULATED)
1851                 return len;
1852
1853         lu_gp_mem = dev->dev_alua_lu_gp_mem;
1854         if (!lu_gp_mem) {
1855                 pr_err("NULL struct se_device->dev_alua_lu_gp_mem"
1856                                 " pointer\n");
1857                 return -EINVAL;
1858         }
1859
1860         spin_lock(&lu_gp_mem->lu_gp_mem_lock);
1861         lu_gp = lu_gp_mem->lu_gp;
1862         if (lu_gp) {
1863                 lu_ci = &lu_gp->lu_gp_group.cg_item;
1864                 len += sprintf(page, "LU Group Alias: %s\nLU Group ID: %hu\n",
1865                         config_item_name(lu_ci), lu_gp->lu_gp_id);
1866         }
1867         spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
1868
1869         return len;
1870 }
1871
1872 static ssize_t target_core_store_alua_lu_gp(
1873         void *p,
1874         const char *page,
1875         size_t count)
1876 {
1877         struct se_device *dev;
1878         struct se_subsystem_dev *su_dev = (struct se_subsystem_dev *)p;
1879         struct se_hba *hba = su_dev->se_dev_hba;
1880         struct t10_alua_lu_gp *lu_gp = NULL, *lu_gp_new = NULL;
1881         struct t10_alua_lu_gp_member *lu_gp_mem;
1882         unsigned char buf[LU_GROUP_NAME_BUF];
1883         int move = 0;
1884
1885         dev = su_dev->se_dev_ptr;
1886         if (!dev)
1887                 return -ENODEV;
1888
1889         if (su_dev->t10_alua.alua_type != SPC3_ALUA_EMULATED) {
1890                 pr_warn("SPC3_ALUA_EMULATED not enabled for %s/%s\n",
1891                         config_item_name(&hba->hba_group.cg_item),
1892                         config_item_name(&su_dev->se_dev_group.cg_item));
1893                 return -EINVAL;
1894         }
1895         if (count > LU_GROUP_NAME_BUF) {
1896                 pr_err("ALUA LU Group Alias too large!\n");
1897                 return -EINVAL;
1898         }
1899         memset(buf, 0, LU_GROUP_NAME_BUF);
1900         memcpy(buf, page, count);
1901         /*
1902          * Any ALUA logical unit alias besides "NULL" means we will be
1903          * making a new group association.
1904          */
1905         if (strcmp(strstrip(buf), "NULL")) {
1906                 /*
1907                  * core_alua_get_lu_gp_by_name() will increment reference to
1908                  * struct t10_alua_lu_gp.  This reference is released with
1909                  * core_alua_get_lu_gp_by_name below().
1910                  */
1911                 lu_gp_new = core_alua_get_lu_gp_by_name(strstrip(buf));
1912                 if (!lu_gp_new)
1913                         return -ENODEV;
1914         }
1915         lu_gp_mem = dev->dev_alua_lu_gp_mem;
1916         if (!lu_gp_mem) {
1917                 if (lu_gp_new)
1918                         core_alua_put_lu_gp_from_name(lu_gp_new);
1919                 pr_err("NULL struct se_device->dev_alua_lu_gp_mem"
1920                                 " pointer\n");
1921                 return -EINVAL;
1922         }
1923
1924         spin_lock(&lu_gp_mem->lu_gp_mem_lock);
1925         lu_gp = lu_gp_mem->lu_gp;
1926         if (lu_gp) {
1927                 /*
1928                  * Clearing an existing lu_gp association, and replacing
1929                  * with NULL
1930                  */
1931                 if (!lu_gp_new) {
1932                         pr_debug("Target_Core_ConfigFS: Releasing %s/%s"
1933                                 " from ALUA LU Group: core/alua/lu_gps/%s, ID:"
1934                                 " %hu\n",
1935                                 config_item_name(&hba->hba_group.cg_item),
1936                                 config_item_name(&su_dev->se_dev_group.cg_item),
1937                                 config_item_name(&lu_gp->lu_gp_group.cg_item),
1938                                 lu_gp->lu_gp_id);
1939
1940                         __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp);
1941                         spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
1942
1943                         return count;
1944                 }
1945                 /*
1946                  * Removing existing association of lu_gp_mem with lu_gp
1947                  */
1948                 __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp);
1949                 move = 1;
1950         }
1951         /*
1952          * Associate lu_gp_mem with lu_gp_new.
1953          */
1954         __core_alua_attach_lu_gp_mem(lu_gp_mem, lu_gp_new);
1955         spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
1956
1957         pr_debug("Target_Core_ConfigFS: %s %s/%s to ALUA LU Group:"
1958                 " core/alua/lu_gps/%s, ID: %hu\n",
1959                 (move) ? "Moving" : "Adding",
1960                 config_item_name(&hba->hba_group.cg_item),
1961                 config_item_name(&su_dev->se_dev_group.cg_item),
1962                 config_item_name(&lu_gp_new->lu_gp_group.cg_item),
1963                 lu_gp_new->lu_gp_id);
1964
1965         core_alua_put_lu_gp_from_name(lu_gp_new);
1966         return count;
1967 }
1968
1969 static struct target_core_configfs_attribute target_core_attr_dev_alua_lu_gp = {
1970         .attr   = { .ca_owner = THIS_MODULE,
1971                     .ca_name = "alua_lu_gp",
1972                     .ca_mode = S_IRUGO | S_IWUSR },
1973         .show   = target_core_show_alua_lu_gp,
1974         .store  = target_core_store_alua_lu_gp,
1975 };
1976
1977 static struct configfs_attribute *lio_core_dev_attrs[] = {
1978         &target_core_attr_dev_info.attr,
1979         &target_core_attr_dev_control.attr,
1980         &target_core_attr_dev_alias.attr,
1981         &target_core_attr_dev_udev_path.attr,
1982         &target_core_attr_dev_enable.attr,
1983         &target_core_attr_dev_alua_lu_gp.attr,
1984         NULL,
1985 };
1986
1987 static void target_core_dev_release(struct config_item *item)
1988 {
1989         struct se_subsystem_dev *se_dev = container_of(to_config_group(item),
1990                                 struct se_subsystem_dev, se_dev_group);
1991         struct se_hba *hba = item_to_hba(&se_dev->se_dev_hba->hba_group.cg_item);
1992         struct se_subsystem_api *t = hba->transport;
1993         struct config_group *dev_cg = &se_dev->se_dev_group;
1994
1995         kfree(dev_cg->default_groups);
1996         /*
1997          * This pointer will set when the storage is enabled with:
1998          *`echo 1 > $CONFIGFS/core/$HBA/$DEV/dev_enable`
1999          */
2000         if (se_dev->se_dev_ptr) {
2001                 pr_debug("Target_Core_ConfigFS: Calling se_free_"
2002                         "virtual_device() for se_dev_ptr: %p\n",
2003                         se_dev->se_dev_ptr);
2004
2005                 se_free_virtual_device(se_dev->se_dev_ptr, hba);
2006         } else {
2007                 /*
2008                  * Release struct se_subsystem_dev->se_dev_su_ptr..
2009                  */
2010                 pr_debug("Target_Core_ConfigFS: Calling t->free_"
2011                         "device() for se_dev_su_ptr: %p\n",
2012                         se_dev->se_dev_su_ptr);
2013
2014                 t->free_device(se_dev->se_dev_su_ptr);
2015         }
2016
2017         pr_debug("Target_Core_ConfigFS: Deallocating se_subsystem"
2018                         "_dev_t: %p\n", se_dev);
2019         kfree(se_dev);
2020 }
2021
2022 static ssize_t target_core_dev_show(struct config_item *item,
2023                                      struct configfs_attribute *attr,
2024                                      char *page)
2025 {
2026         struct se_subsystem_dev *se_dev = container_of(
2027                         to_config_group(item), struct se_subsystem_dev,
2028                         se_dev_group);
2029         struct target_core_configfs_attribute *tc_attr = container_of(
2030                         attr, struct target_core_configfs_attribute, attr);
2031
2032         if (!tc_attr->show)
2033                 return -EINVAL;
2034
2035         return tc_attr->show(se_dev, page);
2036 }
2037
2038 static ssize_t target_core_dev_store(struct config_item *item,
2039                                       struct configfs_attribute *attr,
2040                                       const char *page, size_t count)
2041 {
2042         struct se_subsystem_dev *se_dev = container_of(
2043                         to_config_group(item), struct se_subsystem_dev,
2044                         se_dev_group);
2045         struct target_core_configfs_attribute *tc_attr = container_of(
2046                         attr, struct target_core_configfs_attribute, attr);
2047
2048         if (!tc_attr->store)
2049                 return -EINVAL;
2050
2051         return tc_attr->store(se_dev, page, count);
2052 }
2053
2054 static struct configfs_item_operations target_core_dev_item_ops = {
2055         .release                = target_core_dev_release,
2056         .show_attribute         = target_core_dev_show,
2057         .store_attribute        = target_core_dev_store,
2058 };
2059
2060 static struct config_item_type target_core_dev_cit = {
2061         .ct_item_ops            = &target_core_dev_item_ops,
2062         .ct_attrs               = lio_core_dev_attrs,
2063         .ct_owner               = THIS_MODULE,
2064 };
2065
2066 /* End functions for struct config_item_type target_core_dev_cit */
2067
2068 /* Start functions for struct config_item_type target_core_alua_lu_gp_cit */
2069
2070 CONFIGFS_EATTR_STRUCT(target_core_alua_lu_gp, t10_alua_lu_gp);
2071 #define SE_DEV_ALUA_LU_ATTR(_name, _mode)                               \
2072 static struct target_core_alua_lu_gp_attribute                          \
2073                         target_core_alua_lu_gp_##_name =                \
2074         __CONFIGFS_EATTR(_name, _mode,                                  \
2075         target_core_alua_lu_gp_show_attr_##_name,                       \
2076         target_core_alua_lu_gp_store_attr_##_name);
2077
2078 #define SE_DEV_ALUA_LU_ATTR_RO(_name)                                   \
2079 static struct target_core_alua_lu_gp_attribute                          \
2080                         target_core_alua_lu_gp_##_name =                \
2081         __CONFIGFS_EATTR_RO(_name,                                      \
2082         target_core_alua_lu_gp_show_attr_##_name);
2083
2084 /*
2085  * lu_gp_id
2086  */
2087 static ssize_t target_core_alua_lu_gp_show_attr_lu_gp_id(
2088         struct t10_alua_lu_gp *lu_gp,
2089         char *page)
2090 {
2091         if (!lu_gp->lu_gp_valid_id)
2092                 return 0;
2093
2094         return sprintf(page, "%hu\n", lu_gp->lu_gp_id);
2095 }
2096
2097 static ssize_t target_core_alua_lu_gp_store_attr_lu_gp_id(
2098         struct t10_alua_lu_gp *lu_gp,
2099         const char *page,
2100         size_t count)
2101 {
2102         struct config_group *alua_lu_gp_cg = &lu_gp->lu_gp_group;
2103         unsigned long lu_gp_id;
2104         int ret;
2105
2106         ret = strict_strtoul(page, 0, &lu_gp_id);
2107         if (ret < 0) {
2108                 pr_err("strict_strtoul() returned %d for"
2109                         " lu_gp_id\n", ret);
2110                 return -EINVAL;
2111         }
2112         if (lu_gp_id > 0x0000ffff) {
2113                 pr_err("ALUA lu_gp_id: %lu exceeds maximum:"
2114                         " 0x0000ffff\n", lu_gp_id);
2115                 return -EINVAL;
2116         }
2117
2118         ret = core_alua_set_lu_gp_id(lu_gp, (u16)lu_gp_id);
2119         if (ret < 0)
2120                 return -EINVAL;
2121
2122         pr_debug("Target_Core_ConfigFS: Set ALUA Logical Unit"
2123                 " Group: core/alua/lu_gps/%s to ID: %hu\n",
2124                 config_item_name(&alua_lu_gp_cg->cg_item),
2125                 lu_gp->lu_gp_id);
2126
2127         return count;
2128 }
2129
2130 SE_DEV_ALUA_LU_ATTR(lu_gp_id, S_IRUGO | S_IWUSR);
2131
2132 /*
2133  * members
2134  */
2135 static ssize_t target_core_alua_lu_gp_show_attr_members(
2136         struct t10_alua_lu_gp *lu_gp,
2137         char *page)
2138 {
2139         struct se_device *dev;
2140         struct se_hba *hba;
2141         struct se_subsystem_dev *su_dev;
2142         struct t10_alua_lu_gp_member *lu_gp_mem;
2143         ssize_t len = 0, cur_len;
2144         unsigned char buf[LU_GROUP_NAME_BUF];
2145
2146         memset(buf, 0, LU_GROUP_NAME_BUF);
2147
2148         spin_lock(&lu_gp->lu_gp_lock);
2149         list_for_each_entry(lu_gp_mem, &lu_gp->lu_gp_mem_list, lu_gp_mem_list) {
2150                 dev = lu_gp_mem->lu_gp_mem_dev;
2151                 su_dev = dev->se_sub_dev;
2152                 hba = su_dev->se_dev_hba;
2153
2154                 cur_len = snprintf(buf, LU_GROUP_NAME_BUF, "%s/%s\n",
2155                         config_item_name(&hba->hba_group.cg_item),
2156                         config_item_name(&su_dev->se_dev_group.cg_item));
2157                 cur_len++; /* Extra byte for NULL terminator */
2158
2159                 if ((cur_len + len) > PAGE_SIZE) {
2160                         pr_warn("Ran out of lu_gp_show_attr"
2161                                 "_members buffer\n");
2162                         break;
2163                 }
2164                 memcpy(page+len, buf, cur_len);
2165                 len += cur_len;
2166         }
2167         spin_unlock(&lu_gp->lu_gp_lock);
2168
2169         return len;
2170 }
2171
2172 SE_DEV_ALUA_LU_ATTR_RO(members);
2173
2174 CONFIGFS_EATTR_OPS(target_core_alua_lu_gp, t10_alua_lu_gp, lu_gp_group);
2175
2176 static struct configfs_attribute *target_core_alua_lu_gp_attrs[] = {
2177         &target_core_alua_lu_gp_lu_gp_id.attr,
2178         &target_core_alua_lu_gp_members.attr,
2179         NULL,
2180 };
2181
2182 static void target_core_alua_lu_gp_release(struct config_item *item)
2183 {
2184         struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
2185                         struct t10_alua_lu_gp, lu_gp_group);
2186
2187         core_alua_free_lu_gp(lu_gp);
2188 }
2189
2190 static struct configfs_item_operations target_core_alua_lu_gp_ops = {
2191         .release                = target_core_alua_lu_gp_release,
2192         .show_attribute         = target_core_alua_lu_gp_attr_show,
2193         .store_attribute        = target_core_alua_lu_gp_attr_store,
2194 };
2195
2196 static struct config_item_type target_core_alua_lu_gp_cit = {
2197         .ct_item_ops            = &target_core_alua_lu_gp_ops,
2198         .ct_attrs               = target_core_alua_lu_gp_attrs,
2199         .ct_owner               = THIS_MODULE,
2200 };
2201
2202 /* End functions for struct config_item_type target_core_alua_lu_gp_cit */
2203
2204 /* Start functions for struct config_item_type target_core_alua_lu_gps_cit */
2205
2206 static struct config_group *target_core_alua_create_lu_gp(
2207         struct config_group *group,
2208         const char *name)
2209 {
2210         struct t10_alua_lu_gp *lu_gp;
2211         struct config_group *alua_lu_gp_cg = NULL;
2212         struct config_item *alua_lu_gp_ci = NULL;
2213
2214         lu_gp = core_alua_allocate_lu_gp(name, 0);
2215         if (IS_ERR(lu_gp))
2216                 return NULL;
2217
2218         alua_lu_gp_cg = &lu_gp->lu_gp_group;
2219         alua_lu_gp_ci = &alua_lu_gp_cg->cg_item;
2220
2221         config_group_init_type_name(alua_lu_gp_cg, name,
2222                         &target_core_alua_lu_gp_cit);
2223
2224         pr_debug("Target_Core_ConfigFS: Allocated ALUA Logical Unit"
2225                 " Group: core/alua/lu_gps/%s\n",
2226                 config_item_name(alua_lu_gp_ci));
2227
2228         return alua_lu_gp_cg;
2229
2230 }
2231
2232 static void target_core_alua_drop_lu_gp(
2233         struct config_group *group,
2234         struct config_item *item)
2235 {
2236         struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
2237                         struct t10_alua_lu_gp, lu_gp_group);
2238
2239         pr_debug("Target_Core_ConfigFS: Releasing ALUA Logical Unit"
2240                 " Group: core/alua/lu_gps/%s, ID: %hu\n",
2241                 config_item_name(item), lu_gp->lu_gp_id);
2242         /*
2243          * core_alua_free_lu_gp() is called from target_core_alua_lu_gp_ops->release()
2244          * -> target_core_alua_lu_gp_release()
2245          */
2246         config_item_put(item);
2247 }
2248
2249 static struct configfs_group_operations target_core_alua_lu_gps_group_ops = {
2250         .make_group             = &target_core_alua_create_lu_gp,
2251         .drop_item              = &target_core_alua_drop_lu_gp,
2252 };
2253
2254 static struct config_item_type target_core_alua_lu_gps_cit = {
2255         .ct_item_ops            = NULL,
2256         .ct_group_ops           = &target_core_alua_lu_gps_group_ops,
2257         .ct_owner               = THIS_MODULE,
2258 };
2259
2260 /* End functions for struct config_item_type target_core_alua_lu_gps_cit */
2261
2262 /* Start functions for struct config_item_type target_core_alua_tg_pt_gp_cit */
2263
2264 CONFIGFS_EATTR_STRUCT(target_core_alua_tg_pt_gp, t10_alua_tg_pt_gp);
2265 #define SE_DEV_ALUA_TG_PT_ATTR(_name, _mode)                            \
2266 static struct target_core_alua_tg_pt_gp_attribute                       \
2267                         target_core_alua_tg_pt_gp_##_name =             \
2268         __CONFIGFS_EATTR(_name, _mode,                                  \
2269         target_core_alua_tg_pt_gp_show_attr_##_name,                    \
2270         target_core_alua_tg_pt_gp_store_attr_##_name);
2271
2272 #define SE_DEV_ALUA_TG_PT_ATTR_RO(_name)                                \
2273 static struct target_core_alua_tg_pt_gp_attribute                       \
2274                         target_core_alua_tg_pt_gp_##_name =             \
2275         __CONFIGFS_EATTR_RO(_name,                                      \
2276         target_core_alua_tg_pt_gp_show_attr_##_name);
2277
2278 /*
2279  * alua_access_state
2280  */
2281 static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_access_state(
2282         struct t10_alua_tg_pt_gp *tg_pt_gp,
2283         char *page)
2284 {
2285         return sprintf(page, "%d\n",
2286                 atomic_read(&tg_pt_gp->tg_pt_gp_alua_access_state));
2287 }
2288
2289 static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_access_state(
2290         struct t10_alua_tg_pt_gp *tg_pt_gp,
2291         const char *page,
2292         size_t count)
2293 {
2294         struct se_subsystem_dev *su_dev = tg_pt_gp->tg_pt_gp_su_dev;
2295         unsigned long tmp;
2296         int new_state, ret;
2297
2298         if (!tg_pt_gp->tg_pt_gp_valid_id) {
2299                 pr_err("Unable to do implict ALUA on non valid"
2300                         " tg_pt_gp ID: %hu\n", tg_pt_gp->tg_pt_gp_valid_id);
2301                 return -EINVAL;
2302         }
2303
2304         ret = strict_strtoul(page, 0, &tmp);
2305         if (ret < 0) {
2306                 pr_err("Unable to extract new ALUA access state from"
2307                                 " %s\n", page);
2308                 return -EINVAL;
2309         }
2310         new_state = (int)tmp;
2311
2312         if (!(tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_IMPLICT_ALUA)) {
2313                 pr_err("Unable to process implict configfs ALUA"
2314                         " transition while TPGS_IMPLICT_ALUA is diabled\n");
2315                 return -EINVAL;
2316         }
2317
2318         ret = core_alua_do_port_transition(tg_pt_gp, su_dev->se_dev_ptr,
2319                                         NULL, NULL, new_state, 0);
2320         return (!ret) ? count : -EINVAL;
2321 }
2322
2323 SE_DEV_ALUA_TG_PT_ATTR(alua_access_state, S_IRUGO | S_IWUSR);
2324
2325 /*
2326  * alua_access_status
2327  */
2328 static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_access_status(
2329         struct t10_alua_tg_pt_gp *tg_pt_gp,
2330         char *page)
2331 {
2332         return sprintf(page, "%s\n",
2333                 core_alua_dump_status(tg_pt_gp->tg_pt_gp_alua_access_status));
2334 }
2335
2336 static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_access_status(
2337         struct t10_alua_tg_pt_gp *tg_pt_gp,
2338         const char *page,
2339         size_t count)
2340 {
2341         unsigned long tmp;
2342         int new_status, ret;
2343
2344         if (!tg_pt_gp->tg_pt_gp_valid_id) {
2345                 pr_err("Unable to do set ALUA access status on non"
2346                         " valid tg_pt_gp ID: %hu\n",
2347                         tg_pt_gp->tg_pt_gp_valid_id);
2348                 return -EINVAL;
2349         }
2350
2351         ret = strict_strtoul(page, 0, &tmp);
2352         if (ret < 0) {
2353                 pr_err("Unable to extract new ALUA access status"
2354                                 " from %s\n", page);
2355                 return -EINVAL;
2356         }
2357         new_status = (int)tmp;
2358
2359         if ((new_status != ALUA_STATUS_NONE) &&
2360             (new_status != ALUA_STATUS_ALTERED_BY_EXPLICT_STPG) &&
2361             (new_status != ALUA_STATUS_ALTERED_BY_IMPLICT_ALUA)) {
2362                 pr_err("Illegal ALUA access status: 0x%02x\n",
2363                                 new_status);
2364                 return -EINVAL;
2365         }
2366
2367         tg_pt_gp->tg_pt_gp_alua_access_status = new_status;
2368         return count;
2369 }
2370
2371 SE_DEV_ALUA_TG_PT_ATTR(alua_access_status, S_IRUGO | S_IWUSR);
2372
2373 /*
2374  * alua_access_type
2375  */
2376 static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_access_type(
2377         struct t10_alua_tg_pt_gp *tg_pt_gp,
2378         char *page)
2379 {
2380         return core_alua_show_access_type(tg_pt_gp, page);
2381 }
2382
2383 static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_access_type(
2384         struct t10_alua_tg_pt_gp *tg_pt_gp,
2385         const char *page,
2386         size_t count)
2387 {
2388         return core_alua_store_access_type(tg_pt_gp, page, count);
2389 }
2390
2391 SE_DEV_ALUA_TG_PT_ATTR(alua_access_type, S_IRUGO | S_IWUSR);
2392
2393 /*
2394  * alua_write_metadata
2395  */
2396 static ssize_t target_core_alua_tg_pt_gp_show_attr_alua_write_metadata(
2397         struct t10_alua_tg_pt_gp *tg_pt_gp,
2398         char *page)
2399 {
2400         return sprintf(page, "%d\n", tg_pt_gp->tg_pt_gp_write_metadata);
2401 }
2402
2403 static ssize_t target_core_alua_tg_pt_gp_store_attr_alua_write_metadata(
2404         struct t10_alua_tg_pt_gp *tg_pt_gp,
2405         const char *page,
2406         size_t count)
2407 {
2408         unsigned long tmp;
2409         int ret;
2410
2411         ret = strict_strtoul(page, 0, &tmp);
2412         if (ret < 0) {
2413                 pr_err("Unable to extract alua_write_metadata\n");
2414                 return -EINVAL;
2415         }
2416
2417         if ((tmp != 0) && (tmp != 1)) {
2418                 pr_err("Illegal value for alua_write_metadata:"
2419                         " %lu\n", tmp);
2420                 return -EINVAL;
2421         }
2422         tg_pt_gp->tg_pt_gp_write_metadata = (int)tmp;
2423
2424         return count;
2425 }
2426
2427 SE_DEV_ALUA_TG_PT_ATTR(alua_write_metadata, S_IRUGO | S_IWUSR);
2428
2429
2430
2431 /*
2432  * nonop_delay_msecs
2433  */
2434 static ssize_t target_core_alua_tg_pt_gp_show_attr_nonop_delay_msecs(
2435         struct t10_alua_tg_pt_gp *tg_pt_gp,
2436         char *page)
2437 {
2438         return core_alua_show_nonop_delay_msecs(tg_pt_gp, page);
2439
2440 }
2441
2442 static ssize_t target_core_alua_tg_pt_gp_store_attr_nonop_delay_msecs(
2443         struct t10_alua_tg_pt_gp *tg_pt_gp,
2444         const char *page,
2445         size_t count)
2446 {
2447         return core_alua_store_nonop_delay_msecs(tg_pt_gp, page, count);
2448 }
2449
2450 SE_DEV_ALUA_TG_PT_ATTR(nonop_delay_msecs, S_IRUGO | S_IWUSR);
2451
2452 /*
2453  * trans_delay_msecs
2454  */
2455 static ssize_t target_core_alua_tg_pt_gp_show_attr_trans_delay_msecs(
2456         struct t10_alua_tg_pt_gp *tg_pt_gp,
2457         char *page)
2458 {
2459         return core_alua_show_trans_delay_msecs(tg_pt_gp, page);
2460 }
2461
2462 static ssize_t target_core_alua_tg_pt_gp_store_attr_trans_delay_msecs(
2463         struct t10_alua_tg_pt_gp *tg_pt_gp,
2464         const char *page,
2465         size_t count)
2466 {
2467         return core_alua_store_trans_delay_msecs(tg_pt_gp, page, count);
2468 }
2469
2470 SE_DEV_ALUA_TG_PT_ATTR(trans_delay_msecs, S_IRUGO | S_IWUSR);
2471
2472 /*
2473  * preferred
2474  */
2475
2476 static ssize_t target_core_alua_tg_pt_gp_show_attr_preferred(
2477         struct t10_alua_tg_pt_gp *tg_pt_gp,
2478         char *page)
2479 {
2480         return core_alua_show_preferred_bit(tg_pt_gp, page);
2481 }
2482
2483 static ssize_t target_core_alua_tg_pt_gp_store_attr_preferred(
2484         struct t10_alua_tg_pt_gp *tg_pt_gp,
2485         const char *page,
2486         size_t count)
2487 {
2488         return core_alua_store_preferred_bit(tg_pt_gp, page, count);
2489 }
2490
2491 SE_DEV_ALUA_TG_PT_ATTR(preferred, S_IRUGO | S_IWUSR);
2492
2493 /*
2494  * tg_pt_gp_id
2495  */
2496 static ssize_t target_core_alua_tg_pt_gp_show_attr_tg_pt_gp_id(
2497         struct t10_alua_tg_pt_gp *tg_pt_gp,
2498         char *page)
2499 {
2500         if (!tg_pt_gp->tg_pt_gp_valid_id)
2501                 return 0;
2502
2503         return sprintf(page, "%hu\n", tg_pt_gp->tg_pt_gp_id);
2504 }
2505
2506 static ssize_t target_core_alua_tg_pt_gp_store_attr_tg_pt_gp_id(
2507         struct t10_alua_tg_pt_gp *tg_pt_gp,
2508         const char *page,
2509         size_t count)
2510 {
2511         struct config_group *alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group;
2512         unsigned long tg_pt_gp_id;
2513         int ret;
2514
2515         ret = strict_strtoul(page, 0, &tg_pt_gp_id);
2516         if (ret < 0) {
2517                 pr_err("strict_strtoul() returned %d for"
2518                         " tg_pt_gp_id\n", ret);
2519                 return -EINVAL;
2520         }
2521         if (tg_pt_gp_id > 0x0000ffff) {
2522                 pr_err("ALUA tg_pt_gp_id: %lu exceeds maximum:"
2523                         " 0x0000ffff\n", tg_pt_gp_id);
2524                 return -EINVAL;
2525         }
2526
2527         ret = core_alua_set_tg_pt_gp_id(tg_pt_gp, (u16)tg_pt_gp_id);
2528         if (ret < 0)
2529                 return -EINVAL;
2530
2531         pr_debug("Target_Core_ConfigFS: Set ALUA Target Port Group: "
2532                 "core/alua/tg_pt_gps/%s to ID: %hu\n",
2533                 config_item_name(&alua_tg_pt_gp_cg->cg_item),
2534                 tg_pt_gp->tg_pt_gp_id);
2535
2536         return count;
2537 }
2538
2539 SE_DEV_ALUA_TG_PT_ATTR(tg_pt_gp_id, S_IRUGO | S_IWUSR);
2540
2541 /*
2542  * members
2543  */
2544 static ssize_t target_core_alua_tg_pt_gp_show_attr_members(
2545         struct t10_alua_tg_pt_gp *tg_pt_gp,
2546         char *page)
2547 {
2548         struct se_port *port;
2549         struct se_portal_group *tpg;
2550         struct se_lun *lun;
2551         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
2552         ssize_t len = 0, cur_len;
2553         unsigned char buf[TG_PT_GROUP_NAME_BUF];
2554
2555         memset(buf, 0, TG_PT_GROUP_NAME_BUF);
2556
2557         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
2558         list_for_each_entry(tg_pt_gp_mem, &tg_pt_gp->tg_pt_gp_mem_list,
2559                         tg_pt_gp_mem_list) {
2560                 port = tg_pt_gp_mem->tg_pt;
2561                 tpg = port->sep_tpg;
2562                 lun = port->sep_lun;
2563
2564                 cur_len = snprintf(buf, TG_PT_GROUP_NAME_BUF, "%s/%s/tpgt_%hu"
2565                         "/%s\n", tpg->se_tpg_tfo->get_fabric_name(),
2566                         tpg->se_tpg_tfo->tpg_get_wwn(tpg),
2567                         tpg->se_tpg_tfo->tpg_get_tag(tpg),
2568                         config_item_name(&lun->lun_group.cg_item));
2569                 cur_len++; /* Extra byte for NULL terminator */
2570
2571                 if ((cur_len + len) > PAGE_SIZE) {
2572                         pr_warn("Ran out of lu_gp_show_attr"
2573                                 "_members buffer\n");
2574                         break;
2575                 }
2576                 memcpy(page+len, buf, cur_len);
2577                 len += cur_len;
2578         }
2579         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
2580
2581         return len;
2582 }
2583
2584 SE_DEV_ALUA_TG_PT_ATTR_RO(members);
2585
2586 CONFIGFS_EATTR_OPS(target_core_alua_tg_pt_gp, t10_alua_tg_pt_gp,
2587                         tg_pt_gp_group);
2588
2589 static struct configfs_attribute *target_core_alua_tg_pt_gp_attrs[] = {
2590         &target_core_alua_tg_pt_gp_alua_access_state.attr,
2591         &target_core_alua_tg_pt_gp_alua_access_status.attr,
2592         &target_core_alua_tg_pt_gp_alua_access_type.attr,
2593         &target_core_alua_tg_pt_gp_alua_write_metadata.attr,
2594         &target_core_alua_tg_pt_gp_nonop_delay_msecs.attr,
2595         &target_core_alua_tg_pt_gp_trans_delay_msecs.attr,
2596         &target_core_alua_tg_pt_gp_preferred.attr,
2597         &target_core_alua_tg_pt_gp_tg_pt_gp_id.attr,
2598         &target_core_alua_tg_pt_gp_members.attr,
2599         NULL,
2600 };
2601
2602 static void target_core_alua_tg_pt_gp_release(struct config_item *item)
2603 {
2604         struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
2605                         struct t10_alua_tg_pt_gp, tg_pt_gp_group);
2606
2607         core_alua_free_tg_pt_gp(tg_pt_gp);
2608 }
2609
2610 static struct configfs_item_operations target_core_alua_tg_pt_gp_ops = {
2611         .release                = target_core_alua_tg_pt_gp_release,
2612         .show_attribute         = target_core_alua_tg_pt_gp_attr_show,
2613         .store_attribute        = target_core_alua_tg_pt_gp_attr_store,
2614 };
2615
2616 static struct config_item_type target_core_alua_tg_pt_gp_cit = {
2617         .ct_item_ops            = &target_core_alua_tg_pt_gp_ops,
2618         .ct_attrs               = target_core_alua_tg_pt_gp_attrs,
2619         .ct_owner               = THIS_MODULE,
2620 };
2621
2622 /* End functions for struct config_item_type target_core_alua_tg_pt_gp_cit */
2623
2624 /* Start functions for struct config_item_type target_core_alua_tg_pt_gps_cit */
2625
2626 static struct config_group *target_core_alua_create_tg_pt_gp(
2627         struct config_group *group,
2628         const char *name)
2629 {
2630         struct t10_alua *alua = container_of(group, struct t10_alua,
2631                                         alua_tg_pt_gps_group);
2632         struct t10_alua_tg_pt_gp *tg_pt_gp;
2633         struct se_subsystem_dev *su_dev = alua->t10_sub_dev;
2634         struct config_group *alua_tg_pt_gp_cg = NULL;
2635         struct config_item *alua_tg_pt_gp_ci = NULL;
2636
2637         tg_pt_gp = core_alua_allocate_tg_pt_gp(su_dev, name, 0);
2638         if (!tg_pt_gp)
2639                 return NULL;
2640
2641         alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group;
2642         alua_tg_pt_gp_ci = &alua_tg_pt_gp_cg->cg_item;
2643
2644         config_group_init_type_name(alua_tg_pt_gp_cg, name,
2645                         &target_core_alua_tg_pt_gp_cit);
2646
2647         pr_debug("Target_Core_ConfigFS: Allocated ALUA Target Port"
2648                 " Group: alua/tg_pt_gps/%s\n",
2649                 config_item_name(alua_tg_pt_gp_ci));
2650
2651         return alua_tg_pt_gp_cg;
2652 }
2653
2654 static void target_core_alua_drop_tg_pt_gp(
2655         struct config_group *group,
2656         struct config_item *item)
2657 {
2658         struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
2659                         struct t10_alua_tg_pt_gp, tg_pt_gp_group);
2660
2661         pr_debug("Target_Core_ConfigFS: Releasing ALUA Target Port"
2662                 " Group: alua/tg_pt_gps/%s, ID: %hu\n",
2663                 config_item_name(item), tg_pt_gp->tg_pt_gp_id);
2664         /*
2665          * core_alua_free_tg_pt_gp() is called from target_core_alua_tg_pt_gp_ops->release()
2666          * -> target_core_alua_tg_pt_gp_release().
2667          */
2668         config_item_put(item);
2669 }
2670
2671 static struct configfs_group_operations target_core_alua_tg_pt_gps_group_ops = {
2672         .make_group             = &target_core_alua_create_tg_pt_gp,
2673         .drop_item              = &target_core_alua_drop_tg_pt_gp,
2674 };
2675
2676 static struct config_item_type target_core_alua_tg_pt_gps_cit = {
2677         .ct_group_ops           = &target_core_alua_tg_pt_gps_group_ops,
2678         .ct_owner               = THIS_MODULE,
2679 };
2680
2681 /* End functions for struct config_item_type target_core_alua_tg_pt_gps_cit */
2682
2683 /* Start functions for struct config_item_type target_core_alua_cit */
2684
2685 /*
2686  * target_core_alua_cit is a ConfigFS group that lives under
2687  * /sys/kernel/config/target/core/alua.  There are default groups
2688  * core/alua/lu_gps and core/alua/tg_pt_gps that are attached to
2689  * target_core_alua_cit in target_core_init_configfs() below.
2690  */
2691 static struct config_item_type target_core_alua_cit = {
2692         .ct_item_ops            = NULL,
2693         .ct_attrs               = NULL,
2694         .ct_owner               = THIS_MODULE,
2695 };
2696
2697 /* End functions for struct config_item_type target_core_alua_cit */
2698
2699 /* Start functions for struct config_item_type target_core_stat_cit */
2700
2701 static struct config_group *target_core_stat_mkdir(
2702         struct config_group *group,
2703         const char *name)
2704 {
2705         return ERR_PTR(-ENOSYS);
2706 }
2707
2708 static void target_core_stat_rmdir(
2709         struct config_group *group,
2710         struct config_item *item)
2711 {
2712         return;
2713 }
2714
2715 static struct configfs_group_operations target_core_stat_group_ops = {
2716         .make_group             = &target_core_stat_mkdir,
2717         .drop_item              = &target_core_stat_rmdir,
2718 };
2719
2720 static struct config_item_type target_core_stat_cit = {
2721         .ct_group_ops           = &target_core_stat_group_ops,
2722         .ct_owner               = THIS_MODULE,
2723 };
2724
2725 /* End functions for struct config_item_type target_core_stat_cit */
2726
2727 /* Start functions for struct config_item_type target_core_hba_cit */
2728
2729 static struct config_group *target_core_make_subdev(
2730         struct config_group *group,
2731         const char *name)
2732 {
2733         struct t10_alua_tg_pt_gp *tg_pt_gp;
2734         struct se_subsystem_dev *se_dev;
2735         struct se_subsystem_api *t;
2736         struct config_item *hba_ci = &group->cg_item;
2737         struct se_hba *hba = item_to_hba(hba_ci);
2738         struct config_group *dev_cg = NULL, *tg_pt_gp_cg = NULL;
2739         struct config_group *dev_stat_grp = NULL;
2740         int errno = -ENOMEM, ret;
2741
2742         ret = mutex_lock_interruptible(&hba->hba_access_mutex);
2743         if (ret)
2744                 return ERR_PTR(ret);
2745         /*
2746          * Locate the struct se_subsystem_api from parent's struct se_hba.
2747          */
2748         t = hba->transport;
2749
2750         se_dev = kzalloc(sizeof(struct se_subsystem_dev), GFP_KERNEL);
2751         if (!se_dev) {
2752                 pr_err("Unable to allocate memory for"
2753                                 " struct se_subsystem_dev\n");
2754                 goto unlock;
2755         }
2756         INIT_LIST_HEAD(&se_dev->se_dev_node);
2757         INIT_LIST_HEAD(&se_dev->t10_wwn.t10_vpd_list);
2758         spin_lock_init(&se_dev->t10_wwn.t10_vpd_lock);
2759         INIT_LIST_HEAD(&se_dev->t10_pr.registration_list);
2760         INIT_LIST_HEAD(&se_dev->t10_pr.aptpl_reg_list);
2761         spin_lock_init(&se_dev->t10_pr.registration_lock);
2762         spin_lock_init(&se_dev->t10_pr.aptpl_reg_lock);
2763         INIT_LIST_HEAD(&se_dev->t10_alua.tg_pt_gps_list);
2764         spin_lock_init(&se_dev->t10_alua.tg_pt_gps_lock);
2765         spin_lock_init(&se_dev->se_dev_lock);
2766         se_dev->t10_pr.pr_aptpl_buf_len = PR_APTPL_BUF_LEN;
2767         se_dev->t10_wwn.t10_sub_dev = se_dev;
2768         se_dev->t10_alua.t10_sub_dev = se_dev;
2769         se_dev->se_dev_attrib.da_sub_dev = se_dev;
2770
2771         se_dev->se_dev_hba = hba;
2772         dev_cg = &se_dev->se_dev_group;
2773
2774         dev_cg->default_groups = kzalloc(sizeof(struct config_group) * 7,
2775                         GFP_KERNEL);
2776         if (!dev_cg->default_groups)
2777                 goto out;
2778         /*
2779          * Set se_dev_su_ptr from struct se_subsystem_api returned void ptr
2780          * for ->allocate_virtdevice()
2781          *
2782          * se_dev->se_dev_ptr will be set after ->create_virtdev()
2783          * has been called successfully in the next level up in the
2784          * configfs tree for device object's struct config_group.
2785          */
2786         se_dev->se_dev_su_ptr = t->allocate_virtdevice(hba, name);
2787         if (!se_dev->se_dev_su_ptr) {
2788                 pr_err("Unable to locate subsystem dependent pointer"
2789                         " from allocate_virtdevice()\n");
2790                 goto out;
2791         }
2792         spin_lock(&se_device_lock);
2793         list_add_tail(&se_dev->se_dev_node, &se_dev_list);
2794         spin_unlock(&se_device_lock);
2795
2796         config_group_init_type_name(&se_dev->se_dev_group, name,
2797                         &target_core_dev_cit);
2798         config_group_init_type_name(&se_dev->se_dev_attrib.da_group, "attrib",
2799                         &target_core_dev_attrib_cit);
2800         config_group_init_type_name(&se_dev->se_dev_pr_group, "pr",
2801                         &target_core_dev_pr_cit);
2802         config_group_init_type_name(&se_dev->t10_wwn.t10_wwn_group, "wwn",
2803                         &target_core_dev_wwn_cit);
2804         config_group_init_type_name(&se_dev->t10_alua.alua_tg_pt_gps_group,
2805                         "alua", &target_core_alua_tg_pt_gps_cit);
2806         config_group_init_type_name(&se_dev->dev_stat_grps.stat_group,
2807                         "statistics", &target_core_stat_cit);
2808
2809         dev_cg->default_groups[0] = &se_dev->se_dev_attrib.da_group;
2810         dev_cg->default_groups[1] = &se_dev->se_dev_pr_group;
2811         dev_cg->default_groups[2] = &se_dev->t10_wwn.t10_wwn_group;
2812         dev_cg->default_groups[3] = &se_dev->t10_alua.alua_tg_pt_gps_group;
2813         dev_cg->default_groups[4] = &se_dev->dev_stat_grps.stat_group;
2814         dev_cg->default_groups[5] = NULL;
2815         /*
2816          * Add core/$HBA/$DEV/alua/default_tg_pt_gp
2817          */
2818         tg_pt_gp = core_alua_allocate_tg_pt_gp(se_dev, "default_tg_pt_gp", 1);
2819         if (!tg_pt_gp)
2820                 goto out;
2821
2822         tg_pt_gp_cg = &se_dev->t10_alua.alua_tg_pt_gps_group;
2823         tg_pt_gp_cg->default_groups = kzalloc(sizeof(struct config_group) * 2,
2824                                 GFP_KERNEL);
2825         if (!tg_pt_gp_cg->default_groups) {
2826                 pr_err("Unable to allocate tg_pt_gp_cg->"
2827                                 "default_groups\n");
2828                 goto out;
2829         }
2830
2831         config_group_init_type_name(&tg_pt_gp->tg_pt_gp_group,
2832                         "default_tg_pt_gp", &target_core_alua_tg_pt_gp_cit);
2833         tg_pt_gp_cg->default_groups[0] = &tg_pt_gp->tg_pt_gp_group;
2834         tg_pt_gp_cg->default_groups[1] = NULL;
2835         se_dev->t10_alua.default_tg_pt_gp = tg_pt_gp;
2836         /*
2837          * Add core/$HBA/$DEV/statistics/ default groups
2838          */
2839         dev_stat_grp = &se_dev->dev_stat_grps.stat_group;
2840         dev_stat_grp->default_groups = kzalloc(sizeof(struct config_group) * 4,
2841                                 GFP_KERNEL);
2842         if (!dev_stat_grp->default_groups) {
2843                 pr_err("Unable to allocate dev_stat_grp->default_groups\n");
2844                 goto out;
2845         }
2846         target_stat_setup_dev_default_groups(se_dev);
2847
2848         pr_debug("Target_Core_ConfigFS: Allocated struct se_subsystem_dev:"
2849                 " %p se_dev_su_ptr: %p\n", se_dev, se_dev->se_dev_su_ptr);
2850
2851         mutex_unlock(&hba->hba_access_mutex);
2852         return &se_dev->se_dev_group;
2853 out:
2854         if (se_dev->t10_alua.default_tg_pt_gp) {
2855                 core_alua_free_tg_pt_gp(se_dev->t10_alua.default_tg_pt_gp);
2856                 se_dev->t10_alua.default_tg_pt_gp = NULL;
2857         }
2858         if (dev_stat_grp)
2859                 kfree(dev_stat_grp->default_groups);
2860         if (tg_pt_gp_cg)
2861                 kfree(tg_pt_gp_cg->default_groups);
2862         if (dev_cg)
2863                 kfree(dev_cg->default_groups);
2864         if (se_dev->se_dev_su_ptr)
2865                 t->free_device(se_dev->se_dev_su_ptr);
2866         kfree(se_dev);
2867 unlock:
2868         mutex_unlock(&hba->hba_access_mutex);
2869         return ERR_PTR(errno);
2870 }
2871
2872 static void target_core_drop_subdev(
2873         struct config_group *group,
2874         struct config_item *item)
2875 {
2876         struct se_subsystem_dev *se_dev = container_of(to_config_group(item),
2877                                 struct se_subsystem_dev, se_dev_group);
2878         struct se_hba *hba;
2879         struct se_subsystem_api *t;
2880         struct config_item *df_item;
2881         struct config_group *dev_cg, *tg_pt_gp_cg, *dev_stat_grp;
2882         int i;
2883
2884         hba = item_to_hba(&se_dev->se_dev_hba->hba_group.cg_item);
2885
2886         mutex_lock(&hba->hba_access_mutex);
2887         t = hba->transport;
2888
2889         spin_lock(&se_device_lock);
2890         list_del(&se_dev->se_dev_node);
2891         spin_unlock(&se_device_lock);
2892
2893         dev_stat_grp = &se_dev->dev_stat_grps.stat_group;
2894         for (i = 0; dev_stat_grp->default_groups[i]; i++) {
2895                 df_item = &dev_stat_grp->default_groups[i]->cg_item;
2896                 dev_stat_grp->default_groups[i] = NULL;
2897                 config_item_put(df_item);
2898         }
2899         kfree(dev_stat_grp->default_groups);
2900
2901         tg_pt_gp_cg = &se_dev->t10_alua.alua_tg_pt_gps_group;
2902         for (i = 0; tg_pt_gp_cg->default_groups[i]; i++) {
2903                 df_item = &tg_pt_gp_cg->default_groups[i]->cg_item;
2904                 tg_pt_gp_cg->default_groups[i] = NULL;
2905                 config_item_put(df_item);
2906         }
2907         kfree(tg_pt_gp_cg->default_groups);
2908         /*
2909          * core_alua_free_tg_pt_gp() is called from ->default_tg_pt_gp
2910          * directly from target_core_alua_tg_pt_gp_release().
2911          */
2912         se_dev->t10_alua.default_tg_pt_gp = NULL;
2913
2914         dev_cg = &se_dev->se_dev_group;
2915         for (i = 0; dev_cg->default_groups[i]; i++) {
2916                 df_item = &dev_cg->default_groups[i]->cg_item;
2917                 dev_cg->default_groups[i] = NULL;
2918                 config_item_put(df_item);
2919         }
2920         /*
2921          * The releasing of se_dev and associated se_dev->se_dev_ptr is done
2922          * from target_core_dev_item_ops->release() ->target_core_dev_release().
2923          */
2924         config_item_put(item);
2925         mutex_unlock(&hba->hba_access_mutex);
2926 }
2927
2928 static struct configfs_group_operations target_core_hba_group_ops = {
2929         .make_group             = target_core_make_subdev,
2930         .drop_item              = target_core_drop_subdev,
2931 };
2932
2933 CONFIGFS_EATTR_STRUCT(target_core_hba, se_hba);
2934 #define SE_HBA_ATTR(_name, _mode)                               \
2935 static struct target_core_hba_attribute                         \
2936                 target_core_hba_##_name =                       \
2937                 __CONFIGFS_EATTR(_name, _mode,                  \
2938                 target_core_hba_show_attr_##_name,              \
2939                 target_core_hba_store_attr_##_name);
2940
2941 #define SE_HBA_ATTR_RO(_name)                                   \
2942 static struct target_core_hba_attribute                         \
2943                 target_core_hba_##_name =                       \
2944                 __CONFIGFS_EATTR_RO(_name,                      \
2945                 target_core_hba_show_attr_##_name);
2946
2947 static ssize_t target_core_hba_show_attr_hba_info(
2948         struct se_hba *hba,
2949         char *page)
2950 {
2951         return sprintf(page, "HBA Index: %d plugin: %s version: %s\n",
2952                         hba->hba_id, hba->transport->name,
2953                         TARGET_CORE_CONFIGFS_VERSION);
2954 }
2955
2956 SE_HBA_ATTR_RO(hba_info);
2957
2958 static ssize_t target_core_hba_show_attr_hba_mode(struct se_hba *hba,
2959                                 char *page)
2960 {
2961         int hba_mode = 0;
2962
2963         if (hba->hba_flags & HBA_FLAGS_PSCSI_MODE)
2964                 hba_mode = 1;
2965
2966         return sprintf(page, "%d\n", hba_mode);
2967 }
2968
2969 static ssize_t target_core_hba_store_attr_hba_mode(struct se_hba *hba,
2970                                 const char *page, size_t count)
2971 {
2972         struct se_subsystem_api *transport = hba->transport;
2973         unsigned long mode_flag;
2974         int ret;
2975
2976         if (transport->pmode_enable_hba == NULL)
2977                 return -EINVAL;
2978
2979         ret = strict_strtoul(page, 0, &mode_flag);
2980         if (ret < 0) {
2981                 pr_err("Unable to extract hba mode flag: %d\n", ret);
2982                 return -EINVAL;
2983         }
2984
2985         spin_lock(&hba->device_lock);
2986         if (!list_empty(&hba->hba_dev_list)) {
2987                 pr_err("Unable to set hba_mode with active devices\n");
2988                 spin_unlock(&hba->device_lock);
2989                 return -EINVAL;
2990         }
2991         spin_unlock(&hba->device_lock);
2992
2993         ret = transport->pmode_enable_hba(hba, mode_flag);
2994         if (ret < 0)
2995                 return -EINVAL;
2996         if (ret > 0)
2997                 hba->hba_flags |= HBA_FLAGS_PSCSI_MODE;
2998         else if (ret == 0)
2999                 hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE;
3000
3001         return count;
3002 }
3003
3004 SE_HBA_ATTR(hba_mode, S_IRUGO | S_IWUSR);
3005
3006 CONFIGFS_EATTR_OPS(target_core_hba, se_hba, hba_group);
3007
3008 static void target_core_hba_release(struct config_item *item)
3009 {
3010         struct se_hba *hba = container_of(to_config_group(item),
3011                                 struct se_hba, hba_group);
3012         core_delete_hba(hba);
3013 }
3014
3015 static struct configfs_attribute *target_core_hba_attrs[] = {
3016         &target_core_hba_hba_info.attr,
3017         &target_core_hba_hba_mode.attr,
3018         NULL,
3019 };
3020
3021 static struct configfs_item_operations target_core_hba_item_ops = {
3022         .release                = target_core_hba_release,
3023         .show_attribute         = target_core_hba_attr_show,
3024         .store_attribute        = target_core_hba_attr_store,
3025 };
3026
3027 static struct config_item_type target_core_hba_cit = {
3028         .ct_item_ops            = &target_core_hba_item_ops,
3029         .ct_group_ops           = &target_core_hba_group_ops,
3030         .ct_attrs               = target_core_hba_attrs,
3031         .ct_owner               = THIS_MODULE,
3032 };
3033
3034 static struct config_group *target_core_call_addhbatotarget(
3035         struct config_group *group,
3036         const char *name)
3037 {
3038         char *se_plugin_str, *str, *str2;
3039         struct se_hba *hba;
3040         char buf[TARGET_CORE_NAME_MAX_LEN];
3041         unsigned long plugin_dep_id = 0;
3042         int ret;
3043
3044         memset(buf, 0, TARGET_CORE_NAME_MAX_LEN);
3045         if (strlen(name) >= TARGET_CORE_NAME_MAX_LEN) {
3046                 pr_err("Passed *name strlen(): %d exceeds"
3047                         " TARGET_CORE_NAME_MAX_LEN: %d\n", (int)strlen(name),
3048                         TARGET_CORE_NAME_MAX_LEN);
3049                 return ERR_PTR(-ENAMETOOLONG);
3050         }
3051         snprintf(buf, TARGET_CORE_NAME_MAX_LEN, "%s", name);
3052
3053         str = strstr(buf, "_");
3054         if (!str) {
3055                 pr_err("Unable to locate \"_\" for $SUBSYSTEM_PLUGIN_$HOST_ID\n");
3056                 return ERR_PTR(-EINVAL);
3057         }
3058         se_plugin_str = buf;
3059         /*
3060          * Special case for subsystem plugins that have "_" in their names.
3061          * Namely rd_direct and rd_mcp..
3062          */
3063         str2 = strstr(str+1, "_");
3064         if (str2) {
3065                 *str2 = '\0'; /* Terminate for *se_plugin_str */
3066                 str2++; /* Skip to start of plugin dependent ID */
3067                 str = str2;
3068         } else {
3069                 *str = '\0'; /* Terminate for *se_plugin_str */
3070                 str++; /* Skip to start of plugin dependent ID */
3071         }
3072
3073         ret = strict_strtoul(str, 0, &plugin_dep_id);
3074         if (ret < 0) {
3075                 pr_err("strict_strtoul() returned %d for"
3076                                 " plugin_dep_id\n", ret);
3077                 return ERR_PTR(-EINVAL);
3078         }
3079         /*
3080          * Load up TCM subsystem plugins if they have not already been loaded.
3081          */
3082         if (transport_subsystem_check_init() < 0)
3083                 return ERR_PTR(-EINVAL);
3084
3085         hba = core_alloc_hba(se_plugin_str, plugin_dep_id, 0);
3086         if (IS_ERR(hba))
3087                 return ERR_CAST(hba);
3088
3089         config_group_init_type_name(&hba->hba_group, name,
3090                         &target_core_hba_cit);
3091
3092         return &hba->hba_group;
3093 }
3094
3095 static void target_core_call_delhbafromtarget(
3096         struct config_group *group,
3097         struct config_item *item)
3098 {
3099         /*
3100          * core_delete_hba() is called from target_core_hba_item_ops->release()
3101          * -> target_core_hba_release()
3102          */
3103         config_item_put(item);
3104 }
3105
3106 static struct configfs_group_operations target_core_group_ops = {
3107         .make_group     = target_core_call_addhbatotarget,
3108         .drop_item      = target_core_call_delhbafromtarget,
3109 };
3110
3111 static struct config_item_type target_core_cit = {
3112         .ct_item_ops    = NULL,
3113         .ct_group_ops   = &target_core_group_ops,
3114         .ct_attrs       = NULL,
3115         .ct_owner       = THIS_MODULE,
3116 };
3117
3118 /* Stop functions for struct config_item_type target_core_hba_cit */
3119
3120 static int __init target_core_init_configfs(void)
3121 {
3122         struct config_group *target_cg, *hba_cg = NULL, *alua_cg = NULL;
3123         struct config_group *lu_gp_cg = NULL;
3124         struct configfs_subsystem *subsys;
3125         struct t10_alua_lu_gp *lu_gp;
3126         int ret;
3127
3128         pr_debug("TARGET_CORE[0]: Loading Generic Kernel Storage"
3129                 " Engine: %s on %s/%s on "UTS_RELEASE"\n",
3130                 TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine);
3131
3132         subsys = target_core_subsystem[0];
3133         config_group_init(&subsys->su_group);
3134         mutex_init(&subsys->su_mutex);
3135
3136         INIT_LIST_HEAD(&g_tf_list);
3137         mutex_init(&g_tf_lock);
3138         ret = init_se_kmem_caches();
3139         if (ret < 0)
3140                 return ret;
3141         /*
3142          * Create $CONFIGFS/target/core default group for HBA <-> Storage Object
3143          * and ALUA Logical Unit Group and Target Port Group infrastructure.
3144          */
3145         target_cg = &subsys->su_group;
3146         target_cg->default_groups = kzalloc(sizeof(struct config_group) * 2,
3147                                 GFP_KERNEL);
3148         if (!target_cg->default_groups) {
3149                 pr_err("Unable to allocate target_cg->default_groups\n");
3150                 goto out_global;
3151         }
3152
3153         config_group_init_type_name(&target_core_hbagroup,
3154                         "core", &target_core_cit);
3155         target_cg->default_groups[0] = &target_core_hbagroup;
3156         target_cg->default_groups[1] = NULL;
3157         /*
3158          * Create ALUA infrastructure under /sys/kernel/config/target/core/alua/
3159          */
3160         hba_cg = &target_core_hbagroup;
3161         hba_cg->default_groups = kzalloc(sizeof(struct config_group) * 2,
3162                                 GFP_KERNEL);
3163         if (!hba_cg->default_groups) {
3164                 pr_err("Unable to allocate hba_cg->default_groups\n");
3165                 goto out_global;
3166         }
3167         config_group_init_type_name(&alua_group,
3168                         "alua", &target_core_alua_cit);
3169         hba_cg->default_groups[0] = &alua_group;
3170         hba_cg->default_groups[1] = NULL;
3171         /*
3172          * Add ALUA Logical Unit Group and Target Port Group ConfigFS
3173          * groups under /sys/kernel/config/target/core/alua/
3174          */
3175         alua_cg = &alua_group;
3176         alua_cg->default_groups = kzalloc(sizeof(struct config_group) * 2,
3177                         GFP_KERNEL);
3178         if (!alua_cg->default_groups) {
3179                 pr_err("Unable to allocate alua_cg->default_groups\n");
3180                 goto out_global;
3181         }
3182
3183         config_group_init_type_name(&alua_lu_gps_group,
3184                         "lu_gps", &target_core_alua_lu_gps_cit);
3185         alua_cg->default_groups[0] = &alua_lu_gps_group;
3186         alua_cg->default_groups[1] = NULL;
3187         /*
3188          * Add core/alua/lu_gps/default_lu_gp
3189          */
3190         lu_gp = core_alua_allocate_lu_gp("default_lu_gp", 1);
3191         if (IS_ERR(lu_gp))
3192                 goto out_global;
3193
3194         lu_gp_cg = &alua_lu_gps_group;
3195         lu_gp_cg->default_groups = kzalloc(sizeof(struct config_group) * 2,
3196                         GFP_KERNEL);
3197         if (!lu_gp_cg->default_groups) {
3198                 pr_err("Unable to allocate lu_gp_cg->default_groups\n");
3199                 goto out_global;
3200         }
3201
3202         config_group_init_type_name(&lu_gp->lu_gp_group, "default_lu_gp",
3203                                 &target_core_alua_lu_gp_cit);
3204         lu_gp_cg->default_groups[0] = &lu_gp->lu_gp_group;
3205         lu_gp_cg->default_groups[1] = NULL;
3206         default_lu_gp = lu_gp;
3207         /*
3208          * Register the target_core_mod subsystem with configfs.
3209          */
3210         ret = configfs_register_subsystem(subsys);
3211         if (ret < 0) {
3212                 pr_err("Error %d while registering subsystem %s\n",
3213                         ret, subsys->su_group.cg_item.ci_namebuf);
3214                 goto out_global;
3215         }
3216         pr_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric"
3217                 " Infrastructure: "TARGET_CORE_CONFIGFS_VERSION" on %s/%s"
3218                 " on "UTS_RELEASE"\n", utsname()->sysname, utsname()->machine);
3219         /*
3220          * Register built-in RAMDISK subsystem logic for virtual LUN 0
3221          */
3222         ret = rd_module_init();
3223         if (ret < 0)
3224                 goto out;
3225
3226         if (core_dev_setup_virtual_lun0() < 0)
3227                 goto out;
3228
3229         return 0;
3230
3231 out:
3232         configfs_unregister_subsystem(subsys);
3233         core_dev_release_virtual_lun0();
3234         rd_module_exit();
3235 out_global:
3236         if (default_lu_gp) {
3237                 core_alua_free_lu_gp(default_lu_gp);
3238                 default_lu_gp = NULL;
3239         }
3240         if (lu_gp_cg)
3241                 kfree(lu_gp_cg->default_groups);
3242         if (alua_cg)
3243                 kfree(alua_cg->default_groups);
3244         if (hba_cg)
3245                 kfree(hba_cg->default_groups);
3246         kfree(target_cg->default_groups);
3247         release_se_kmem_caches();
3248         return ret;
3249 }
3250
3251 static void __exit target_core_exit_configfs(void)
3252 {
3253         struct configfs_subsystem *subsys;
3254         struct config_group *hba_cg, *alua_cg, *lu_gp_cg;
3255         struct config_item *item;
3256         int i;
3257
3258         subsys = target_core_subsystem[0];
3259
3260         lu_gp_cg = &alua_lu_gps_group;
3261         for (i = 0; lu_gp_cg->default_groups[i]; i++) {
3262                 item = &lu_gp_cg->default_groups[i]->cg_item;
3263                 lu_gp_cg->default_groups[i] = NULL;
3264                 config_item_put(item);
3265         }
3266         kfree(lu_gp_cg->default_groups);
3267         lu_gp_cg->default_groups = NULL;
3268
3269         alua_cg = &alua_group;
3270         for (i = 0; alua_cg->default_groups[i]; i++) {
3271                 item = &alua_cg->default_groups[i]->cg_item;
3272                 alua_cg->default_groups[i] = NULL;
3273                 config_item_put(item);
3274         }
3275         kfree(alua_cg->default_groups);
3276         alua_cg->default_groups = NULL;
3277
3278         hba_cg = &target_core_hbagroup;
3279         for (i = 0; hba_cg->default_groups[i]; i++) {
3280                 item = &hba_cg->default_groups[i]->cg_item;
3281                 hba_cg->default_groups[i] = NULL;
3282                 config_item_put(item);
3283         }
3284         kfree(hba_cg->default_groups);
3285         hba_cg->default_groups = NULL;
3286         /*
3287          * We expect subsys->su_group.default_groups to be released
3288          * by configfs subsystem provider logic..
3289          */
3290         configfs_unregister_subsystem(subsys);
3291         kfree(subsys->su_group.default_groups);
3292
3293         core_alua_free_lu_gp(default_lu_gp);
3294         default_lu_gp = NULL;
3295
3296         pr_debug("TARGET_CORE[0]: Released ConfigFS Fabric"
3297                         " Infrastructure\n");
3298
3299         core_dev_release_virtual_lun0();
3300         rd_module_exit();
3301         release_se_kmem_caches();
3302 }
3303
3304 MODULE_DESCRIPTION("Target_Core_Mod/ConfigFS");
3305 MODULE_AUTHOR("nab@Linux-iSCSI.org");
3306 MODULE_LICENSE("GPL");
3307
3308 module_init(target_core_init_configfs);
3309 module_exit(target_core_exit_configfs);