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