drivers/target/target_core_fabric_configfs.c

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