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 848 CONFIGFS_ATTR(target_fabric_tpg_base_, enable); 849 850 static int 851 target_fabric_setup_tpg_base_cit(struct target_fabric_configfs *tf) 852 { 853 struct config_item_type *cit = &tf->tf_tpg_base_cit; 854 struct configfs_attribute **attrs = NULL; 855 size_t nr_attrs = 0; 856 int i = 0; 857 858 if (tf->tf_ops->tfc_tpg_base_attrs) 859 while (tf->tf_ops->tfc_tpg_base_attrs[nr_attrs] != NULL) 860 nr_attrs++; 861 862 if (tf->tf_ops->fabric_enable_tpg) 863 nr_attrs++; 864 865 if (nr_attrs == 0) 866 goto done; 867 868 /* + 1 for final NULL in the array */ 869 attrs = kcalloc(nr_attrs + 1, sizeof(*attrs), GFP_KERNEL); 870 if (!attrs) 871 return -ENOMEM; 872 873 if (tf->tf_ops->tfc_tpg_base_attrs) 874 for (; tf->tf_ops->tfc_tpg_base_attrs[i] != NULL; i++) 875 attrs[i] = tf->tf_ops->tfc_tpg_base_attrs[i]; 876 877 if (tf->tf_ops->fabric_enable_tpg) 878 attrs[i] = &target_fabric_tpg_base_attr_enable; 879 880 done: 881 cit->ct_item_ops = &target_fabric_tpg_base_item_ops; 882 cit->ct_attrs = attrs; 883 cit->ct_owner = tf->tf_ops->module; 884 pr_debug("Setup generic tpg_base\n"); 885 886 return 0; 887 } 888 /* End of tfc_tpg_base_cit */ 889 890 /* Start of tfc_tpg_cit */ 891 892 static struct config_group *target_fabric_make_tpg( 893 struct config_group *group, 894 const char *name) 895 { 896 struct se_wwn *wwn = container_of(group, struct se_wwn, wwn_group); 897 struct target_fabric_configfs *tf = wwn->wwn_tf; 898 struct se_portal_group *se_tpg; 899 900 if (!tf->tf_ops->fabric_make_tpg) { 901 pr_err("tf->tf_ops->fabric_make_tpg is NULL\n"); 902 return ERR_PTR(-ENOSYS); 903 } 904 905 se_tpg = tf->tf_ops->fabric_make_tpg(wwn, name); 906 if (!se_tpg || IS_ERR(se_tpg)) 907 return ERR_PTR(-EINVAL); 908 909 config_group_init_type_name(&se_tpg->tpg_group, name, 910 &tf->tf_tpg_base_cit); 911 912 config_group_init_type_name(&se_tpg->tpg_lun_group, "lun", 913 &tf->tf_tpg_lun_cit); 914 configfs_add_default_group(&se_tpg->tpg_lun_group, 915 &se_tpg->tpg_group); 916 917 config_group_init_type_name(&se_tpg->tpg_np_group, "np", 918 &tf->tf_tpg_np_cit); 919 configfs_add_default_group(&se_tpg->tpg_np_group, 920 &se_tpg->tpg_group); 921 922 config_group_init_type_name(&se_tpg->tpg_acl_group, "acls", 923 &tf->tf_tpg_nacl_cit); 924 configfs_add_default_group(&se_tpg->tpg_acl_group, 925 &se_tpg->tpg_group); 926 927 config_group_init_type_name(&se_tpg->tpg_attrib_group, "attrib", 928 &tf->tf_tpg_attrib_cit); 929 configfs_add_default_group(&se_tpg->tpg_attrib_group, 930 &se_tpg->tpg_group); 931 932 config_group_init_type_name(&se_tpg->tpg_auth_group, "auth", 933 &tf->tf_tpg_auth_cit); 934 configfs_add_default_group(&se_tpg->tpg_auth_group, 935 &se_tpg->tpg_group); 936 937 config_group_init_type_name(&se_tpg->tpg_param_group, "param", 938 &tf->tf_tpg_param_cit); 939 configfs_add_default_group(&se_tpg->tpg_param_group, 940 &se_tpg->tpg_group); 941 942 return &se_tpg->tpg_group; 943 } 944 945 static void target_fabric_drop_tpg( 946 struct config_group *group, 947 struct config_item *item) 948 { 949 struct se_portal_group *se_tpg = container_of(to_config_group(item), 950 struct se_portal_group, tpg_group); 951 952 configfs_remove_default_groups(&se_tpg->tpg_group); 953 config_item_put(item); 954 } 955 956 static void target_fabric_release_wwn(struct config_item *item) 957 { 958 struct se_wwn *wwn = container_of(to_config_group(item), 959 struct se_wwn, wwn_group); 960 struct target_fabric_configfs *tf = wwn->wwn_tf; 961 962 configfs_remove_default_groups(&wwn->fabric_stat_group); 963 configfs_remove_default_groups(&wwn->param_group); 964 tf->tf_ops->fabric_drop_wwn(wwn); 965 } 966 967 static struct configfs_item_operations target_fabric_tpg_item_ops = { 968 .release = target_fabric_release_wwn, 969 }; 970 971 static struct configfs_group_operations target_fabric_tpg_group_ops = { 972 .make_group = target_fabric_make_tpg, 973 .drop_item = target_fabric_drop_tpg, 974 }; 975 976 TF_CIT_SETUP(tpg, &target_fabric_tpg_item_ops, &target_fabric_tpg_group_ops, 977 NULL); 978 979 /* End of tfc_tpg_cit */ 980 981 /* Start of tfc_wwn_fabric_stats_cit */ 982 /* 983 * This is used as a placeholder for struct se_wwn->fabric_stat_group 984 * to allow fabrics access to ->fabric_stat_group->default_groups[] 985 */ 986 TF_CIT_SETUP(wwn_fabric_stats, NULL, NULL, NULL); 987 988 /* End of tfc_wwn_fabric_stats_cit */ 989 990 static ssize_t 991 target_fabric_wwn_cmd_completion_affinity_show(struct config_item *item, 992 char *page) 993 { 994 struct se_wwn *wwn = container_of(to_config_group(item), struct se_wwn, 995 param_group); 996 return sprintf(page, "%d\n", 997 wwn->cmd_compl_affinity == WORK_CPU_UNBOUND ? 998 SE_COMPL_AFFINITY_CURR_CPU : wwn->cmd_compl_affinity); 999 } 1000 1001 static ssize_t 1002 target_fabric_wwn_cmd_completion_affinity_store(struct config_item *item, 1003 const char *page, size_t count) 1004 { 1005 struct se_wwn *wwn = container_of(to_config_group(item), struct se_wwn, 1006 param_group); 1007 int compl_val; 1008 1009 if (kstrtoint(page, 0, &compl_val)) 1010 return -EINVAL; 1011 1012 switch (compl_val) { 1013 case SE_COMPL_AFFINITY_CPUID: 1014 wwn->cmd_compl_affinity = compl_val; 1015 break; 1016 case SE_COMPL_AFFINITY_CURR_CPU: 1017 wwn->cmd_compl_affinity = WORK_CPU_UNBOUND; 1018 break; 1019 default: 1020 if (compl_val < 0 || compl_val >= nr_cpu_ids || 1021 !cpu_online(compl_val)) { 1022 pr_err("Command completion value must be between %d and %d or an online CPU.\n", 1023 SE_COMPL_AFFINITY_CPUID, 1024 SE_COMPL_AFFINITY_CURR_CPU); 1025 return -EINVAL; 1026 } 1027 wwn->cmd_compl_affinity = compl_val; 1028 } 1029 1030 return count; 1031 } 1032 CONFIGFS_ATTR(target_fabric_wwn_, cmd_completion_affinity); 1033 1034 static struct configfs_attribute *target_fabric_wwn_param_attrs[] = { 1035 &target_fabric_wwn_attr_cmd_completion_affinity, 1036 NULL, 1037 }; 1038 1039 TF_CIT_SETUP(wwn_param, NULL, NULL, target_fabric_wwn_param_attrs); 1040 1041 /* Start of tfc_wwn_cit */ 1042 1043 static struct config_group *target_fabric_make_wwn( 1044 struct config_group *group, 1045 const char *name) 1046 { 1047 struct target_fabric_configfs *tf = container_of(group, 1048 struct target_fabric_configfs, tf_group); 1049 struct se_wwn *wwn; 1050 1051 if (!tf->tf_ops->fabric_make_wwn) { 1052 pr_err("tf->tf_ops.fabric_make_wwn is NULL\n"); 1053 return ERR_PTR(-ENOSYS); 1054 } 1055 1056 wwn = tf->tf_ops->fabric_make_wwn(tf, group, name); 1057 if (!wwn || IS_ERR(wwn)) 1058 return ERR_PTR(-EINVAL); 1059 1060 wwn->cmd_compl_affinity = SE_COMPL_AFFINITY_CPUID; 1061 wwn->wwn_tf = tf; 1062 1063 config_group_init_type_name(&wwn->wwn_group, name, &tf->tf_tpg_cit); 1064 1065 config_group_init_type_name(&wwn->fabric_stat_group, "fabric_statistics", 1066 &tf->tf_wwn_fabric_stats_cit); 1067 configfs_add_default_group(&wwn->fabric_stat_group, &wwn->wwn_group); 1068 1069 config_group_init_type_name(&wwn->param_group, "param", 1070 &tf->tf_wwn_param_cit); 1071 configfs_add_default_group(&wwn->param_group, &wwn->wwn_group); 1072 1073 if (tf->tf_ops->add_wwn_groups) 1074 tf->tf_ops->add_wwn_groups(wwn); 1075 return &wwn->wwn_group; 1076 } 1077 1078 static void target_fabric_drop_wwn( 1079 struct config_group *group, 1080 struct config_item *item) 1081 { 1082 struct se_wwn *wwn = container_of(to_config_group(item), 1083 struct se_wwn, wwn_group); 1084 1085 configfs_remove_default_groups(&wwn->wwn_group); 1086 config_item_put(item); 1087 } 1088 1089 static struct configfs_group_operations target_fabric_wwn_group_ops = { 1090 .make_group = target_fabric_make_wwn, 1091 .drop_item = target_fabric_drop_wwn, 1092 }; 1093 1094 TF_CIT_SETUP_DRV(wwn, NULL, &target_fabric_wwn_group_ops); 1095 TF_CIT_SETUP_DRV(discovery, NULL, NULL); 1096 1097 int target_fabric_setup_cits(struct target_fabric_configfs *tf) 1098 { 1099 int ret; 1100 1101 target_fabric_setup_discovery_cit(tf); 1102 target_fabric_setup_wwn_cit(tf); 1103 target_fabric_setup_wwn_fabric_stats_cit(tf); 1104 target_fabric_setup_wwn_param_cit(tf); 1105 target_fabric_setup_tpg_cit(tf); 1106 1107 ret = target_fabric_setup_tpg_base_cit(tf); 1108 if (ret) 1109 return ret; 1110 1111 target_fabric_setup_tpg_port_cit(tf); 1112 target_fabric_setup_tpg_port_stat_cit(tf); 1113 target_fabric_setup_tpg_lun_cit(tf); 1114 target_fabric_setup_tpg_np_cit(tf); 1115 target_fabric_setup_tpg_np_base_cit(tf); 1116 target_fabric_setup_tpg_attrib_cit(tf); 1117 target_fabric_setup_tpg_auth_cit(tf); 1118 target_fabric_setup_tpg_param_cit(tf); 1119 target_fabric_setup_tpg_nacl_cit(tf); 1120 target_fabric_setup_tpg_nacl_base_cit(tf); 1121 target_fabric_setup_tpg_nacl_attrib_cit(tf); 1122 target_fabric_setup_tpg_nacl_auth_cit(tf); 1123 target_fabric_setup_tpg_nacl_param_cit(tf); 1124 target_fabric_setup_tpg_nacl_stat_cit(tf); 1125 target_fabric_setup_tpg_mappedlun_cit(tf); 1126 target_fabric_setup_tpg_mappedlun_stat_cit(tf); 1127 1128 return 0; 1129 } 1130