drivers/target/target_core_fabric_configfs.c

   1 /*******************************************************************************
   2 * Filename: target_core_fabric_configfs.c
   3  *
   4  * This file contains generic fabric module configfs infrastructure for
   5  * TCM v4.x code
   6  *
   7  * (c) Copyright 2010-2013 Datera, Inc.
   8  *
   9  * Nicholas A. Bellinger <nab@linux-iscsi.org>
  10 *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  ****************************************************************************/
  21
  22 #include <linux/module.h>
  23 #include <linux/moduleparam.h>
  24 #include <linux/utsname.h>
  25 #include <linux/init.h>
  26 #include <linux/fs.h>
  27 #include <linux/namei.h>
  28 #include <linux/slab.h>
  29 #include <linux/types.h>
  30 #include <linux/delay.h>
  31 #include <linux/unistd.h>
  32 #include <linux/string.h>
  33 #include <linux/syscalls.h>
  34 #include <linux/configfs.h>
  35
  36 #include <target/target_core_base.h>
  37 #include <target/target_core_backend.h>
  38 #include <target/target_core_fabric.h>
  39
  40 #include "target_core_internal.h"
  41 #include "target_core_alua.h"
  42 #include "target_core_pr.h"
  43
  44 #define TF_CIT_SETUP(_name, _item_ops, _group_ops, _attrs)              \
  45 static void target_fabric_setup_##_name##_cit(struct target_fabric_configfs *tf) \
  46 {                                                                       \
  47         struct config_item_type *cit = &tf->tf_##_name##_cit;           \
  48                                                                         \
  49         cit->ct_item_ops = _item_ops;                                   \
  50         cit->ct_group_ops = _group_ops;                                 \
  51         cit->ct_attrs = _attrs;                                         \
  52         cit->ct_owner = tf->tf_ops->module;                             \
  53         pr_debug("Setup generic %s\n", __stringify(_name));             \
  54 }
  55
  56 #define TF_CIT_SETUP_DRV(_name, _item_ops, _group_ops)          \
  57 static void target_fabric_setup_##_name##_cit(struct target_fabric_configfs *tf) \
  58 {                                                                       \
  59         struct config_item_type *cit = &tf->tf_##_name##_cit;           \
  60         struct configfs_attribute **attrs = tf->tf_ops->tfc_##_name##_attrs; \
  61                                                                         \
  62         cit->ct_item_ops = _item_ops;                                   \
  63         cit->ct_group_ops = _group_ops;                                 \
  64         cit->ct_attrs = attrs;                                          \
  65         cit->ct_owner = tf->tf_ops->module;                             \
  66         pr_debug("Setup generic %s\n", __stringify(_name));             \
  67 }
  68
  69 static struct configfs_item_operations target_fabric_port_item_ops;
  70
  71 /* Start of tfc_tpg_mappedlun_cit */
  72
  73 static int target_fabric_mappedlun_link(
  74         struct config_item *lun_acl_ci,
  75         struct config_item *lun_ci)
  76 {
  77         struct se_dev_entry *deve;
  78         struct se_lun *lun;
  79         struct se_lun_acl *lacl = container_of(to_config_group(lun_acl_ci),
  80                         struct se_lun_acl, se_lun_group);
  81         struct se_portal_group *se_tpg;
  82         struct config_item *nacl_ci, *tpg_ci, *tpg_ci_s, *wwn_ci, *wwn_ci_s;
  83         bool lun_access_ro;
  84
  85         if (!lun_ci->ci_type ||
  86             lun_ci->ci_type->ct_item_ops != &target_fabric_port_item_ops) {
  87                 pr_err("Bad lun_ci, not a valid lun_ci pointer: %p\n", lun_ci);
  88                 return -EFAULT;
  89         }
  90         lun = container_of(to_config_group(lun_ci), struct se_lun, lun_group);
  91
  92         /*
  93          * Ensure that the source port exists
  94          */
  95         if (!lun->lun_se_dev) {
  96                 pr_err("Source se_lun->lun_se_dev does not exist\n");
  97                 return -EINVAL;
  98         }
  99         if (lun->lun_shutdown) {
 100                 pr_err("Unable to create mappedlun symlink because"
 101                         " lun->lun_shutdown=true\n");
 102                 return -EINVAL;
 103         }
 104         se_tpg = lun->lun_tpg;
 105
 106         nacl_ci = &lun_acl_ci->ci_parent->ci_group->cg_item;
 107         tpg_ci = &nacl_ci->ci_group->cg_item;
 108         wwn_ci = &tpg_ci->ci_group->cg_item;
 109         tpg_ci_s = &lun_ci->ci_parent->ci_group->cg_item;
 110         wwn_ci_s = &tpg_ci_s->ci_group->cg_item;
 111         /*
 112          * Make sure the SymLink is going to the same $FABRIC/$WWN/tpgt_$TPGT
 113          */
 114         if (strcmp(config_item_name(wwn_ci), config_item_name(wwn_ci_s))) {
 115                 pr_err("Illegal Initiator ACL SymLink outside of %s\n",
 116                         config_item_name(wwn_ci));
 117                 return -EINVAL;
 118         }
 119         if (strcmp(config_item_name(tpg_ci), config_item_name(tpg_ci_s))) {
 120                 pr_err("Illegal Initiator ACL Symlink outside of %s"
 121                         " TPGT: %s\n", config_item_name(wwn_ci),
 122                         config_item_name(tpg_ci));
 123                 return -EINVAL;
 124         }
 125         /*
 126          * If this struct se_node_acl was dynamically generated with
 127          * tpg_1/attrib/generate_node_acls=1, use the existing
 128          * deve->lun_access_ro value, which will be true when
 129          * tpg_1/attrib/demo_mode_write_protect=1
 130          */
 131         rcu_read_lock();
 132         deve = target_nacl_find_deve(lacl->se_lun_nacl, lacl->mapped_lun);
 133         if (deve)
 134                 lun_access_ro = deve->lun_access_ro;
 135         else
 136                 lun_access_ro =
 137                         (se_tpg->se_tpg_tfo->tpg_check_prod_mode_write_protect(
 138                                 se_tpg)) ? true : false;
 139         rcu_read_unlock();
 140         /*
 141          * Determine the actual mapped LUN value user wants..
 142          *
 143          * This value is what the SCSI Initiator actually sees the
 144          * $FABRIC/$WWPN/$TPGT/lun/lun_* as on their SCSI Initiator Ports.
 145          */
 146         return core_dev_add_initiator_node_lun_acl(se_tpg, lacl, lun, lun_access_ro);
 147 }
 148
 149 static void target_fabric_mappedlun_unlink(
 150         struct config_item *lun_acl_ci,
 151         struct config_item *lun_ci)
 152 {
 153         struct se_lun_acl *lacl = container_of(to_config_group(lun_acl_ci),
 154                         struct se_lun_acl, se_lun_group);
 155         struct se_lun *lun = container_of(to_config_group(lun_ci),
 156                         struct se_lun, lun_group);
 157
 158         core_dev_del_initiator_node_lun_acl(lun, lacl);
 159 }
 160
 161 static struct se_lun_acl *item_to_lun_acl(struct config_item *item)
 162 {
 163         return container_of(to_config_group(item), struct se_lun_acl,
 164                         se_lun_group);
 165 }
 166
 167 static ssize_t target_fabric_mappedlun_write_protect_show(
 168                 struct config_item *item, char *page)
 169 {
 170         struct se_lun_acl *lacl = item_to_lun_acl(item);
 171         struct se_node_acl *se_nacl = lacl->se_lun_nacl;
 172         struct se_dev_entry *deve;
 173         ssize_t len = 0;
 174
 175         rcu_read_lock();
 176         deve = target_nacl_find_deve(se_nacl, lacl->mapped_lun);
 177         if (deve) {
 178                 len = sprintf(page, "%d\n", deve->lun_access_ro);
 179         }
 180         rcu_read_unlock();
 181
 182         return len;
 183 }
 184
 185 static ssize_t target_fabric_mappedlun_write_protect_store(
 186                 struct config_item *item, const char *page, size_t count)
 187 {
 188         struct se_lun_acl *lacl = item_to_lun_acl(item);
 189         struct se_node_acl *se_nacl = lacl->se_lun_nacl;
 190         struct se_portal_group *se_tpg = se_nacl->se_tpg;
 191         unsigned long wp;
 192         int ret;
 193
 194         ret = kstrtoul(page, 0, &wp);
 195         if (ret)
 196                 return ret;
 197
 198         if ((wp != 1) && (wp != 0))
 199                 return -EINVAL;
 200
 201         /* wp=1 means lun_access_ro=true */
 202         core_update_device_list_access(lacl->mapped_lun, wp, lacl->se_lun_nacl);
 203
 204         pr_debug("%s_ConfigFS: Changed Initiator ACL: %s"
 205                 " Mapped LUN: %llu Write Protect bit to %s\n",
 206                 se_tpg->se_tpg_tfo->get_fabric_name(),
 207                 se_nacl->initiatorname, lacl->mapped_lun, (wp) ? "ON" : "OFF");
 208
 209         return count;
 210
 211 }
 212
 213 CONFIGFS_ATTR(target_fabric_mappedlun_, write_protect);
 214
 215 static struct configfs_attribute *target_fabric_mappedlun_attrs[] = {
 216         &target_fabric_mappedlun_attr_write_protect,
 217         NULL,
 218 };
 219
 220 static void target_fabric_mappedlun_release(struct config_item *item)
 221 {
 222         struct se_lun_acl *lacl = container_of(to_config_group(item),
 223                                 struct se_lun_acl, se_lun_group);
 224         struct se_portal_group *se_tpg = lacl->se_lun_nacl->se_tpg;
 225
 226         core_dev_free_initiator_node_lun_acl(se_tpg, lacl);
 227 }
 228
 229 static struct configfs_item_operations target_fabric_mappedlun_item_ops = {
 230         .release                = target_fabric_mappedlun_release,
 231         .allow_link             = target_fabric_mappedlun_link,
 232         .drop_link              = target_fabric_mappedlun_unlink,
 233 };
 234
 235 TF_CIT_SETUP(tpg_mappedlun, &target_fabric_mappedlun_item_ops, NULL,
 236                 target_fabric_mappedlun_attrs);
 237
 238 /* End of tfc_tpg_mappedlun_cit */
 239
 240 /* Start of tfc_tpg_mappedlun_port_cit */
 241
 242 static struct config_group *target_core_mappedlun_stat_mkdir(
 243         struct config_group *group,
 244         const char *name)
 245 {
 246         return ERR_PTR(-ENOSYS);
 247 }
 248
 249 static void target_core_mappedlun_stat_rmdir(
 250         struct config_group *group,
 251         struct config_item *item)
 252 {
 253         return;
 254 }
 255
 256 static struct configfs_group_operations target_fabric_mappedlun_stat_group_ops = {
 257         .make_group             = target_core_mappedlun_stat_mkdir,
 258         .drop_item              = target_core_mappedlun_stat_rmdir,
 259 };
 260
 261 TF_CIT_SETUP(tpg_mappedlun_stat, NULL, &target_fabric_mappedlun_stat_group_ops,
 262                 NULL);
 263
 264 /* End of tfc_tpg_mappedlun_port_cit */
 265
 266 TF_CIT_SETUP_DRV(tpg_nacl_attrib, NULL, NULL);
 267 TF_CIT_SETUP_DRV(tpg_nacl_auth, NULL, NULL);
 268 TF_CIT_SETUP_DRV(tpg_nacl_param, NULL, NULL);
 269
 270 /* Start of tfc_tpg_nacl_base_cit */
 271
 272 static struct config_group *target_fabric_make_mappedlun(
 273         struct config_group *group,
 274         const char *name)
 275 {
 276         struct se_node_acl *se_nacl = container_of(group,
 277                         struct se_node_acl, acl_group);
 278         struct se_portal_group *se_tpg = se_nacl->se_tpg;
 279         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
 280         struct se_lun_acl *lacl = NULL;
 281         char *buf;
 282         unsigned long long mapped_lun;
 283         int ret = 0;
 284
 285         buf = kzalloc(strlen(name) + 1, GFP_KERNEL);
 286         if (!buf) {
 287                 pr_err("Unable to allocate memory for name buf\n");
 288                 return ERR_PTR(-ENOMEM);
 289         }
 290         snprintf(buf, strlen(name) + 1, "%s", name);
 291         /*
 292          * Make sure user is creating iscsi/$IQN/$TPGT/acls/$INITIATOR/lun_$ID.
 293          */
 294         if (strstr(buf, "lun_") != buf) {
 295                 pr_err("Unable to locate \"lun_\" from buf: %s"
 296                         " name: %s\n", buf, name);
 297                 ret = -EINVAL;
 298                 goto out;
 299         }
 300         /*
 301          * Determine the Mapped LUN value.  This is what the SCSI Initiator
 302          * Port will actually see.
 303          */
 304         ret = kstrtoull(buf + 4, 0, &mapped_lun);
 305         if (ret)
 306                 goto out;
 307
 308         lacl = core_dev_init_initiator_node_lun_acl(se_tpg, se_nacl,
 309                         mapped_lun, &ret);
 310         if (!lacl) {
 311                 ret = -EINVAL;
 312                 goto out;
 313         }
 314
 315         config_group_init_type_name(&lacl->se_lun_group, name,
 316                         &tf->tf_tpg_mappedlun_cit);
 317
 318         config_group_init_type_name(&lacl->ml_stat_grps.stat_group,
 319                         "statistics", &tf->tf_tpg_mappedlun_stat_cit);
 320         configfs_add_default_group(&lacl->ml_stat_grps.stat_group,
 321                         &lacl->se_lun_group);
 322
 323         target_stat_setup_mappedlun_default_groups(lacl);
 324
 325         kfree(buf);
 326         return &lacl->se_lun_group;
 327 out:
 328         kfree(lacl);
 329         kfree(buf);
 330         return ERR_PTR(ret);
 331 }
 332
 333 static void target_fabric_drop_mappedlun(
 334         struct config_group *group,
 335         struct config_item *item)
 336 {
 337         struct se_lun_acl *lacl = container_of(to_config_group(item),
 338                         struct se_lun_acl, se_lun_group);
 339
 340         configfs_remove_default_groups(&lacl->ml_stat_grps.stat_group);
 341         configfs_remove_default_groups(&lacl->se_lun_group);
 342
 343         config_item_put(item);
 344 }
 345
 346 static void target_fabric_nacl_base_release(struct config_item *item)
 347 {
 348         struct se_node_acl *se_nacl = container_of(to_config_group(item),
 349                         struct se_node_acl, acl_group);
 350
 351         configfs_remove_default_groups(&se_nacl->acl_fabric_stat_group);
 352         core_tpg_del_initiator_node_acl(se_nacl);
 353 }
 354
 355 static struct configfs_item_operations target_fabric_nacl_base_item_ops = {
 356         .release                = target_fabric_nacl_base_release,
 357 };
 358
 359 static struct configfs_group_operations target_fabric_nacl_base_group_ops = {
 360         .make_group             = target_fabric_make_mappedlun,
 361         .drop_item              = target_fabric_drop_mappedlun,
 362 };
 363
 364 TF_CIT_SETUP_DRV(tpg_nacl_base, &target_fabric_nacl_base_item_ops,
 365                 &target_fabric_nacl_base_group_ops);
 366
 367 /* End of tfc_tpg_nacl_base_cit */
 368
 369 /* Start of tfc_node_fabric_stats_cit */
 370 /*
 371  * This is used as a placeholder for struct se_node_acl->acl_fabric_stat_group
 372  * to allow fabrics access to ->acl_fabric_stat_group->default_groups[]
 373  */
 374 TF_CIT_SETUP(tpg_nacl_stat, NULL, NULL, NULL);
 375
 376 /* End of tfc_wwn_fabric_stats_cit */
 377
 378 /* Start of tfc_tpg_nacl_cit */
 379
 380 static struct config_group *target_fabric_make_nodeacl(
 381         struct config_group *group,
 382         const char *name)
 383 {
 384         struct se_portal_group *se_tpg = container_of(group,
 385                         struct se_portal_group, tpg_acl_group);
 386         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
 387         struct se_node_acl *se_nacl;
 388
 389         se_nacl = core_tpg_add_initiator_node_acl(se_tpg, name);
 390         if (IS_ERR(se_nacl))
 391                 return ERR_CAST(se_nacl);
 392
 393         config_group_init_type_name(&se_nacl->acl_group, name,
 394                         &tf->tf_tpg_nacl_base_cit);
 395
 396         config_group_init_type_name(&se_nacl->acl_attrib_group, "attrib",
 397                         &tf->tf_tpg_nacl_attrib_cit);
 398         configfs_add_default_group(&se_nacl->acl_attrib_group,
 399                         &se_nacl->acl_group);
 400
 401         config_group_init_type_name(&se_nacl->acl_auth_group, "auth",
 402                         &tf->tf_tpg_nacl_auth_cit);
 403         configfs_add_default_group(&se_nacl->acl_auth_group,
 404                         &se_nacl->acl_group);
 405
 406         config_group_init_type_name(&se_nacl->acl_param_group, "param",
 407                         &tf->tf_tpg_nacl_param_cit);
 408         configfs_add_default_group(&se_nacl->acl_param_group,
 409                         &se_nacl->acl_group);
 410
 411         config_group_init_type_name(&se_nacl->acl_fabric_stat_group,
 412                         "fabric_statistics", &tf->tf_tpg_nacl_stat_cit);
 413         configfs_add_default_group(&se_nacl->acl_fabric_stat_group,
 414                         &se_nacl->acl_group);
 415
 416         if (tf->tf_ops->fabric_init_nodeacl) {
 417                 int ret = tf->tf_ops->fabric_init_nodeacl(se_nacl, name);
 418                 if (ret) {
 419                         configfs_remove_default_groups(&se_nacl->acl_fabric_stat_group);
 420                         core_tpg_del_initiator_node_acl(se_nacl);
 421                         return ERR_PTR(ret);
 422                 }
 423         }
 424
 425         return &se_nacl->acl_group;
 426 }
 427
 428 static void target_fabric_drop_nodeacl(
 429         struct config_group *group,
 430         struct config_item *item)
 431 {
 432         struct se_node_acl *se_nacl = container_of(to_config_group(item),
 433                         struct se_node_acl, acl_group);
 434
 435         configfs_remove_default_groups(&se_nacl->acl_group);
 436
 437         /*
 438          * struct se_node_acl free is done in target_fabric_nacl_base_release()
 439          */
 440         config_item_put(item);
 441 }
 442
 443 static struct configfs_group_operations target_fabric_nacl_group_ops = {
 444         .make_group     = target_fabric_make_nodeacl,
 445         .drop_item      = target_fabric_drop_nodeacl,
 446 };
 447
 448 TF_CIT_SETUP(tpg_nacl, NULL, &target_fabric_nacl_group_ops, NULL);
 449
 450 /* End of tfc_tpg_nacl_cit */
 451
 452 /* Start of tfc_tpg_np_base_cit */
 453
 454 static void target_fabric_np_base_release(struct config_item *item)
 455 {
 456         struct se_tpg_np *se_tpg_np = container_of(to_config_group(item),
 457                                 struct se_tpg_np, tpg_np_group);
 458         struct se_portal_group *se_tpg = se_tpg_np->tpg_np_parent;
 459         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
 460
 461         tf->tf_ops->fabric_drop_np(se_tpg_np);
 462 }
 463
 464 static struct configfs_item_operations target_fabric_np_base_item_ops = {
 465         .release                = target_fabric_np_base_release,
 466 };
 467
 468 TF_CIT_SETUP_DRV(tpg_np_base, &target_fabric_np_base_item_ops, NULL);
 469
 470 /* End of tfc_tpg_np_base_cit */
 471
 472 /* Start of tfc_tpg_np_cit */
 473
 474 static struct config_group *target_fabric_make_np(
 475         struct config_group *group,
 476         const char *name)
 477 {
 478         struct se_portal_group *se_tpg = container_of(group,
 479                                 struct se_portal_group, tpg_np_group);
 480         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
 481         struct se_tpg_np *se_tpg_np;
 482
 483         if (!tf->tf_ops->fabric_make_np) {
 484                 pr_err("tf->tf_ops.fabric_make_np is NULL\n");
 485                 return ERR_PTR(-ENOSYS);
 486         }
 487
 488         se_tpg_np = tf->tf_ops->fabric_make_np(se_tpg, group, name);
 489         if (!se_tpg_np || IS_ERR(se_tpg_np))
 490                 return ERR_PTR(-EINVAL);
 491
 492         se_tpg_np->tpg_np_parent = se_tpg;
 493         config_group_init_type_name(&se_tpg_np->tpg_np_group, name,
 494                         &tf->tf_tpg_np_base_cit);
 495
 496         return &se_tpg_np->tpg_np_group;
 497 }
 498
 499 static void target_fabric_drop_np(
 500         struct config_group *group,
 501         struct config_item *item)
 502 {
 503         /*
 504          * struct se_tpg_np is released via target_fabric_np_base_release()
 505          */
 506         config_item_put(item);
 507 }
 508
 509 static struct configfs_group_operations target_fabric_np_group_ops = {
 510         .make_group     = &target_fabric_make_np,
 511         .drop_item      = &target_fabric_drop_np,
 512 };
 513
 514 TF_CIT_SETUP(tpg_np, NULL, &target_fabric_np_group_ops, NULL);
 515
 516 /* End of tfc_tpg_np_cit */
 517
 518 /* Start of tfc_tpg_port_cit */
 519
 520 static struct se_lun *item_to_lun(struct config_item *item)
 521 {
 522         return container_of(to_config_group(item), struct se_lun,
 523                         lun_group);
 524 }
 525
 526 static ssize_t target_fabric_port_alua_tg_pt_gp_show(struct config_item *item,
 527                 char *page)
 528 {
 529         struct se_lun *lun = item_to_lun(item);
 530
 531         if (!lun || !lun->lun_se_dev)
 532                 return -ENODEV;
 533
 534         return core_alua_show_tg_pt_gp_info(lun, page);
 535 }
 536
 537 static ssize_t target_fabric_port_alua_tg_pt_gp_store(struct config_item *item,
 538                 const char *page, size_t count)
 539 {
 540         struct se_lun *lun = item_to_lun(item);
 541
 542         if (!lun || !lun->lun_se_dev)
 543                 return -ENODEV;
 544
 545         return core_alua_store_tg_pt_gp_info(lun, page, count);
 546 }
 547
 548 static ssize_t target_fabric_port_alua_tg_pt_offline_show(
 549                 struct config_item *item, char *page)
 550 {
 551         struct se_lun *lun = item_to_lun(item);
 552
 553         if (!lun || !lun->lun_se_dev)
 554                 return -ENODEV;
 555
 556         return core_alua_show_offline_bit(lun, page);
 557 }
 558
 559 static ssize_t target_fabric_port_alua_tg_pt_offline_store(
 560                 struct config_item *item, const char *page, size_t count)
 561 {
 562         struct se_lun *lun = item_to_lun(item);
 563
 564         if (!lun || !lun->lun_se_dev)
 565                 return -ENODEV;
 566
 567         return core_alua_store_offline_bit(lun, page, count);
 568 }
 569
 570 static ssize_t target_fabric_port_alua_tg_pt_status_show(
 571                 struct config_item *item, char *page)
 572 {
 573         struct se_lun *lun = item_to_lun(item);
 574
 575         if (!lun || !lun->lun_se_dev)
 576                 return -ENODEV;
 577
 578         return core_alua_show_secondary_status(lun, page);
 579 }
 580
 581 static ssize_t target_fabric_port_alua_tg_pt_status_store(
 582                 struct config_item *item, const char *page, size_t count)
 583 {
 584         struct se_lun *lun = item_to_lun(item);
 585
 586         if (!lun || !lun->lun_se_dev)
 587                 return -ENODEV;
 588
 589         return core_alua_store_secondary_status(lun, page, count);
 590 }
 591
 592 static ssize_t target_fabric_port_alua_tg_pt_write_md_show(
 593                 struct config_item *item, char *page)
 594 {
 595         struct se_lun *lun = item_to_lun(item);
 596
 597         if (!lun || !lun->lun_se_dev)
 598                 return -ENODEV;
 599
 600         return core_alua_show_secondary_write_metadata(lun, page);
 601 }
 602
 603 static ssize_t target_fabric_port_alua_tg_pt_write_md_store(
 604                 struct config_item *item, const char *page, size_t count)
 605 {
 606         struct se_lun *lun = item_to_lun(item);
 607
 608         if (!lun || !lun->lun_se_dev)
 609                 return -ENODEV;
 610
 611         return core_alua_store_secondary_write_metadata(lun, page, count);
 612 }
 613
 614 CONFIGFS_ATTR(target_fabric_port_, alua_tg_pt_gp);
 615 CONFIGFS_ATTR(target_fabric_port_, alua_tg_pt_offline);
 616 CONFIGFS_ATTR(target_fabric_port_, alua_tg_pt_status);
 617 CONFIGFS_ATTR(target_fabric_port_, alua_tg_pt_write_md);
 618
 619 static struct configfs_attribute *target_fabric_port_attrs[] = {
 620         &target_fabric_port_attr_alua_tg_pt_gp,
 621         &target_fabric_port_attr_alua_tg_pt_offline,
 622         &target_fabric_port_attr_alua_tg_pt_status,
 623         &target_fabric_port_attr_alua_tg_pt_write_md,
 624         NULL,
 625 };
 626
 627 static int target_fabric_port_link(
 628         struct config_item *lun_ci,
 629         struct config_item *se_dev_ci)
 630 {
 631         struct config_item *tpg_ci;
 632         struct se_lun *lun = container_of(to_config_group(lun_ci),
 633                                 struct se_lun, lun_group);
 634         struct se_portal_group *se_tpg;
 635         struct se_device *dev;
 636         struct target_fabric_configfs *tf;
 637         int ret;
 638
 639         if (!se_dev_ci->ci_type ||
 640             se_dev_ci->ci_type->ct_item_ops != &target_core_dev_item_ops) {
 641                 pr_err("Bad se_dev_ci, not a valid se_dev_ci pointer: %p\n", se_dev_ci);
 642                 return -EFAULT;
 643         }
 644         dev = container_of(to_config_group(se_dev_ci), struct se_device, dev_group);
 645
 646         if (!target_dev_configured(dev)) {
 647                 pr_err("se_device not configured yet, cannot port link\n");
 648                 return -ENODEV;
 649         }
 650
 651         tpg_ci = &lun_ci->ci_parent->ci_group->cg_item;
 652         se_tpg = container_of(to_config_group(tpg_ci),
 653                                 struct se_portal_group, tpg_group);
 654         tf = se_tpg->se_tpg_wwn->wwn_tf;
 655
 656         if (lun->lun_se_dev !=  NULL) {
 657                 pr_err("Port Symlink already exists\n");
 658                 return -EEXIST;
 659         }
 660
 661         ret = core_dev_add_lun(se_tpg, dev, lun);
 662         if (ret) {
 663                 pr_err("core_dev_add_lun() failed: %d\n", ret);
 664                 goto out;
 665         }
 666
 667         if (tf->tf_ops->fabric_post_link) {
 668                 /*
 669                  * Call the optional fabric_post_link() to allow a
 670                  * fabric module to setup any additional state once
 671                  * core_dev_add_lun() has been called..
 672                  */
 673                 tf->tf_ops->fabric_post_link(se_tpg, lun);
 674         }
 675
 676         return 0;
 677 out:
 678         return ret;
 679 }
 680
 681 static void target_fabric_port_unlink(
 682         struct config_item *lun_ci,
 683         struct config_item *se_dev_ci)
 684 {
 685         struct se_lun *lun = container_of(to_config_group(lun_ci),
 686                                 struct se_lun, lun_group);
 687         struct se_portal_group *se_tpg = lun->lun_tpg;
 688         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
 689
 690         if (tf->tf_ops->fabric_pre_unlink) {
 691                 /*
 692                  * Call the optional fabric_pre_unlink() to allow a
 693                  * fabric module to release any additional stat before
 694                  * core_dev_del_lun() is called.
 695                 */
 696                 tf->tf_ops->fabric_pre_unlink(se_tpg, lun);
 697         }
 698
 699         core_dev_del_lun(se_tpg, lun);
 700 }
 701
 702 static void target_fabric_port_release(struct config_item *item)
 703 {
 704         struct se_lun *lun = container_of(to_config_group(item),
 705                                           struct se_lun, lun_group);
 706
 707         kfree_rcu(lun, rcu_head);
 708 }
 709
 710 static struct configfs_item_operations target_fabric_port_item_ops = {
 711         .release                = target_fabric_port_release,
 712         .allow_link             = target_fabric_port_link,
 713         .drop_link              = target_fabric_port_unlink,
 714 };
 715
 716 TF_CIT_SETUP(tpg_port, &target_fabric_port_item_ops, NULL, target_fabric_port_attrs);
 717
 718 /* End of tfc_tpg_port_cit */
 719
 720 /* Start of tfc_tpg_port_stat_cit */
 721
 722 static struct config_group *target_core_port_stat_mkdir(
 723         struct config_group *group,
 724         const char *name)
 725 {
 726         return ERR_PTR(-ENOSYS);
 727 }
 728
 729 static void target_core_port_stat_rmdir(
 730         struct config_group *group,
 731         struct config_item *item)
 732 {
 733         return;
 734 }
 735
 736 static struct configfs_group_operations target_fabric_port_stat_group_ops = {
 737         .make_group             = target_core_port_stat_mkdir,
 738         .drop_item              = target_core_port_stat_rmdir,
 739 };
 740
 741 TF_CIT_SETUP(tpg_port_stat, NULL, &target_fabric_port_stat_group_ops, NULL);
 742
 743 /* End of tfc_tpg_port_stat_cit */
 744
 745 /* Start of tfc_tpg_lun_cit */
 746
 747 static struct config_group *target_fabric_make_lun(
 748         struct config_group *group,
 749         const char *name)
 750 {
 751         struct se_lun *lun;
 752         struct se_portal_group *se_tpg = container_of(group,
 753                         struct se_portal_group, tpg_lun_group);
 754         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
 755         unsigned long long unpacked_lun;
 756         int errno;
 757
 758         if (strstr(name, "lun_") != name) {
 759                 pr_err("Unable to locate \'_\" in"
 760                                 " \"lun_$LUN_NUMBER\"\n");
 761                 return ERR_PTR(-EINVAL);
 762         }
 763         errno = kstrtoull(name + 4, 0, &unpacked_lun);
 764         if (errno)
 765                 return ERR_PTR(errno);
 766
 767         lun = core_tpg_alloc_lun(se_tpg, unpacked_lun);
 768         if (IS_ERR(lun))
 769                 return ERR_CAST(lun);
 770
 771         config_group_init_type_name(&lun->lun_group, name,
 772                         &tf->tf_tpg_port_cit);
 773
 774         config_group_init_type_name(&lun->port_stat_grps.stat_group,
 775                         "statistics", &tf->tf_tpg_port_stat_cit);
 776         configfs_add_default_group(&lun->port_stat_grps.stat_group,
 777                         &lun->lun_group);
 778
 779         target_stat_setup_port_default_groups(lun);
 780
 781         return &lun->lun_group;
 782 }
 783
 784 static void target_fabric_drop_lun(
 785         struct config_group *group,
 786         struct config_item *item)
 787 {
 788         struct se_lun *lun = container_of(to_config_group(item),
 789                                 struct se_lun, lun_group);
 790
 791         configfs_remove_default_groups(&lun->port_stat_grps.stat_group);
 792         configfs_remove_default_groups(&lun->lun_group);
 793
 794         config_item_put(item);
 795 }
 796
 797 static struct configfs_group_operations target_fabric_lun_group_ops = {
 798         .make_group     = &target_fabric_make_lun,
 799         .drop_item      = &target_fabric_drop_lun,
 800 };
 801
 802 TF_CIT_SETUP(tpg_lun, NULL, &target_fabric_lun_group_ops, NULL);
 803
 804 /* End of tfc_tpg_lun_cit */
 805
 806 TF_CIT_SETUP_DRV(tpg_attrib, NULL, NULL);
 807 TF_CIT_SETUP_DRV(tpg_auth, NULL, NULL);
 808 TF_CIT_SETUP_DRV(tpg_param, NULL, NULL);
 809
 810 /* Start of tfc_tpg_base_cit */
 811
 812 static void target_fabric_tpg_release(struct config_item *item)
 813 {
 814         struct se_portal_group *se_tpg = container_of(to_config_group(item),
 815                         struct se_portal_group, tpg_group);
 816         struct se_wwn *wwn = se_tpg->se_tpg_wwn;
 817         struct target_fabric_configfs *tf = wwn->wwn_tf;
 818
 819         tf->tf_ops->fabric_drop_tpg(se_tpg);
 820 }
 821
 822 static struct configfs_item_operations target_fabric_tpg_base_item_ops = {
 823         .release                = target_fabric_tpg_release,
 824 };
 825
 826 TF_CIT_SETUP_DRV(tpg_base, &target_fabric_tpg_base_item_ops, NULL);
 827
 828 /* End of tfc_tpg_base_cit */
 829
 830 /* Start of tfc_tpg_cit */
 831
 832 static struct config_group *target_fabric_make_tpg(
 833         struct config_group *group,
 834         const char *name)
 835 {
 836         struct se_wwn *wwn = container_of(group, struct se_wwn, wwn_group);
 837         struct target_fabric_configfs *tf = wwn->wwn_tf;
 838         struct se_portal_group *se_tpg;
 839
 840         if (!tf->tf_ops->fabric_make_tpg) {
 841                 pr_err("tf->tf_ops->fabric_make_tpg is NULL\n");
 842                 return ERR_PTR(-ENOSYS);
 843         }
 844
 845         se_tpg = tf->tf_ops->fabric_make_tpg(wwn, name);
 846         if (!se_tpg || IS_ERR(se_tpg))
 847                 return ERR_PTR(-EINVAL);
 848
 849         config_group_init_type_name(&se_tpg->tpg_group, name,
 850                         &tf->tf_tpg_base_cit);
 851
 852         config_group_init_type_name(&se_tpg->tpg_lun_group, "lun",
 853                         &tf->tf_tpg_lun_cit);
 854         configfs_add_default_group(&se_tpg->tpg_lun_group,
 855                         &se_tpg->tpg_group);
 856
 857         config_group_init_type_name(&se_tpg->tpg_np_group, "np",
 858                         &tf->tf_tpg_np_cit);
 859         configfs_add_default_group(&se_tpg->tpg_np_group,
 860                         &se_tpg->tpg_group);
 861
 862         config_group_init_type_name(&se_tpg->tpg_acl_group, "acls",
 863                         &tf->tf_tpg_nacl_cit);
 864         configfs_add_default_group(&se_tpg->tpg_acl_group,
 865                         &se_tpg->tpg_group);
 866
 867         config_group_init_type_name(&se_tpg->tpg_attrib_group, "attrib",
 868                         &tf->tf_tpg_attrib_cit);
 869         configfs_add_default_group(&se_tpg->tpg_attrib_group,
 870                         &se_tpg->tpg_group);
 871
 872         config_group_init_type_name(&se_tpg->tpg_auth_group, "auth",
 873                         &tf->tf_tpg_auth_cit);
 874         configfs_add_default_group(&se_tpg->tpg_auth_group,
 875                         &se_tpg->tpg_group);
 876
 877         config_group_init_type_name(&se_tpg->tpg_param_group, "param",
 878                         &tf->tf_tpg_param_cit);
 879         configfs_add_default_group(&se_tpg->tpg_param_group,
 880                         &se_tpg->tpg_group);
 881
 882         return &se_tpg->tpg_group;
 883 }
 884
 885 static void target_fabric_drop_tpg(
 886         struct config_group *group,
 887         struct config_item *item)
 888 {
 889         struct se_portal_group *se_tpg = container_of(to_config_group(item),
 890                                 struct se_portal_group, tpg_group);
 891
 892         configfs_remove_default_groups(&se_tpg->tpg_group);
 893         config_item_put(item);
 894 }
 895
 896 static void target_fabric_release_wwn(struct config_item *item)
 897 {
 898         struct se_wwn *wwn = container_of(to_config_group(item),
 899                                 struct se_wwn, wwn_group);
 900         struct target_fabric_configfs *tf = wwn->wwn_tf;
 901
 902         configfs_remove_default_groups(&wwn->fabric_stat_group);
 903         tf->tf_ops->fabric_drop_wwn(wwn);
 904 }
 905
 906 static struct configfs_item_operations target_fabric_tpg_item_ops = {
 907         .release        = target_fabric_release_wwn,
 908 };
 909
 910 static struct configfs_group_operations target_fabric_tpg_group_ops = {
 911         .make_group     = target_fabric_make_tpg,
 912         .drop_item      = target_fabric_drop_tpg,
 913 };
 914
 915 TF_CIT_SETUP(tpg, &target_fabric_tpg_item_ops, &target_fabric_tpg_group_ops,
 916                 NULL);
 917
 918 /* End of tfc_tpg_cit */
 919
 920 /* Start of tfc_wwn_fabric_stats_cit */
 921 /*
 922  * This is used as a placeholder for struct se_wwn->fabric_stat_group
 923  * to allow fabrics access to ->fabric_stat_group->default_groups[]
 924  */
 925 TF_CIT_SETUP(wwn_fabric_stats, NULL, NULL, NULL);
 926
 927 /* End of tfc_wwn_fabric_stats_cit */
 928
 929 /* Start of tfc_wwn_cit */
 930
 931 static struct config_group *target_fabric_make_wwn(
 932         struct config_group *group,
 933         const char *name)
 934 {
 935         struct target_fabric_configfs *tf = container_of(group,
 936                                 struct target_fabric_configfs, tf_group);
 937         struct se_wwn *wwn;
 938
 939         if (!tf->tf_ops->fabric_make_wwn) {
 940                 pr_err("tf->tf_ops.fabric_make_wwn is NULL\n");
 941                 return ERR_PTR(-ENOSYS);
 942         }
 943
 944         wwn = tf->tf_ops->fabric_make_wwn(tf, group, name);
 945         if (!wwn || IS_ERR(wwn))
 946                 return ERR_PTR(-EINVAL);
 947
 948         wwn->wwn_tf = tf;
 949
 950         config_group_init_type_name(&wwn->wwn_group, name, &tf->tf_tpg_cit);
 951
 952         config_group_init_type_name(&wwn->fabric_stat_group, "fabric_statistics",
 953                         &tf->tf_wwn_fabric_stats_cit);
 954         configfs_add_default_group(&wwn->fabric_stat_group, &wwn->wwn_group);
 955
 956         if (tf->tf_ops->add_wwn_groups)
 957                 tf->tf_ops->add_wwn_groups(wwn);
 958         return &wwn->wwn_group;
 959 }
 960
 961 static void target_fabric_drop_wwn(
 962         struct config_group *group,
 963         struct config_item *item)
 964 {
 965         struct se_wwn *wwn = container_of(to_config_group(item),
 966                                 struct se_wwn, wwn_group);
 967
 968         configfs_remove_default_groups(&wwn->wwn_group);
 969         config_item_put(item);
 970 }
 971
 972 static struct configfs_group_operations target_fabric_wwn_group_ops = {
 973         .make_group     = target_fabric_make_wwn,
 974         .drop_item      = target_fabric_drop_wwn,
 975 };
 976
 977 TF_CIT_SETUP_DRV(wwn, NULL, &target_fabric_wwn_group_ops);
 978 TF_CIT_SETUP_DRV(discovery, NULL, NULL);
 979
 980 int target_fabric_setup_cits(struct target_fabric_configfs *tf)
 981 {
 982         target_fabric_setup_discovery_cit(tf);
 983         target_fabric_setup_wwn_cit(tf);
 984         target_fabric_setup_wwn_fabric_stats_cit(tf);
 985         target_fabric_setup_tpg_cit(tf);
 986         target_fabric_setup_tpg_base_cit(tf);
 987         target_fabric_setup_tpg_port_cit(tf);
 988         target_fabric_setup_tpg_port_stat_cit(tf);
 989         target_fabric_setup_tpg_lun_cit(tf);
 990         target_fabric_setup_tpg_np_cit(tf);
 991         target_fabric_setup_tpg_np_base_cit(tf);
 992         target_fabric_setup_tpg_attrib_cit(tf);
 993         target_fabric_setup_tpg_auth_cit(tf);
 994         target_fabric_setup_tpg_param_cit(tf);
 995         target_fabric_setup_tpg_nacl_cit(tf);
 996         target_fabric_setup_tpg_nacl_base_cit(tf);
 997         target_fabric_setup_tpg_nacl_attrib_cit(tf);
 998         target_fabric_setup_tpg_nacl_auth_cit(tf);
 999         target_fabric_setup_tpg_nacl_param_cit(tf);
1000         target_fabric_setup_tpg_nacl_stat_cit(tf);
1001         target_fabric_setup_tpg_mappedlun_cit(tf);
1002         target_fabric_setup_tpg_mappedlun_stat_cit(tf);
1003
1004         return 0;
1005 }