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