1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /******************************************************************************* 3 * Filename: target_core_configfs.c 4 * 5 * This file contains ConfigFS logic for the Generic Target Engine project. 6 * 7 * (c) Copyright 2008-2013 Datera, Inc. 8 * 9 * Nicholas A. Bellinger <nab@kernel.org> 10 * 11 * based on configfs Copyright (C) 2005 Oracle. All rights reserved. 12 * 13 ****************************************************************************/ 14 15 #include <linux/kstrtox.h> 16 #include <linux/module.h> 17 #include <linux/moduleparam.h> 18 #include <generated/utsrelease.h> 19 #include <linux/utsname.h> 20 #include <linux/init.h> 21 #include <linux/fs.h> 22 #include <linux/namei.h> 23 #include <linux/slab.h> 24 #include <linux/types.h> 25 #include <linux/delay.h> 26 #include <linux/unistd.h> 27 #include <linux/string.h> 28 #include <linux/parser.h> 29 #include <linux/syscalls.h> 30 #include <linux/configfs.h> 31 #include <linux/spinlock.h> 32 33 #include <target/target_core_base.h> 34 #include <target/target_core_backend.h> 35 #include <target/target_core_fabric.h> 36 37 #include "target_core_internal.h" 38 #include "target_core_alua.h" 39 #include "target_core_pr.h" 40 #include "target_core_rd.h" 41 #include "target_core_xcopy.h" 42 43 #define TB_CIT_SETUP(_name, _item_ops, _group_ops, _attrs) \ 44 static void target_core_setup_##_name##_cit(struct target_backend *tb) \ 45 { \ 46 struct config_item_type *cit = &tb->tb_##_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 = tb->ops->owner; \ 52 pr_debug("Setup generic %s\n", __stringify(_name)); \ 53 } 54 55 #define TB_CIT_SETUP_DRV(_name, _item_ops, _group_ops) \ 56 static void target_core_setup_##_name##_cit(struct target_backend *tb) \ 57 { \ 58 struct config_item_type *cit = &tb->tb_##_name##_cit; \ 59 \ 60 cit->ct_item_ops = _item_ops; \ 61 cit->ct_group_ops = _group_ops; \ 62 cit->ct_attrs = tb->ops->tb_##_name##_attrs; \ 63 cit->ct_owner = tb->ops->owner; \ 64 pr_debug("Setup generic %s\n", __stringify(_name)); \ 65 } 66 67 extern struct t10_alua_lu_gp *default_lu_gp; 68 69 static LIST_HEAD(g_tf_list); 70 static DEFINE_MUTEX(g_tf_lock); 71 72 static struct config_group target_core_hbagroup; 73 static struct config_group alua_group; 74 static struct config_group alua_lu_gps_group; 75 76 static unsigned int target_devices; 77 static DEFINE_MUTEX(target_devices_lock); 78 79 static inline struct se_hba * 80 item_to_hba(struct config_item *item) 81 { 82 return container_of(to_config_group(item), struct se_hba, hba_group); 83 } 84 85 /* 86 * Attributes for /sys/kernel/config/target/ 87 */ 88 static ssize_t target_core_item_version_show(struct config_item *item, 89 char *page) 90 { 91 return sprintf(page, "Target Engine Core ConfigFS Infrastructure %s" 92 " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_VERSION, 93 utsname()->sysname, utsname()->machine); 94 } 95 96 CONFIGFS_ATTR_RO(target_core_item_, version); 97 98 char db_root[DB_ROOT_LEN] = DB_ROOT_DEFAULT; 99 static char db_root_stage[DB_ROOT_LEN]; 100 101 static ssize_t target_core_item_dbroot_show(struct config_item *item, 102 char *page) 103 { 104 return sprintf(page, "%s\n", db_root); 105 } 106 107 static ssize_t target_core_item_dbroot_store(struct config_item *item, 108 const char *page, size_t count) 109 { 110 ssize_t read_bytes; 111 struct file *fp; 112 ssize_t r = -EINVAL; 113 114 mutex_lock(&target_devices_lock); 115 if (target_devices) { 116 pr_err("db_root: cannot be changed because it's in use\n"); 117 goto unlock; 118 } 119 120 if (count > (DB_ROOT_LEN - 1)) { 121 pr_err("db_root: count %d exceeds DB_ROOT_LEN-1: %u\n", 122 (int)count, DB_ROOT_LEN - 1); 123 goto unlock; 124 } 125 126 read_bytes = snprintf(db_root_stage, DB_ROOT_LEN, "%s", page); 127 if (!read_bytes) 128 goto unlock; 129 130 if (db_root_stage[read_bytes - 1] == '\n') 131 db_root_stage[read_bytes - 1] = '\0'; 132 133 /* validate new db root before accepting it */ 134 fp = filp_open(db_root_stage, O_RDONLY, 0); 135 if (IS_ERR(fp)) { 136 pr_err("db_root: cannot open: %s\n", db_root_stage); 137 goto unlock; 138 } 139 if (!S_ISDIR(file_inode(fp)->i_mode)) { 140 filp_close(fp, NULL); 141 pr_err("db_root: not a directory: %s\n", db_root_stage); 142 goto unlock; 143 } 144 filp_close(fp, NULL); 145 146 strncpy(db_root, db_root_stage, read_bytes); 147 pr_debug("Target_Core_ConfigFS: db_root set to %s\n", db_root); 148 149 r = read_bytes; 150 151 unlock: 152 mutex_unlock(&target_devices_lock); 153 return r; 154 } 155 156 CONFIGFS_ATTR(target_core_item_, dbroot); 157 158 static struct target_fabric_configfs *target_core_get_fabric( 159 const char *name) 160 { 161 struct target_fabric_configfs *tf; 162 163 if (!name) 164 return NULL; 165 166 mutex_lock(&g_tf_lock); 167 list_for_each_entry(tf, &g_tf_list, tf_list) { 168 const char *cmp_name = tf->tf_ops->fabric_alias; 169 if (!cmp_name) 170 cmp_name = tf->tf_ops->fabric_name; 171 if (!strcmp(cmp_name, name)) { 172 atomic_inc(&tf->tf_access_cnt); 173 mutex_unlock(&g_tf_lock); 174 return tf; 175 } 176 } 177 mutex_unlock(&g_tf_lock); 178 179 return NULL; 180 } 181 182 /* 183 * Called from struct target_core_group_ops->make_group() 184 */ 185 static struct config_group *target_core_register_fabric( 186 struct config_group *group, 187 const char *name) 188 { 189 struct target_fabric_configfs *tf; 190 int ret; 191 192 pr_debug("Target_Core_ConfigFS: REGISTER -> group: %p name:" 193 " %s\n", group, name); 194 195 tf = target_core_get_fabric(name); 196 if (!tf) { 197 pr_debug("target_core_register_fabric() trying autoload for %s\n", 198 name); 199 200 /* 201 * Below are some hardcoded request_module() calls to automatically 202 * local fabric modules when the following is called: 203 * 204 * mkdir -p /sys/kernel/config/target/$MODULE_NAME 205 * 206 * Note that this does not limit which TCM fabric module can be 207 * registered, but simply provids auto loading logic for modules with 208 * mkdir(2) system calls with known TCM fabric modules. 209 */ 210 211 if (!strncmp(name, "iscsi", 5)) { 212 /* 213 * Automatically load the LIO Target fabric module when the 214 * following is called: 215 * 216 * mkdir -p $CONFIGFS/target/iscsi 217 */ 218 ret = request_module("iscsi_target_mod"); 219 if (ret < 0) { 220 pr_debug("request_module() failed for" 221 " iscsi_target_mod.ko: %d\n", ret); 222 return ERR_PTR(-EINVAL); 223 } 224 } else if (!strncmp(name, "loopback", 8)) { 225 /* 226 * Automatically load the tcm_loop fabric module when the 227 * following is called: 228 * 229 * mkdir -p $CONFIGFS/target/loopback 230 */ 231 ret = request_module("tcm_loop"); 232 if (ret < 0) { 233 pr_debug("request_module() failed for" 234 " tcm_loop.ko: %d\n", ret); 235 return ERR_PTR(-EINVAL); 236 } 237 } 238 239 tf = target_core_get_fabric(name); 240 } 241 242 if (!tf) { 243 pr_debug("target_core_get_fabric() failed for %s\n", 244 name); 245 return ERR_PTR(-EINVAL); 246 } 247 pr_debug("Target_Core_ConfigFS: REGISTER -> Located fabric:" 248 " %s\n", tf->tf_ops->fabric_name); 249 /* 250 * On a successful target_core_get_fabric() look, the returned 251 * struct target_fabric_configfs *tf will contain a usage reference. 252 */ 253 pr_debug("Target_Core_ConfigFS: REGISTER tfc_wwn_cit -> %p\n", 254 &tf->tf_wwn_cit); 255 256 config_group_init_type_name(&tf->tf_group, name, &tf->tf_wwn_cit); 257 258 config_group_init_type_name(&tf->tf_disc_group, "discovery_auth", 259 &tf->tf_discovery_cit); 260 configfs_add_default_group(&tf->tf_disc_group, &tf->tf_group); 261 262 pr_debug("Target_Core_ConfigFS: REGISTER -> Allocated Fabric: %s\n", 263 config_item_name(&tf->tf_group.cg_item)); 264 return &tf->tf_group; 265 } 266 267 /* 268 * Called from struct target_core_group_ops->drop_item() 269 */ 270 static void target_core_deregister_fabric( 271 struct config_group *group, 272 struct config_item *item) 273 { 274 struct target_fabric_configfs *tf = container_of( 275 to_config_group(item), struct target_fabric_configfs, tf_group); 276 277 pr_debug("Target_Core_ConfigFS: DEREGISTER -> Looking up %s in" 278 " tf list\n", config_item_name(item)); 279 280 pr_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric:" 281 " %s\n", tf->tf_ops->fabric_name); 282 atomic_dec(&tf->tf_access_cnt); 283 284 pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci" 285 " %s\n", config_item_name(item)); 286 287 configfs_remove_default_groups(&tf->tf_group); 288 config_item_put(item); 289 } 290 291 static struct configfs_group_operations target_core_fabric_group_ops = { 292 .make_group = &target_core_register_fabric, 293 .drop_item = &target_core_deregister_fabric, 294 }; 295 296 /* 297 * All item attributes appearing in /sys/kernel/target/ appear here. 298 */ 299 static struct configfs_attribute *target_core_fabric_item_attrs[] = { 300 &target_core_item_attr_version, 301 &target_core_item_attr_dbroot, 302 NULL, 303 }; 304 305 /* 306 * Provides Fabrics Groups and Item Attributes for /sys/kernel/config/target/ 307 */ 308 static const struct config_item_type target_core_fabrics_item = { 309 .ct_group_ops = &target_core_fabric_group_ops, 310 .ct_attrs = target_core_fabric_item_attrs, 311 .ct_owner = THIS_MODULE, 312 }; 313 314 static struct configfs_subsystem target_core_fabrics = { 315 .su_group = { 316 .cg_item = { 317 .ci_namebuf = "target", 318 .ci_type = &target_core_fabrics_item, 319 }, 320 }, 321 }; 322 323 int target_depend_item(struct config_item *item) 324 { 325 return configfs_depend_item(&target_core_fabrics, item); 326 } 327 EXPORT_SYMBOL(target_depend_item); 328 329 void target_undepend_item(struct config_item *item) 330 { 331 return configfs_undepend_item(item); 332 } 333 EXPORT_SYMBOL(target_undepend_item); 334 335 /*############################################################################## 336 // Start functions called by external Target Fabrics Modules 337 //############################################################################*/ 338 static int target_disable_feature(struct se_portal_group *se_tpg) 339 { 340 return 0; 341 } 342 343 static u32 target_default_get_inst_index(struct se_portal_group *se_tpg) 344 { 345 return 1; 346 } 347 348 static u32 target_default_sess_get_index(struct se_session *se_sess) 349 { 350 return 0; 351 } 352 353 static void target_set_default_node_attributes(struct se_node_acl *se_acl) 354 { 355 } 356 357 static int target_default_get_cmd_state(struct se_cmd *se_cmd) 358 { 359 return 0; 360 } 361 362 static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo) 363 { 364 if (tfo->fabric_alias) { 365 if (strlen(tfo->fabric_alias) >= TARGET_FABRIC_NAME_SIZE) { 366 pr_err("Passed alias: %s exceeds " 367 "TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_alias); 368 return -EINVAL; 369 } 370 } 371 if (!tfo->fabric_name) { 372 pr_err("Missing tfo->fabric_name\n"); 373 return -EINVAL; 374 } 375 if (strlen(tfo->fabric_name) >= TARGET_FABRIC_NAME_SIZE) { 376 pr_err("Passed name: %s exceeds " 377 "TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_name); 378 return -EINVAL; 379 } 380 if (!tfo->tpg_get_wwn) { 381 pr_err("Missing tfo->tpg_get_wwn()\n"); 382 return -EINVAL; 383 } 384 if (!tfo->tpg_get_tag) { 385 pr_err("Missing tfo->tpg_get_tag()\n"); 386 return -EINVAL; 387 } 388 if (!tfo->release_cmd) { 389 pr_err("Missing tfo->release_cmd()\n"); 390 return -EINVAL; 391 } 392 if (!tfo->write_pending) { 393 pr_err("Missing tfo->write_pending()\n"); 394 return -EINVAL; 395 } 396 if (!tfo->queue_data_in) { 397 pr_err("Missing tfo->queue_data_in()\n"); 398 return -EINVAL; 399 } 400 if (!tfo->queue_status) { 401 pr_err("Missing tfo->queue_status()\n"); 402 return -EINVAL; 403 } 404 if (!tfo->queue_tm_rsp) { 405 pr_err("Missing tfo->queue_tm_rsp()\n"); 406 return -EINVAL; 407 } 408 if (!tfo->aborted_task) { 409 pr_err("Missing tfo->aborted_task()\n"); 410 return -EINVAL; 411 } 412 if (!tfo->check_stop_free) { 413 pr_err("Missing tfo->check_stop_free()\n"); 414 return -EINVAL; 415 } 416 /* 417 * We at least require tfo->fabric_make_wwn(), tfo->fabric_drop_wwn() 418 * tfo->fabric_make_tpg() and tfo->fabric_drop_tpg() in 419 * target_core_fabric_configfs.c WWN+TPG group context code. 420 */ 421 if (!tfo->fabric_make_wwn) { 422 pr_err("Missing tfo->fabric_make_wwn()\n"); 423 return -EINVAL; 424 } 425 if (!tfo->fabric_drop_wwn) { 426 pr_err("Missing tfo->fabric_drop_wwn()\n"); 427 return -EINVAL; 428 } 429 if (!tfo->fabric_make_tpg) { 430 pr_err("Missing tfo->fabric_make_tpg()\n"); 431 return -EINVAL; 432 } 433 if (!tfo->fabric_drop_tpg) { 434 pr_err("Missing tfo->fabric_drop_tpg()\n"); 435 return -EINVAL; 436 } 437 438 return 0; 439 } 440 441 static void target_set_default_ops(struct target_core_fabric_ops *tfo) 442 { 443 if (!tfo->tpg_check_demo_mode) 444 tfo->tpg_check_demo_mode = target_disable_feature; 445 446 if (!tfo->tpg_check_demo_mode_cache) 447 tfo->tpg_check_demo_mode_cache = target_disable_feature; 448 449 if (!tfo->tpg_check_demo_mode_write_protect) 450 tfo->tpg_check_demo_mode_write_protect = target_disable_feature; 451 452 if (!tfo->tpg_check_prod_mode_write_protect) 453 tfo->tpg_check_prod_mode_write_protect = target_disable_feature; 454 455 if (!tfo->tpg_get_inst_index) 456 tfo->tpg_get_inst_index = target_default_get_inst_index; 457 458 if (!tfo->sess_get_index) 459 tfo->sess_get_index = target_default_sess_get_index; 460 461 if (!tfo->set_default_node_attributes) 462 tfo->set_default_node_attributes = target_set_default_node_attributes; 463 464 if (!tfo->get_cmd_state) 465 tfo->get_cmd_state = target_default_get_cmd_state; 466 } 467 468 int target_register_template(const struct target_core_fabric_ops *fo) 469 { 470 struct target_core_fabric_ops *tfo; 471 struct target_fabric_configfs *tf; 472 int ret; 473 474 ret = target_fabric_tf_ops_check(fo); 475 if (ret) 476 return ret; 477 478 tf = kzalloc(sizeof(struct target_fabric_configfs), GFP_KERNEL); 479 if (!tf) { 480 pr_err("%s: could not allocate memory!\n", __func__); 481 return -ENOMEM; 482 } 483 tfo = kzalloc(sizeof(struct target_core_fabric_ops), GFP_KERNEL); 484 if (!tfo) { 485 kfree(tf); 486 pr_err("%s: could not allocate memory!\n", __func__); 487 return -ENOMEM; 488 } 489 memcpy(tfo, fo, sizeof(*tfo)); 490 target_set_default_ops(tfo); 491 492 INIT_LIST_HEAD(&tf->tf_list); 493 atomic_set(&tf->tf_access_cnt, 0); 494 tf->tf_ops = tfo; 495 target_fabric_setup_cits(tf); 496 497 mutex_lock(&g_tf_lock); 498 list_add_tail(&tf->tf_list, &g_tf_list); 499 mutex_unlock(&g_tf_lock); 500 501 return 0; 502 } 503 EXPORT_SYMBOL(target_register_template); 504 505 void target_unregister_template(const struct target_core_fabric_ops *fo) 506 { 507 struct target_fabric_configfs *t; 508 509 mutex_lock(&g_tf_lock); 510 list_for_each_entry(t, &g_tf_list, tf_list) { 511 if (!strcmp(t->tf_ops->fabric_name, fo->fabric_name)) { 512 BUG_ON(atomic_read(&t->tf_access_cnt)); 513 list_del(&t->tf_list); 514 mutex_unlock(&g_tf_lock); 515 /* 516 * Wait for any outstanding fabric se_deve_entry->rcu_head 517 * callbacks to complete post kfree_rcu(), before allowing 518 * fabric driver unload of TFO->module to proceed. 519 */ 520 rcu_barrier(); 521 kfree(t->tf_tpg_base_cit.ct_attrs); 522 kfree(t->tf_ops); 523 kfree(t); 524 return; 525 } 526 } 527 mutex_unlock(&g_tf_lock); 528 } 529 EXPORT_SYMBOL(target_unregister_template); 530 531 /*############################################################################## 532 // Stop functions called by external Target Fabrics Modules 533 //############################################################################*/ 534 535 static inline struct se_dev_attrib *to_attrib(struct config_item *item) 536 { 537 return container_of(to_config_group(item), struct se_dev_attrib, 538 da_group); 539 } 540 541 /* Start functions for struct config_item_type tb_dev_attrib_cit */ 542 #define DEF_CONFIGFS_ATTRIB_SHOW(_name) \ 543 static ssize_t _name##_show(struct config_item *item, char *page) \ 544 { \ 545 return snprintf(page, PAGE_SIZE, "%u\n", to_attrib(item)->_name); \ 546 } 547 548 DEF_CONFIGFS_ATTRIB_SHOW(emulate_model_alias); 549 DEF_CONFIGFS_ATTRIB_SHOW(emulate_dpo); 550 DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_write); 551 DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_read); 552 DEF_CONFIGFS_ATTRIB_SHOW(emulate_write_cache); 553 DEF_CONFIGFS_ATTRIB_SHOW(emulate_ua_intlck_ctrl); 554 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tas); 555 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpu); 556 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpws); 557 DEF_CONFIGFS_ATTRIB_SHOW(emulate_caw); 558 DEF_CONFIGFS_ATTRIB_SHOW(emulate_3pc); 559 DEF_CONFIGFS_ATTRIB_SHOW(emulate_pr); 560 DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_type); 561 DEF_CONFIGFS_ATTRIB_SHOW(hw_pi_prot_type); 562 DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_verify); 563 DEF_CONFIGFS_ATTRIB_SHOW(enforce_pr_isids); 564 DEF_CONFIGFS_ATTRIB_SHOW(is_nonrot); 565 DEF_CONFIGFS_ATTRIB_SHOW(emulate_rest_reord); 566 DEF_CONFIGFS_ATTRIB_SHOW(force_pr_aptpl); 567 DEF_CONFIGFS_ATTRIB_SHOW(hw_block_size); 568 DEF_CONFIGFS_ATTRIB_SHOW(block_size); 569 DEF_CONFIGFS_ATTRIB_SHOW(hw_max_sectors); 570 DEF_CONFIGFS_ATTRIB_SHOW(optimal_sectors); 571 DEF_CONFIGFS_ATTRIB_SHOW(hw_queue_depth); 572 DEF_CONFIGFS_ATTRIB_SHOW(queue_depth); 573 DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_lba_count); 574 DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_block_desc_count); 575 DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity); 576 DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity_alignment); 577 DEF_CONFIGFS_ATTRIB_SHOW(unmap_zeroes_data); 578 DEF_CONFIGFS_ATTRIB_SHOW(max_write_same_len); 579 DEF_CONFIGFS_ATTRIB_SHOW(emulate_rsoc); 580 581 #define DEF_CONFIGFS_ATTRIB_STORE_U32(_name) \ 582 static ssize_t _name##_store(struct config_item *item, const char *page,\ 583 size_t count) \ 584 { \ 585 struct se_dev_attrib *da = to_attrib(item); \ 586 u32 val; \ 587 int ret; \ 588 \ 589 ret = kstrtou32(page, 0, &val); \ 590 if (ret < 0) \ 591 return ret; \ 592 da->_name = val; \ 593 return count; \ 594 } 595 596 DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_lba_count); 597 DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_block_desc_count); 598 DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity); 599 DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity_alignment); 600 DEF_CONFIGFS_ATTRIB_STORE_U32(max_write_same_len); 601 602 #define DEF_CONFIGFS_ATTRIB_STORE_BOOL(_name) \ 603 static ssize_t _name##_store(struct config_item *item, const char *page, \ 604 size_t count) \ 605 { \ 606 struct se_dev_attrib *da = to_attrib(item); \ 607 bool flag; \ 608 int ret; \ 609 \ 610 ret = kstrtobool(page, &flag); \ 611 if (ret < 0) \ 612 return ret; \ 613 da->_name = flag; \ 614 return count; \ 615 } 616 617 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_fua_write); 618 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_caw); 619 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_3pc); 620 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_pr); 621 DEF_CONFIGFS_ATTRIB_STORE_BOOL(enforce_pr_isids); 622 DEF_CONFIGFS_ATTRIB_STORE_BOOL(is_nonrot); 623 624 #define DEF_CONFIGFS_ATTRIB_STORE_STUB(_name) \ 625 static ssize_t _name##_store(struct config_item *item, const char *page,\ 626 size_t count) \ 627 { \ 628 printk_once(KERN_WARNING \ 629 "ignoring deprecated %s attribute\n", \ 630 __stringify(_name)); \ 631 return count; \ 632 } 633 634 DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_dpo); 635 DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_fua_read); 636 637 static void dev_set_t10_wwn_model_alias(struct se_device *dev) 638 { 639 const char *configname; 640 641 configname = config_item_name(&dev->dev_group.cg_item); 642 if (strlen(configname) >= INQUIRY_MODEL_LEN) { 643 pr_warn("dev[%p]: Backstore name '%s' is too long for " 644 "INQUIRY_MODEL, truncating to 15 characters\n", dev, 645 configname); 646 } 647 /* 648 * XXX We can't use sizeof(dev->t10_wwn.model) (INQUIRY_MODEL_LEN + 1) 649 * here without potentially breaking existing setups, so continue to 650 * truncate one byte shorter than what can be carried in INQUIRY. 651 */ 652 strlcpy(dev->t10_wwn.model, configname, INQUIRY_MODEL_LEN); 653 } 654 655 static ssize_t emulate_model_alias_store(struct config_item *item, 656 const char *page, size_t count) 657 { 658 struct se_dev_attrib *da = to_attrib(item); 659 struct se_device *dev = da->da_dev; 660 bool flag; 661 int ret; 662 663 if (dev->export_count) { 664 pr_err("dev[%p]: Unable to change model alias" 665 " while export_count is %d\n", 666 dev, dev->export_count); 667 return -EINVAL; 668 } 669 670 ret = kstrtobool(page, &flag); 671 if (ret < 0) 672 return ret; 673 674 BUILD_BUG_ON(sizeof(dev->t10_wwn.model) != INQUIRY_MODEL_LEN + 1); 675 if (flag) { 676 dev_set_t10_wwn_model_alias(dev); 677 } else { 678 strlcpy(dev->t10_wwn.model, dev->transport->inquiry_prod, 679 sizeof(dev->t10_wwn.model)); 680 } 681 da->emulate_model_alias = flag; 682 return count; 683 } 684 685 static ssize_t emulate_write_cache_store(struct config_item *item, 686 const char *page, size_t count) 687 { 688 struct se_dev_attrib *da = to_attrib(item); 689 bool flag; 690 int ret; 691 692 ret = kstrtobool(page, &flag); 693 if (ret < 0) 694 return ret; 695 696 if (flag && da->da_dev->transport->get_write_cache) { 697 pr_err("emulate_write_cache not supported for this device\n"); 698 return -EINVAL; 699 } 700 701 da->emulate_write_cache = flag; 702 pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n", 703 da->da_dev, flag); 704 return count; 705 } 706 707 static ssize_t emulate_ua_intlck_ctrl_store(struct config_item *item, 708 const char *page, size_t count) 709 { 710 struct se_dev_attrib *da = to_attrib(item); 711 u32 val; 712 int ret; 713 714 ret = kstrtou32(page, 0, &val); 715 if (ret < 0) 716 return ret; 717 718 if (val != TARGET_UA_INTLCK_CTRL_CLEAR 719 && val != TARGET_UA_INTLCK_CTRL_NO_CLEAR 720 && val != TARGET_UA_INTLCK_CTRL_ESTABLISH_UA) { 721 pr_err("Illegal value %d\n", val); 722 return -EINVAL; 723 } 724 725 if (da->da_dev->export_count) { 726 pr_err("dev[%p]: Unable to change SE Device" 727 " UA_INTRLCK_CTRL while export_count is %d\n", 728 da->da_dev, da->da_dev->export_count); 729 return -EINVAL; 730 } 731 da->emulate_ua_intlck_ctrl = val; 732 pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n", 733 da->da_dev, val); 734 return count; 735 } 736 737 static ssize_t emulate_tas_store(struct config_item *item, 738 const char *page, size_t count) 739 { 740 struct se_dev_attrib *da = to_attrib(item); 741 bool flag; 742 int ret; 743 744 ret = kstrtobool(page, &flag); 745 if (ret < 0) 746 return ret; 747 748 if (da->da_dev->export_count) { 749 pr_err("dev[%p]: Unable to change SE Device TAS while" 750 " export_count is %d\n", 751 da->da_dev, da->da_dev->export_count); 752 return -EINVAL; 753 } 754 da->emulate_tas = flag; 755 pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n", 756 da->da_dev, flag ? "Enabled" : "Disabled"); 757 758 return count; 759 } 760 761 static ssize_t emulate_tpu_store(struct config_item *item, 762 const char *page, size_t count) 763 { 764 struct se_dev_attrib *da = to_attrib(item); 765 struct se_device *dev = da->da_dev; 766 bool flag; 767 int ret; 768 769 ret = kstrtobool(page, &flag); 770 if (ret < 0) 771 return ret; 772 773 /* 774 * We expect this value to be non-zero when generic Block Layer 775 * Discard supported is detected iblock_create_virtdevice(). 776 */ 777 if (flag && !da->max_unmap_block_desc_count) { 778 if (!dev->transport->configure_unmap || 779 !dev->transport->configure_unmap(dev)) { 780 pr_err("Generic Block Discard not supported\n"); 781 return -ENOSYS; 782 } 783 } 784 785 da->emulate_tpu = flag; 786 pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n", 787 da->da_dev, flag); 788 return count; 789 } 790 791 static ssize_t emulate_tpws_store(struct config_item *item, 792 const char *page, size_t count) 793 { 794 struct se_dev_attrib *da = to_attrib(item); 795 struct se_device *dev = da->da_dev; 796 bool flag; 797 int ret; 798 799 ret = kstrtobool(page, &flag); 800 if (ret < 0) 801 return ret; 802 803 /* 804 * We expect this value to be non-zero when generic Block Layer 805 * Discard supported is detected iblock_create_virtdevice(). 806 */ 807 if (flag && !da->max_unmap_block_desc_count) { 808 if (!dev->transport->configure_unmap || 809 !dev->transport->configure_unmap(dev)) { 810 pr_err("Generic Block Discard not supported\n"); 811 return -ENOSYS; 812 } 813 } 814 815 da->emulate_tpws = flag; 816 pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n", 817 da->da_dev, flag); 818 return count; 819 } 820 821 static ssize_t pi_prot_type_store(struct config_item *item, 822 const char *page, size_t count) 823 { 824 struct se_dev_attrib *da = to_attrib(item); 825 int old_prot = da->pi_prot_type, ret; 826 struct se_device *dev = da->da_dev; 827 u32 flag; 828 829 ret = kstrtou32(page, 0, &flag); 830 if (ret < 0) 831 return ret; 832 833 if (flag != 0 && flag != 1 && flag != 2 && flag != 3) { 834 pr_err("Illegal value %d for pi_prot_type\n", flag); 835 return -EINVAL; 836 } 837 if (flag == 2) { 838 pr_err("DIF TYPE2 protection currently not supported\n"); 839 return -ENOSYS; 840 } 841 if (da->hw_pi_prot_type) { 842 pr_warn("DIF protection enabled on underlying hardware," 843 " ignoring\n"); 844 return count; 845 } 846 if (!dev->transport->init_prot || !dev->transport->free_prot) { 847 /* 0 is only allowed value for non-supporting backends */ 848 if (flag == 0) 849 return count; 850 851 pr_err("DIF protection not supported by backend: %s\n", 852 dev->transport->name); 853 return -ENOSYS; 854 } 855 if (!target_dev_configured(dev)) { 856 pr_err("DIF protection requires device to be configured\n"); 857 return -ENODEV; 858 } 859 if (dev->export_count) { 860 pr_err("dev[%p]: Unable to change SE Device PROT type while" 861 " export_count is %d\n", dev, dev->export_count); 862 return -EINVAL; 863 } 864 865 da->pi_prot_type = flag; 866 867 if (flag && !old_prot) { 868 ret = dev->transport->init_prot(dev); 869 if (ret) { 870 da->pi_prot_type = old_prot; 871 da->pi_prot_verify = (bool) da->pi_prot_type; 872 return ret; 873 } 874 875 } else if (!flag && old_prot) { 876 dev->transport->free_prot(dev); 877 } 878 879 da->pi_prot_verify = (bool) da->pi_prot_type; 880 pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag); 881 return count; 882 } 883 884 /* always zero, but attr needs to remain RW to avoid userspace breakage */ 885 static ssize_t pi_prot_format_show(struct config_item *item, char *page) 886 { 887 return snprintf(page, PAGE_SIZE, "0\n"); 888 } 889 890 static ssize_t pi_prot_format_store(struct config_item *item, 891 const char *page, size_t count) 892 { 893 struct se_dev_attrib *da = to_attrib(item); 894 struct se_device *dev = da->da_dev; 895 bool flag; 896 int ret; 897 898 ret = kstrtobool(page, &flag); 899 if (ret < 0) 900 return ret; 901 902 if (!flag) 903 return count; 904 905 if (!dev->transport->format_prot) { 906 pr_err("DIF protection format not supported by backend %s\n", 907 dev->transport->name); 908 return -ENOSYS; 909 } 910 if (!target_dev_configured(dev)) { 911 pr_err("DIF protection format requires device to be configured\n"); 912 return -ENODEV; 913 } 914 if (dev->export_count) { 915 pr_err("dev[%p]: Unable to format SE Device PROT type while" 916 " export_count is %d\n", dev, dev->export_count); 917 return -EINVAL; 918 } 919 920 ret = dev->transport->format_prot(dev); 921 if (ret) 922 return ret; 923 924 pr_debug("dev[%p]: SE Device Protection Format complete\n", dev); 925 return count; 926 } 927 928 static ssize_t pi_prot_verify_store(struct config_item *item, 929 const char *page, size_t count) 930 { 931 struct se_dev_attrib *da = to_attrib(item); 932 bool flag; 933 int ret; 934 935 ret = kstrtobool(page, &flag); 936 if (ret < 0) 937 return ret; 938 939 if (!flag) { 940 da->pi_prot_verify = flag; 941 return count; 942 } 943 if (da->hw_pi_prot_type) { 944 pr_warn("DIF protection enabled on underlying hardware," 945 " ignoring\n"); 946 return count; 947 } 948 if (!da->pi_prot_type) { 949 pr_warn("DIF protection not supported by backend, ignoring\n"); 950 return count; 951 } 952 da->pi_prot_verify = flag; 953 954 return count; 955 } 956 957 static ssize_t force_pr_aptpl_store(struct config_item *item, 958 const char *page, size_t count) 959 { 960 struct se_dev_attrib *da = to_attrib(item); 961 bool flag; 962 int ret; 963 964 ret = kstrtobool(page, &flag); 965 if (ret < 0) 966 return ret; 967 if (da->da_dev->export_count) { 968 pr_err("dev[%p]: Unable to set force_pr_aptpl while" 969 " export_count is %d\n", 970 da->da_dev, da->da_dev->export_count); 971 return -EINVAL; 972 } 973 974 da->force_pr_aptpl = flag; 975 pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", da->da_dev, flag); 976 return count; 977 } 978 979 static ssize_t emulate_rest_reord_store(struct config_item *item, 980 const char *page, size_t count) 981 { 982 struct se_dev_attrib *da = to_attrib(item); 983 bool flag; 984 int ret; 985 986 ret = kstrtobool(page, &flag); 987 if (ret < 0) 988 return ret; 989 990 if (flag != 0) { 991 printk(KERN_ERR "dev[%p]: SE Device emulation of restricted" 992 " reordering not implemented\n", da->da_dev); 993 return -ENOSYS; 994 } 995 da->emulate_rest_reord = flag; 996 pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", 997 da->da_dev, flag); 998 return count; 999 } 1000 1001 static ssize_t unmap_zeroes_data_store(struct config_item *item, 1002 const char *page, size_t count) 1003 { 1004 struct se_dev_attrib *da = to_attrib(item); 1005 struct se_device *dev = da->da_dev; 1006 bool flag; 1007 int ret; 1008 1009 ret = kstrtobool(page, &flag); 1010 if (ret < 0) 1011 return ret; 1012 1013 if (da->da_dev->export_count) { 1014 pr_err("dev[%p]: Unable to change SE Device" 1015 " unmap_zeroes_data while export_count is %d\n", 1016 da->da_dev, da->da_dev->export_count); 1017 return -EINVAL; 1018 } 1019 /* 1020 * We expect this value to be non-zero when generic Block Layer 1021 * Discard supported is detected iblock_configure_device(). 1022 */ 1023 if (flag && !da->max_unmap_block_desc_count) { 1024 if (!dev->transport->configure_unmap || 1025 !dev->transport->configure_unmap(dev)) { 1026 pr_err("dev[%p]: Thin Provisioning LBPRZ will not be set because max_unmap_block_desc_count is zero\n", 1027 da->da_dev); 1028 return -ENOSYS; 1029 } 1030 } 1031 da->unmap_zeroes_data = flag; 1032 pr_debug("dev[%p]: SE Device Thin Provisioning LBPRZ bit: %d\n", 1033 da->da_dev, flag); 1034 return count; 1035 } 1036 1037 /* 1038 * Note, this can only be called on unexported SE Device Object. 1039 */ 1040 static ssize_t queue_depth_store(struct config_item *item, 1041 const char *page, size_t count) 1042 { 1043 struct se_dev_attrib *da = to_attrib(item); 1044 struct se_device *dev = da->da_dev; 1045 u32 val; 1046 int ret; 1047 1048 ret = kstrtou32(page, 0, &val); 1049 if (ret < 0) 1050 return ret; 1051 1052 if (dev->export_count) { 1053 pr_err("dev[%p]: Unable to change SE Device TCQ while" 1054 " export_count is %d\n", 1055 dev, dev->export_count); 1056 return -EINVAL; 1057 } 1058 if (!val) { 1059 pr_err("dev[%p]: Illegal ZERO value for queue_depth\n", dev); 1060 return -EINVAL; 1061 } 1062 1063 if (val > dev->dev_attrib.queue_depth) { 1064 if (val > dev->dev_attrib.hw_queue_depth) { 1065 pr_err("dev[%p]: Passed queue_depth:" 1066 " %u exceeds TCM/SE_Device MAX" 1067 " TCQ: %u\n", dev, val, 1068 dev->dev_attrib.hw_queue_depth); 1069 return -EINVAL; 1070 } 1071 } 1072 da->queue_depth = dev->queue_depth = val; 1073 pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n", dev, val); 1074 return count; 1075 } 1076 1077 static ssize_t optimal_sectors_store(struct config_item *item, 1078 const char *page, size_t count) 1079 { 1080 struct se_dev_attrib *da = to_attrib(item); 1081 u32 val; 1082 int ret; 1083 1084 ret = kstrtou32(page, 0, &val); 1085 if (ret < 0) 1086 return ret; 1087 1088 if (da->da_dev->export_count) { 1089 pr_err("dev[%p]: Unable to change SE Device" 1090 " optimal_sectors while export_count is %d\n", 1091 da->da_dev, da->da_dev->export_count); 1092 return -EINVAL; 1093 } 1094 if (val > da->hw_max_sectors) { 1095 pr_err("dev[%p]: Passed optimal_sectors %u cannot be" 1096 " greater than hw_max_sectors: %u\n", 1097 da->da_dev, val, da->hw_max_sectors); 1098 return -EINVAL; 1099 } 1100 1101 da->optimal_sectors = val; 1102 pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n", 1103 da->da_dev, val); 1104 return count; 1105 } 1106 1107 static ssize_t block_size_store(struct config_item *item, 1108 const char *page, size_t count) 1109 { 1110 struct se_dev_attrib *da = to_attrib(item); 1111 u32 val; 1112 int ret; 1113 1114 ret = kstrtou32(page, 0, &val); 1115 if (ret < 0) 1116 return ret; 1117 1118 if (da->da_dev->export_count) { 1119 pr_err("dev[%p]: Unable to change SE Device block_size" 1120 " while export_count is %d\n", 1121 da->da_dev, da->da_dev->export_count); 1122 return -EINVAL; 1123 } 1124 1125 if (val != 512 && val != 1024 && val != 2048 && val != 4096) { 1126 pr_err("dev[%p]: Illegal value for block_device: %u" 1127 " for SE device, must be 512, 1024, 2048 or 4096\n", 1128 da->da_dev, val); 1129 return -EINVAL; 1130 } 1131 1132 da->block_size = val; 1133 1134 pr_debug("dev[%p]: SE Device block_size changed to %u\n", 1135 da->da_dev, val); 1136 return count; 1137 } 1138 1139 static ssize_t alua_support_show(struct config_item *item, char *page) 1140 { 1141 struct se_dev_attrib *da = to_attrib(item); 1142 u8 flags = da->da_dev->transport_flags; 1143 1144 return snprintf(page, PAGE_SIZE, "%d\n", 1145 flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA ? 0 : 1); 1146 } 1147 1148 static ssize_t alua_support_store(struct config_item *item, 1149 const char *page, size_t count) 1150 { 1151 struct se_dev_attrib *da = to_attrib(item); 1152 struct se_device *dev = da->da_dev; 1153 bool flag, oldflag; 1154 int ret; 1155 1156 ret = kstrtobool(page, &flag); 1157 if (ret < 0) 1158 return ret; 1159 1160 oldflag = !(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA); 1161 if (flag == oldflag) 1162 return count; 1163 1164 if (!(dev->transport->transport_flags_changeable & 1165 TRANSPORT_FLAG_PASSTHROUGH_ALUA)) { 1166 pr_err("dev[%p]: Unable to change SE Device alua_support:" 1167 " alua_support has fixed value\n", dev); 1168 return -ENOSYS; 1169 } 1170 1171 if (flag) 1172 dev->transport_flags &= ~TRANSPORT_FLAG_PASSTHROUGH_ALUA; 1173 else 1174 dev->transport_flags |= TRANSPORT_FLAG_PASSTHROUGH_ALUA; 1175 return count; 1176 } 1177 1178 static ssize_t pgr_support_show(struct config_item *item, char *page) 1179 { 1180 struct se_dev_attrib *da = to_attrib(item); 1181 u8 flags = da->da_dev->transport_flags; 1182 1183 return snprintf(page, PAGE_SIZE, "%d\n", 1184 flags & TRANSPORT_FLAG_PASSTHROUGH_PGR ? 0 : 1); 1185 } 1186 1187 static ssize_t pgr_support_store(struct config_item *item, 1188 const char *page, size_t count) 1189 { 1190 struct se_dev_attrib *da = to_attrib(item); 1191 struct se_device *dev = da->da_dev; 1192 bool flag, oldflag; 1193 int ret; 1194 1195 ret = kstrtobool(page, &flag); 1196 if (ret < 0) 1197 return ret; 1198 1199 oldflag = !(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR); 1200 if (flag == oldflag) 1201 return count; 1202 1203 if (!(dev->transport->transport_flags_changeable & 1204 TRANSPORT_FLAG_PASSTHROUGH_PGR)) { 1205 pr_err("dev[%p]: Unable to change SE Device pgr_support:" 1206 " pgr_support has fixed value\n", dev); 1207 return -ENOSYS; 1208 } 1209 1210 if (flag) 1211 dev->transport_flags &= ~TRANSPORT_FLAG_PASSTHROUGH_PGR; 1212 else 1213 dev->transport_flags |= TRANSPORT_FLAG_PASSTHROUGH_PGR; 1214 return count; 1215 } 1216 1217 static ssize_t emulate_rsoc_store(struct config_item *item, 1218 const char *page, size_t count) 1219 { 1220 struct se_dev_attrib *da = to_attrib(item); 1221 bool flag; 1222 int ret; 1223 1224 ret = kstrtobool(page, &flag); 1225 if (ret < 0) 1226 return ret; 1227 1228 da->emulate_rsoc = flag; 1229 pr_debug("dev[%p]: SE Device REPORT_SUPPORTED_OPERATION_CODES_EMULATION flag: %d\n", 1230 da->da_dev, flag); 1231 return count; 1232 } 1233 1234 CONFIGFS_ATTR(, emulate_model_alias); 1235 CONFIGFS_ATTR(, emulate_dpo); 1236 CONFIGFS_ATTR(, emulate_fua_write); 1237 CONFIGFS_ATTR(, emulate_fua_read); 1238 CONFIGFS_ATTR(, emulate_write_cache); 1239 CONFIGFS_ATTR(, emulate_ua_intlck_ctrl); 1240 CONFIGFS_ATTR(, emulate_tas); 1241 CONFIGFS_ATTR(, emulate_tpu); 1242 CONFIGFS_ATTR(, emulate_tpws); 1243 CONFIGFS_ATTR(, emulate_caw); 1244 CONFIGFS_ATTR(, emulate_3pc); 1245 CONFIGFS_ATTR(, emulate_pr); 1246 CONFIGFS_ATTR(, emulate_rsoc); 1247 CONFIGFS_ATTR(, pi_prot_type); 1248 CONFIGFS_ATTR_RO(, hw_pi_prot_type); 1249 CONFIGFS_ATTR(, pi_prot_format); 1250 CONFIGFS_ATTR(, pi_prot_verify); 1251 CONFIGFS_ATTR(, enforce_pr_isids); 1252 CONFIGFS_ATTR(, is_nonrot); 1253 CONFIGFS_ATTR(, emulate_rest_reord); 1254 CONFIGFS_ATTR(, force_pr_aptpl); 1255 CONFIGFS_ATTR_RO(, hw_block_size); 1256 CONFIGFS_ATTR(, block_size); 1257 CONFIGFS_ATTR_RO(, hw_max_sectors); 1258 CONFIGFS_ATTR(, optimal_sectors); 1259 CONFIGFS_ATTR_RO(, hw_queue_depth); 1260 CONFIGFS_ATTR(, queue_depth); 1261 CONFIGFS_ATTR(, max_unmap_lba_count); 1262 CONFIGFS_ATTR(, max_unmap_block_desc_count); 1263 CONFIGFS_ATTR(, unmap_granularity); 1264 CONFIGFS_ATTR(, unmap_granularity_alignment); 1265 CONFIGFS_ATTR(, unmap_zeroes_data); 1266 CONFIGFS_ATTR(, max_write_same_len); 1267 CONFIGFS_ATTR(, alua_support); 1268 CONFIGFS_ATTR(, pgr_support); 1269 1270 /* 1271 * dev_attrib attributes for devices using the target core SBC/SPC 1272 * interpreter. Any backend using spc_parse_cdb should be using 1273 * these. 1274 */ 1275 struct configfs_attribute *sbc_attrib_attrs[] = { 1276 &attr_emulate_model_alias, 1277 &attr_emulate_dpo, 1278 &attr_emulate_fua_write, 1279 &attr_emulate_fua_read, 1280 &attr_emulate_write_cache, 1281 &attr_emulate_ua_intlck_ctrl, 1282 &attr_emulate_tas, 1283 &attr_emulate_tpu, 1284 &attr_emulate_tpws, 1285 &attr_emulate_caw, 1286 &attr_emulate_3pc, 1287 &attr_emulate_pr, 1288 &attr_pi_prot_type, 1289 &attr_hw_pi_prot_type, 1290 &attr_pi_prot_format, 1291 &attr_pi_prot_verify, 1292 &attr_enforce_pr_isids, 1293 &attr_is_nonrot, 1294 &attr_emulate_rest_reord, 1295 &attr_force_pr_aptpl, 1296 &attr_hw_block_size, 1297 &attr_block_size, 1298 &attr_hw_max_sectors, 1299 &attr_optimal_sectors, 1300 &attr_hw_queue_depth, 1301 &attr_queue_depth, 1302 &attr_max_unmap_lba_count, 1303 &attr_max_unmap_block_desc_count, 1304 &attr_unmap_granularity, 1305 &attr_unmap_granularity_alignment, 1306 &attr_unmap_zeroes_data, 1307 &attr_max_write_same_len, 1308 &attr_alua_support, 1309 &attr_pgr_support, 1310 &attr_emulate_rsoc, 1311 NULL, 1312 }; 1313 EXPORT_SYMBOL(sbc_attrib_attrs); 1314 1315 /* 1316 * Minimal dev_attrib attributes for devices passing through CDBs. 1317 * In this case we only provide a few read-only attributes for 1318 * backwards compatibility. 1319 */ 1320 struct configfs_attribute *passthrough_attrib_attrs[] = { 1321 &attr_hw_pi_prot_type, 1322 &attr_hw_block_size, 1323 &attr_hw_max_sectors, 1324 &attr_hw_queue_depth, 1325 &attr_emulate_pr, 1326 &attr_alua_support, 1327 &attr_pgr_support, 1328 NULL, 1329 }; 1330 EXPORT_SYMBOL(passthrough_attrib_attrs); 1331 1332 /* 1333 * pr related dev_attrib attributes for devices passing through CDBs, 1334 * but allowing in core pr emulation. 1335 */ 1336 struct configfs_attribute *passthrough_pr_attrib_attrs[] = { 1337 &attr_enforce_pr_isids, 1338 &attr_force_pr_aptpl, 1339 NULL, 1340 }; 1341 EXPORT_SYMBOL(passthrough_pr_attrib_attrs); 1342 1343 TB_CIT_SETUP_DRV(dev_attrib, NULL, NULL); 1344 TB_CIT_SETUP_DRV(dev_action, NULL, NULL); 1345 1346 /* End functions for struct config_item_type tb_dev_attrib_cit */ 1347 1348 /* Start functions for struct config_item_type tb_dev_wwn_cit */ 1349 1350 static struct t10_wwn *to_t10_wwn(struct config_item *item) 1351 { 1352 return container_of(to_config_group(item), struct t10_wwn, t10_wwn_group); 1353 } 1354 1355 static ssize_t target_check_inquiry_data(char *buf) 1356 { 1357 size_t len; 1358 int i; 1359 1360 len = strlen(buf); 1361 1362 /* 1363 * SPC 4.3.1: 1364 * ASCII data fields shall contain only ASCII printable characters 1365 * (i.e., code values 20h to 7Eh) and may be terminated with one or 1366 * more ASCII null (00h) characters. 1367 */ 1368 for (i = 0; i < len; i++) { 1369 if (buf[i] < 0x20 || buf[i] > 0x7E) { 1370 pr_err("Emulated T10 Inquiry Data contains non-ASCII-printable characters\n"); 1371 return -EINVAL; 1372 } 1373 } 1374 1375 return len; 1376 } 1377 1378 /* 1379 * STANDARD and VPD page 0x83 T10 Vendor Identification 1380 */ 1381 static ssize_t target_wwn_vendor_id_show(struct config_item *item, 1382 char *page) 1383 { 1384 return sprintf(page, "%s\n", &to_t10_wwn(item)->vendor[0]); 1385 } 1386 1387 static ssize_t target_wwn_vendor_id_store(struct config_item *item, 1388 const char *page, size_t count) 1389 { 1390 struct t10_wwn *t10_wwn = to_t10_wwn(item); 1391 struct se_device *dev = t10_wwn->t10_dev; 1392 /* +2 to allow for a trailing (stripped) '\n' and null-terminator */ 1393 unsigned char buf[INQUIRY_VENDOR_LEN + 2]; 1394 char *stripped = NULL; 1395 size_t len; 1396 ssize_t ret; 1397 1398 len = strlcpy(buf, page, sizeof(buf)); 1399 if (len < sizeof(buf)) { 1400 /* Strip any newline added from userspace. */ 1401 stripped = strstrip(buf); 1402 len = strlen(stripped); 1403 } 1404 if (len > INQUIRY_VENDOR_LEN) { 1405 pr_err("Emulated T10 Vendor Identification exceeds" 1406 " INQUIRY_VENDOR_LEN: " __stringify(INQUIRY_VENDOR_LEN) 1407 "\n"); 1408 return -EOVERFLOW; 1409 } 1410 1411 ret = target_check_inquiry_data(stripped); 1412 1413 if (ret < 0) 1414 return ret; 1415 1416 /* 1417 * Check to see if any active exports exist. If they do exist, fail 1418 * here as changing this information on the fly (underneath the 1419 * initiator side OS dependent multipath code) could cause negative 1420 * effects. 1421 */ 1422 if (dev->export_count) { 1423 pr_err("Unable to set T10 Vendor Identification while" 1424 " active %d exports exist\n", dev->export_count); 1425 return -EINVAL; 1426 } 1427 1428 BUILD_BUG_ON(sizeof(dev->t10_wwn.vendor) != INQUIRY_VENDOR_LEN + 1); 1429 strlcpy(dev->t10_wwn.vendor, stripped, sizeof(dev->t10_wwn.vendor)); 1430 1431 pr_debug("Target_Core_ConfigFS: Set emulated T10 Vendor Identification:" 1432 " %s\n", dev->t10_wwn.vendor); 1433 1434 return count; 1435 } 1436 1437 static ssize_t target_wwn_product_id_show(struct config_item *item, 1438 char *page) 1439 { 1440 return sprintf(page, "%s\n", &to_t10_wwn(item)->model[0]); 1441 } 1442 1443 static ssize_t target_wwn_product_id_store(struct config_item *item, 1444 const char *page, size_t count) 1445 { 1446 struct t10_wwn *t10_wwn = to_t10_wwn(item); 1447 struct se_device *dev = t10_wwn->t10_dev; 1448 /* +2 to allow for a trailing (stripped) '\n' and null-terminator */ 1449 unsigned char buf[INQUIRY_MODEL_LEN + 2]; 1450 char *stripped = NULL; 1451 size_t len; 1452 ssize_t ret; 1453 1454 len = strlcpy(buf, page, sizeof(buf)); 1455 if (len < sizeof(buf)) { 1456 /* Strip any newline added from userspace. */ 1457 stripped = strstrip(buf); 1458 len = strlen(stripped); 1459 } 1460 if (len > INQUIRY_MODEL_LEN) { 1461 pr_err("Emulated T10 Vendor exceeds INQUIRY_MODEL_LEN: " 1462 __stringify(INQUIRY_MODEL_LEN) 1463 "\n"); 1464 return -EOVERFLOW; 1465 } 1466 1467 ret = target_check_inquiry_data(stripped); 1468 1469 if (ret < 0) 1470 return ret; 1471 1472 /* 1473 * Check to see if any active exports exist. If they do exist, fail 1474 * here as changing this information on the fly (underneath the 1475 * initiator side OS dependent multipath code) could cause negative 1476 * effects. 1477 */ 1478 if (dev->export_count) { 1479 pr_err("Unable to set T10 Model while active %d exports exist\n", 1480 dev->export_count); 1481 return -EINVAL; 1482 } 1483 1484 BUILD_BUG_ON(sizeof(dev->t10_wwn.model) != INQUIRY_MODEL_LEN + 1); 1485 strlcpy(dev->t10_wwn.model, stripped, sizeof(dev->t10_wwn.model)); 1486 1487 pr_debug("Target_Core_ConfigFS: Set emulated T10 Model Identification: %s\n", 1488 dev->t10_wwn.model); 1489 1490 return count; 1491 } 1492 1493 static ssize_t target_wwn_revision_show(struct config_item *item, 1494 char *page) 1495 { 1496 return sprintf(page, "%s\n", &to_t10_wwn(item)->revision[0]); 1497 } 1498 1499 static ssize_t target_wwn_revision_store(struct config_item *item, 1500 const char *page, size_t count) 1501 { 1502 struct t10_wwn *t10_wwn = to_t10_wwn(item); 1503 struct se_device *dev = t10_wwn->t10_dev; 1504 /* +2 to allow for a trailing (stripped) '\n' and null-terminator */ 1505 unsigned char buf[INQUIRY_REVISION_LEN + 2]; 1506 char *stripped = NULL; 1507 size_t len; 1508 ssize_t ret; 1509 1510 len = strlcpy(buf, page, sizeof(buf)); 1511 if (len < sizeof(buf)) { 1512 /* Strip any newline added from userspace. */ 1513 stripped = strstrip(buf); 1514 len = strlen(stripped); 1515 } 1516 if (len > INQUIRY_REVISION_LEN) { 1517 pr_err("Emulated T10 Revision exceeds INQUIRY_REVISION_LEN: " 1518 __stringify(INQUIRY_REVISION_LEN) 1519 "\n"); 1520 return -EOVERFLOW; 1521 } 1522 1523 ret = target_check_inquiry_data(stripped); 1524 1525 if (ret < 0) 1526 return ret; 1527 1528 /* 1529 * Check to see if any active exports exist. If they do exist, fail 1530 * here as changing this information on the fly (underneath the 1531 * initiator side OS dependent multipath code) could cause negative 1532 * effects. 1533 */ 1534 if (dev->export_count) { 1535 pr_err("Unable to set T10 Revision while active %d exports exist\n", 1536 dev->export_count); 1537 return -EINVAL; 1538 } 1539 1540 BUILD_BUG_ON(sizeof(dev->t10_wwn.revision) != INQUIRY_REVISION_LEN + 1); 1541 strlcpy(dev->t10_wwn.revision, stripped, sizeof(dev->t10_wwn.revision)); 1542 1543 pr_debug("Target_Core_ConfigFS: Set emulated T10 Revision: %s\n", 1544 dev->t10_wwn.revision); 1545 1546 return count; 1547 } 1548 1549 static ssize_t 1550 target_wwn_company_id_show(struct config_item *item, 1551 char *page) 1552 { 1553 return snprintf(page, PAGE_SIZE, "%#08x\n", 1554 to_t10_wwn(item)->company_id); 1555 } 1556 1557 static ssize_t 1558 target_wwn_company_id_store(struct config_item *item, 1559 const char *page, size_t count) 1560 { 1561 struct t10_wwn *t10_wwn = to_t10_wwn(item); 1562 struct se_device *dev = t10_wwn->t10_dev; 1563 u32 val; 1564 int ret; 1565 1566 /* 1567 * The IEEE COMPANY_ID field should contain a 24-bit canonical 1568 * form OUI assigned by the IEEE. 1569 */ 1570 ret = kstrtou32(page, 0, &val); 1571 if (ret < 0) 1572 return ret; 1573 1574 if (val >= 0x1000000) 1575 return -EOVERFLOW; 1576 1577 /* 1578 * Check to see if any active exports exist. If they do exist, fail 1579 * here as changing this information on the fly (underneath the 1580 * initiator side OS dependent multipath code) could cause negative 1581 * effects. 1582 */ 1583 if (dev->export_count) { 1584 pr_err("Unable to set Company ID while %u exports exist\n", 1585 dev->export_count); 1586 return -EINVAL; 1587 } 1588 1589 t10_wwn->company_id = val; 1590 1591 pr_debug("Target_Core_ConfigFS: Set IEEE Company ID: %#08x\n", 1592 t10_wwn->company_id); 1593 1594 return count; 1595 } 1596 1597 /* 1598 * VPD page 0x80 Unit serial 1599 */ 1600 static ssize_t target_wwn_vpd_unit_serial_show(struct config_item *item, 1601 char *page) 1602 { 1603 return sprintf(page, "T10 VPD Unit Serial Number: %s\n", 1604 &to_t10_wwn(item)->unit_serial[0]); 1605 } 1606 1607 static ssize_t target_wwn_vpd_unit_serial_store(struct config_item *item, 1608 const char *page, size_t count) 1609 { 1610 struct t10_wwn *t10_wwn = to_t10_wwn(item); 1611 struct se_device *dev = t10_wwn->t10_dev; 1612 unsigned char buf[INQUIRY_VPD_SERIAL_LEN] = { }; 1613 1614 /* 1615 * If Linux/SCSI subsystem_api_t plugin got a VPD Unit Serial 1616 * from the struct scsi_device level firmware, do not allow 1617 * VPD Unit Serial to be emulated. 1618 * 1619 * Note this struct scsi_device could also be emulating VPD 1620 * information from its drivers/scsi LLD. But for now we assume 1621 * it is doing 'the right thing' wrt a world wide unique 1622 * VPD Unit Serial Number that OS dependent multipath can depend on. 1623 */ 1624 if (dev->dev_flags & DF_FIRMWARE_VPD_UNIT_SERIAL) { 1625 pr_err("Underlying SCSI device firmware provided VPD" 1626 " Unit Serial, ignoring request\n"); 1627 return -EOPNOTSUPP; 1628 } 1629 1630 if (strlen(page) >= INQUIRY_VPD_SERIAL_LEN) { 1631 pr_err("Emulated VPD Unit Serial exceeds" 1632 " INQUIRY_VPD_SERIAL_LEN: %d\n", INQUIRY_VPD_SERIAL_LEN); 1633 return -EOVERFLOW; 1634 } 1635 /* 1636 * Check to see if any active $FABRIC_MOD exports exist. If they 1637 * do exist, fail here as changing this information on the fly 1638 * (underneath the initiator side OS dependent multipath code) 1639 * could cause negative effects. 1640 */ 1641 if (dev->export_count) { 1642 pr_err("Unable to set VPD Unit Serial while" 1643 " active %d $FABRIC_MOD exports exist\n", 1644 dev->export_count); 1645 return -EINVAL; 1646 } 1647 1648 /* 1649 * This currently assumes ASCII encoding for emulated VPD Unit Serial. 1650 * 1651 * Also, strip any newline added from the userspace 1652 * echo $UUID > $TARGET/$HBA/$STORAGE_OBJECT/wwn/vpd_unit_serial 1653 */ 1654 snprintf(buf, INQUIRY_VPD_SERIAL_LEN, "%s", page); 1655 snprintf(dev->t10_wwn.unit_serial, INQUIRY_VPD_SERIAL_LEN, 1656 "%s", strstrip(buf)); 1657 dev->dev_flags |= DF_EMULATED_VPD_UNIT_SERIAL; 1658 1659 pr_debug("Target_Core_ConfigFS: Set emulated VPD Unit Serial:" 1660 " %s\n", dev->t10_wwn.unit_serial); 1661 1662 return count; 1663 } 1664 1665 /* 1666 * VPD page 0x83 Protocol Identifier 1667 */ 1668 static ssize_t target_wwn_vpd_protocol_identifier_show(struct config_item *item, 1669 char *page) 1670 { 1671 struct t10_wwn *t10_wwn = to_t10_wwn(item); 1672 struct t10_vpd *vpd; 1673 unsigned char buf[VPD_TMP_BUF_SIZE] = { }; 1674 ssize_t len = 0; 1675 1676 spin_lock(&t10_wwn->t10_vpd_lock); 1677 list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) { 1678 if (!vpd->protocol_identifier_set) 1679 continue; 1680 1681 transport_dump_vpd_proto_id(vpd, buf, VPD_TMP_BUF_SIZE); 1682 1683 if (len + strlen(buf) >= PAGE_SIZE) 1684 break; 1685 1686 len += sprintf(page+len, "%s", buf); 1687 } 1688 spin_unlock(&t10_wwn->t10_vpd_lock); 1689 1690 return len; 1691 } 1692 1693 /* 1694 * Generic wrapper for dumping VPD identifiers by association. 1695 */ 1696 #define DEF_DEV_WWN_ASSOC_SHOW(_name, _assoc) \ 1697 static ssize_t target_wwn_##_name##_show(struct config_item *item, \ 1698 char *page) \ 1699 { \ 1700 struct t10_wwn *t10_wwn = to_t10_wwn(item); \ 1701 struct t10_vpd *vpd; \ 1702 unsigned char buf[VPD_TMP_BUF_SIZE]; \ 1703 ssize_t len = 0; \ 1704 \ 1705 spin_lock(&t10_wwn->t10_vpd_lock); \ 1706 list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) { \ 1707 if (vpd->association != _assoc) \ 1708 continue; \ 1709 \ 1710 memset(buf, 0, VPD_TMP_BUF_SIZE); \ 1711 transport_dump_vpd_assoc(vpd, buf, VPD_TMP_BUF_SIZE); \ 1712 if (len + strlen(buf) >= PAGE_SIZE) \ 1713 break; \ 1714 len += sprintf(page+len, "%s", buf); \ 1715 \ 1716 memset(buf, 0, VPD_TMP_BUF_SIZE); \ 1717 transport_dump_vpd_ident_type(vpd, buf, VPD_TMP_BUF_SIZE); \ 1718 if (len + strlen(buf) >= PAGE_SIZE) \ 1719 break; \ 1720 len += sprintf(page+len, "%s", buf); \ 1721 \ 1722 memset(buf, 0, VPD_TMP_BUF_SIZE); \ 1723 transport_dump_vpd_ident(vpd, buf, VPD_TMP_BUF_SIZE); \ 1724 if (len + strlen(buf) >= PAGE_SIZE) \ 1725 break; \ 1726 len += sprintf(page+len, "%s", buf); \ 1727 } \ 1728 spin_unlock(&t10_wwn->t10_vpd_lock); \ 1729 \ 1730 return len; \ 1731 } 1732 1733 /* VPD page 0x83 Association: Logical Unit */ 1734 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_logical_unit, 0x00); 1735 /* VPD page 0x83 Association: Target Port */ 1736 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_target_port, 0x10); 1737 /* VPD page 0x83 Association: SCSI Target Device */ 1738 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_scsi_target_device, 0x20); 1739 1740 CONFIGFS_ATTR(target_wwn_, vendor_id); 1741 CONFIGFS_ATTR(target_wwn_, product_id); 1742 CONFIGFS_ATTR(target_wwn_, revision); 1743 CONFIGFS_ATTR(target_wwn_, company_id); 1744 CONFIGFS_ATTR(target_wwn_, vpd_unit_serial); 1745 CONFIGFS_ATTR_RO(target_wwn_, vpd_protocol_identifier); 1746 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_logical_unit); 1747 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_target_port); 1748 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_scsi_target_device); 1749 1750 static struct configfs_attribute *target_core_dev_wwn_attrs[] = { 1751 &target_wwn_attr_vendor_id, 1752 &target_wwn_attr_product_id, 1753 &target_wwn_attr_revision, 1754 &target_wwn_attr_company_id, 1755 &target_wwn_attr_vpd_unit_serial, 1756 &target_wwn_attr_vpd_protocol_identifier, 1757 &target_wwn_attr_vpd_assoc_logical_unit, 1758 &target_wwn_attr_vpd_assoc_target_port, 1759 &target_wwn_attr_vpd_assoc_scsi_target_device, 1760 NULL, 1761 }; 1762 1763 TB_CIT_SETUP(dev_wwn, NULL, NULL, target_core_dev_wwn_attrs); 1764 1765 /* End functions for struct config_item_type tb_dev_wwn_cit */ 1766 1767 /* Start functions for struct config_item_type tb_dev_pr_cit */ 1768 1769 static struct se_device *pr_to_dev(struct config_item *item) 1770 { 1771 return container_of(to_config_group(item), struct se_device, 1772 dev_pr_group); 1773 } 1774 1775 static ssize_t target_core_dev_pr_show_spc3_res(struct se_device *dev, 1776 char *page) 1777 { 1778 struct se_node_acl *se_nacl; 1779 struct t10_pr_registration *pr_reg; 1780 char i_buf[PR_REG_ISID_ID_LEN] = { }; 1781 1782 pr_reg = dev->dev_pr_res_holder; 1783 if (!pr_reg) 1784 return sprintf(page, "No SPC-3 Reservation holder\n"); 1785 1786 se_nacl = pr_reg->pr_reg_nacl; 1787 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN); 1788 1789 return sprintf(page, "SPC-3 Reservation: %s Initiator: %s%s\n", 1790 se_nacl->se_tpg->se_tpg_tfo->fabric_name, 1791 se_nacl->initiatorname, i_buf); 1792 } 1793 1794 static ssize_t target_core_dev_pr_show_spc2_res(struct se_device *dev, 1795 char *page) 1796 { 1797 struct se_session *sess = dev->reservation_holder; 1798 struct se_node_acl *se_nacl; 1799 ssize_t len; 1800 1801 if (sess) { 1802 se_nacl = sess->se_node_acl; 1803 len = sprintf(page, 1804 "SPC-2 Reservation: %s Initiator: %s\n", 1805 se_nacl->se_tpg->se_tpg_tfo->fabric_name, 1806 se_nacl->initiatorname); 1807 } else { 1808 len = sprintf(page, "No SPC-2 Reservation holder\n"); 1809 } 1810 return len; 1811 } 1812 1813 static ssize_t target_pr_res_holder_show(struct config_item *item, char *page) 1814 { 1815 struct se_device *dev = pr_to_dev(item); 1816 int ret; 1817 1818 if (!dev->dev_attrib.emulate_pr) 1819 return sprintf(page, "SPC_RESERVATIONS_DISABLED\n"); 1820 1821 if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR) 1822 return sprintf(page, "Passthrough\n"); 1823 1824 spin_lock(&dev->dev_reservation_lock); 1825 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) 1826 ret = target_core_dev_pr_show_spc2_res(dev, page); 1827 else 1828 ret = target_core_dev_pr_show_spc3_res(dev, page); 1829 spin_unlock(&dev->dev_reservation_lock); 1830 return ret; 1831 } 1832 1833 static ssize_t target_pr_res_pr_all_tgt_pts_show(struct config_item *item, 1834 char *page) 1835 { 1836 struct se_device *dev = pr_to_dev(item); 1837 ssize_t len = 0; 1838 1839 spin_lock(&dev->dev_reservation_lock); 1840 if (!dev->dev_pr_res_holder) { 1841 len = sprintf(page, "No SPC-3 Reservation holder\n"); 1842 } else if (dev->dev_pr_res_holder->pr_reg_all_tg_pt) { 1843 len = sprintf(page, "SPC-3 Reservation: All Target" 1844 " Ports registration\n"); 1845 } else { 1846 len = sprintf(page, "SPC-3 Reservation: Single" 1847 " Target Port registration\n"); 1848 } 1849 1850 spin_unlock(&dev->dev_reservation_lock); 1851 return len; 1852 } 1853 1854 static ssize_t target_pr_res_pr_generation_show(struct config_item *item, 1855 char *page) 1856 { 1857 return sprintf(page, "0x%08x\n", pr_to_dev(item)->t10_pr.pr_generation); 1858 } 1859 1860 1861 static ssize_t target_pr_res_pr_holder_tg_port_show(struct config_item *item, 1862 char *page) 1863 { 1864 struct se_device *dev = pr_to_dev(item); 1865 struct se_node_acl *se_nacl; 1866 struct se_portal_group *se_tpg; 1867 struct t10_pr_registration *pr_reg; 1868 const struct target_core_fabric_ops *tfo; 1869 ssize_t len = 0; 1870 1871 spin_lock(&dev->dev_reservation_lock); 1872 pr_reg = dev->dev_pr_res_holder; 1873 if (!pr_reg) { 1874 len = sprintf(page, "No SPC-3 Reservation holder\n"); 1875 goto out_unlock; 1876 } 1877 1878 se_nacl = pr_reg->pr_reg_nacl; 1879 se_tpg = se_nacl->se_tpg; 1880 tfo = se_tpg->se_tpg_tfo; 1881 1882 len += sprintf(page+len, "SPC-3 Reservation: %s" 1883 " Target Node Endpoint: %s\n", tfo->fabric_name, 1884 tfo->tpg_get_wwn(se_tpg)); 1885 len += sprintf(page+len, "SPC-3 Reservation: Relative Port" 1886 " Identifier Tag: %hu %s Portal Group Tag: %hu" 1887 " %s Logical Unit: %llu\n", pr_reg->tg_pt_sep_rtpi, 1888 tfo->fabric_name, tfo->tpg_get_tag(se_tpg), 1889 tfo->fabric_name, pr_reg->pr_aptpl_target_lun); 1890 1891 out_unlock: 1892 spin_unlock(&dev->dev_reservation_lock); 1893 return len; 1894 } 1895 1896 1897 static ssize_t target_pr_res_pr_registered_i_pts_show(struct config_item *item, 1898 char *page) 1899 { 1900 struct se_device *dev = pr_to_dev(item); 1901 const struct target_core_fabric_ops *tfo; 1902 struct t10_pr_registration *pr_reg; 1903 unsigned char buf[384]; 1904 char i_buf[PR_REG_ISID_ID_LEN]; 1905 ssize_t len = 0; 1906 int reg_count = 0; 1907 1908 len += sprintf(page+len, "SPC-3 PR Registrations:\n"); 1909 1910 spin_lock(&dev->t10_pr.registration_lock); 1911 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list, 1912 pr_reg_list) { 1913 1914 memset(buf, 0, 384); 1915 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 1916 tfo = pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo; 1917 core_pr_dump_initiator_port(pr_reg, i_buf, 1918 PR_REG_ISID_ID_LEN); 1919 sprintf(buf, "%s Node: %s%s Key: 0x%016Lx PRgen: 0x%08x\n", 1920 tfo->fabric_name, 1921 pr_reg->pr_reg_nacl->initiatorname, i_buf, pr_reg->pr_res_key, 1922 pr_reg->pr_res_generation); 1923 1924 if (len + strlen(buf) >= PAGE_SIZE) 1925 break; 1926 1927 len += sprintf(page+len, "%s", buf); 1928 reg_count++; 1929 } 1930 spin_unlock(&dev->t10_pr.registration_lock); 1931 1932 if (!reg_count) 1933 len += sprintf(page+len, "None\n"); 1934 1935 return len; 1936 } 1937 1938 static ssize_t target_pr_res_pr_type_show(struct config_item *item, char *page) 1939 { 1940 struct se_device *dev = pr_to_dev(item); 1941 struct t10_pr_registration *pr_reg; 1942 ssize_t len = 0; 1943 1944 spin_lock(&dev->dev_reservation_lock); 1945 pr_reg = dev->dev_pr_res_holder; 1946 if (pr_reg) { 1947 len = sprintf(page, "SPC-3 Reservation Type: %s\n", 1948 core_scsi3_pr_dump_type(pr_reg->pr_res_type)); 1949 } else { 1950 len = sprintf(page, "No SPC-3 Reservation holder\n"); 1951 } 1952 1953 spin_unlock(&dev->dev_reservation_lock); 1954 return len; 1955 } 1956 1957 static ssize_t target_pr_res_type_show(struct config_item *item, char *page) 1958 { 1959 struct se_device *dev = pr_to_dev(item); 1960 1961 if (!dev->dev_attrib.emulate_pr) 1962 return sprintf(page, "SPC_RESERVATIONS_DISABLED\n"); 1963 if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR) 1964 return sprintf(page, "SPC_PASSTHROUGH\n"); 1965 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) 1966 return sprintf(page, "SPC2_RESERVATIONS\n"); 1967 1968 return sprintf(page, "SPC3_PERSISTENT_RESERVATIONS\n"); 1969 } 1970 1971 static ssize_t target_pr_res_aptpl_active_show(struct config_item *item, 1972 char *page) 1973 { 1974 struct se_device *dev = pr_to_dev(item); 1975 1976 if (!dev->dev_attrib.emulate_pr || 1977 (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)) 1978 return 0; 1979 1980 return sprintf(page, "APTPL Bit Status: %s\n", 1981 (dev->t10_pr.pr_aptpl_active) ? "Activated" : "Disabled"); 1982 } 1983 1984 static ssize_t target_pr_res_aptpl_metadata_show(struct config_item *item, 1985 char *page) 1986 { 1987 struct se_device *dev = pr_to_dev(item); 1988 1989 if (!dev->dev_attrib.emulate_pr || 1990 (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)) 1991 return 0; 1992 1993 return sprintf(page, "Ready to process PR APTPL metadata..\n"); 1994 } 1995 1996 enum { 1997 Opt_initiator_fabric, Opt_initiator_node, Opt_initiator_sid, 1998 Opt_sa_res_key, Opt_res_holder, Opt_res_type, Opt_res_scope, 1999 Opt_res_all_tg_pt, Opt_mapped_lun, Opt_target_fabric, 2000 Opt_target_node, Opt_tpgt, Opt_port_rtpi, Opt_target_lun, Opt_err 2001 }; 2002 2003 static match_table_t tokens = { 2004 {Opt_initiator_fabric, "initiator_fabric=%s"}, 2005 {Opt_initiator_node, "initiator_node=%s"}, 2006 {Opt_initiator_sid, "initiator_sid=%s"}, 2007 {Opt_sa_res_key, "sa_res_key=%s"}, 2008 {Opt_res_holder, "res_holder=%d"}, 2009 {Opt_res_type, "res_type=%d"}, 2010 {Opt_res_scope, "res_scope=%d"}, 2011 {Opt_res_all_tg_pt, "res_all_tg_pt=%d"}, 2012 {Opt_mapped_lun, "mapped_lun=%u"}, 2013 {Opt_target_fabric, "target_fabric=%s"}, 2014 {Opt_target_node, "target_node=%s"}, 2015 {Opt_tpgt, "tpgt=%d"}, 2016 {Opt_port_rtpi, "port_rtpi=%d"}, 2017 {Opt_target_lun, "target_lun=%u"}, 2018 {Opt_err, NULL} 2019 }; 2020 2021 static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item, 2022 const char *page, size_t count) 2023 { 2024 struct se_device *dev = pr_to_dev(item); 2025 unsigned char *i_fabric = NULL, *i_port = NULL, *isid = NULL; 2026 unsigned char *t_fabric = NULL, *t_port = NULL; 2027 char *orig, *ptr, *opts; 2028 substring_t args[MAX_OPT_ARGS]; 2029 unsigned long long tmp_ll; 2030 u64 sa_res_key = 0; 2031 u64 mapped_lun = 0, target_lun = 0; 2032 int ret = -1, res_holder = 0, all_tg_pt = 0, arg, token; 2033 u16 tpgt = 0; 2034 u8 type = 0; 2035 2036 if (!dev->dev_attrib.emulate_pr || 2037 (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)) 2038 return count; 2039 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) 2040 return count; 2041 2042 if (dev->export_count) { 2043 pr_debug("Unable to process APTPL metadata while" 2044 " active fabric exports exist\n"); 2045 return -EINVAL; 2046 } 2047 2048 opts = kstrdup(page, GFP_KERNEL); 2049 if (!opts) 2050 return -ENOMEM; 2051 2052 orig = opts; 2053 while ((ptr = strsep(&opts, ",\n")) != NULL) { 2054 if (!*ptr) 2055 continue; 2056 2057 token = match_token(ptr, tokens, args); 2058 switch (token) { 2059 case Opt_initiator_fabric: 2060 i_fabric = match_strdup(args); 2061 if (!i_fabric) { 2062 ret = -ENOMEM; 2063 goto out; 2064 } 2065 break; 2066 case Opt_initiator_node: 2067 i_port = match_strdup(args); 2068 if (!i_port) { 2069 ret = -ENOMEM; 2070 goto out; 2071 } 2072 if (strlen(i_port) >= PR_APTPL_MAX_IPORT_LEN) { 2073 pr_err("APTPL metadata initiator_node=" 2074 " exceeds PR_APTPL_MAX_IPORT_LEN: %d\n", 2075 PR_APTPL_MAX_IPORT_LEN); 2076 ret = -EINVAL; 2077 break; 2078 } 2079 break; 2080 case Opt_initiator_sid: 2081 isid = match_strdup(args); 2082 if (!isid) { 2083 ret = -ENOMEM; 2084 goto out; 2085 } 2086 if (strlen(isid) >= PR_REG_ISID_LEN) { 2087 pr_err("APTPL metadata initiator_isid" 2088 "= exceeds PR_REG_ISID_LEN: %d\n", 2089 PR_REG_ISID_LEN); 2090 ret = -EINVAL; 2091 break; 2092 } 2093 break; 2094 case Opt_sa_res_key: 2095 ret = match_u64(args, &tmp_ll); 2096 if (ret < 0) { 2097 pr_err("kstrtoull() failed for sa_res_key=\n"); 2098 goto out; 2099 } 2100 sa_res_key = (u64)tmp_ll; 2101 break; 2102 /* 2103 * PR APTPL Metadata for Reservation 2104 */ 2105 case Opt_res_holder: 2106 ret = match_int(args, &arg); 2107 if (ret) 2108 goto out; 2109 res_holder = arg; 2110 break; 2111 case Opt_res_type: 2112 ret = match_int(args, &arg); 2113 if (ret) 2114 goto out; 2115 type = (u8)arg; 2116 break; 2117 case Opt_res_scope: 2118 ret = match_int(args, &arg); 2119 if (ret) 2120 goto out; 2121 break; 2122 case Opt_res_all_tg_pt: 2123 ret = match_int(args, &arg); 2124 if (ret) 2125 goto out; 2126 all_tg_pt = (int)arg; 2127 break; 2128 case Opt_mapped_lun: 2129 ret = match_u64(args, &tmp_ll); 2130 if (ret) 2131 goto out; 2132 mapped_lun = (u64)tmp_ll; 2133 break; 2134 /* 2135 * PR APTPL Metadata for Target Port 2136 */ 2137 case Opt_target_fabric: 2138 t_fabric = match_strdup(args); 2139 if (!t_fabric) { 2140 ret = -ENOMEM; 2141 goto out; 2142 } 2143 break; 2144 case Opt_target_node: 2145 t_port = match_strdup(args); 2146 if (!t_port) { 2147 ret = -ENOMEM; 2148 goto out; 2149 } 2150 if (strlen(t_port) >= PR_APTPL_MAX_TPORT_LEN) { 2151 pr_err("APTPL metadata target_node=" 2152 " exceeds PR_APTPL_MAX_TPORT_LEN: %d\n", 2153 PR_APTPL_MAX_TPORT_LEN); 2154 ret = -EINVAL; 2155 break; 2156 } 2157 break; 2158 case Opt_tpgt: 2159 ret = match_int(args, &arg); 2160 if (ret) 2161 goto out; 2162 tpgt = (u16)arg; 2163 break; 2164 case Opt_port_rtpi: 2165 ret = match_int(args, &arg); 2166 if (ret) 2167 goto out; 2168 break; 2169 case Opt_target_lun: 2170 ret = match_u64(args, &tmp_ll); 2171 if (ret) 2172 goto out; 2173 target_lun = (u64)tmp_ll; 2174 break; 2175 default: 2176 break; 2177 } 2178 } 2179 2180 if (!i_port || !t_port || !sa_res_key) { 2181 pr_err("Illegal parameters for APTPL registration\n"); 2182 ret = -EINVAL; 2183 goto out; 2184 } 2185 2186 if (res_holder && !(type)) { 2187 pr_err("Illegal PR type: 0x%02x for reservation" 2188 " holder\n", type); 2189 ret = -EINVAL; 2190 goto out; 2191 } 2192 2193 ret = core_scsi3_alloc_aptpl_registration(&dev->t10_pr, sa_res_key, 2194 i_port, isid, mapped_lun, t_port, tpgt, target_lun, 2195 res_holder, all_tg_pt, type); 2196 out: 2197 kfree(i_fabric); 2198 kfree(i_port); 2199 kfree(isid); 2200 kfree(t_fabric); 2201 kfree(t_port); 2202 kfree(orig); 2203 return (ret == 0) ? count : ret; 2204 } 2205 2206 2207 CONFIGFS_ATTR_RO(target_pr_, res_holder); 2208 CONFIGFS_ATTR_RO(target_pr_, res_pr_all_tgt_pts); 2209 CONFIGFS_ATTR_RO(target_pr_, res_pr_generation); 2210 CONFIGFS_ATTR_RO(target_pr_, res_pr_holder_tg_port); 2211 CONFIGFS_ATTR_RO(target_pr_, res_pr_registered_i_pts); 2212 CONFIGFS_ATTR_RO(target_pr_, res_pr_type); 2213 CONFIGFS_ATTR_RO(target_pr_, res_type); 2214 CONFIGFS_ATTR_RO(target_pr_, res_aptpl_active); 2215 CONFIGFS_ATTR(target_pr_, res_aptpl_metadata); 2216 2217 static struct configfs_attribute *target_core_dev_pr_attrs[] = { 2218 &target_pr_attr_res_holder, 2219 &target_pr_attr_res_pr_all_tgt_pts, 2220 &target_pr_attr_res_pr_generation, 2221 &target_pr_attr_res_pr_holder_tg_port, 2222 &target_pr_attr_res_pr_registered_i_pts, 2223 &target_pr_attr_res_pr_type, 2224 &target_pr_attr_res_type, 2225 &target_pr_attr_res_aptpl_active, 2226 &target_pr_attr_res_aptpl_metadata, 2227 NULL, 2228 }; 2229 2230 TB_CIT_SETUP(dev_pr, NULL, NULL, target_core_dev_pr_attrs); 2231 2232 /* End functions for struct config_item_type tb_dev_pr_cit */ 2233 2234 /* Start functions for struct config_item_type tb_dev_cit */ 2235 2236 static inline struct se_device *to_device(struct config_item *item) 2237 { 2238 return container_of(to_config_group(item), struct se_device, dev_group); 2239 } 2240 2241 static ssize_t target_dev_info_show(struct config_item *item, char *page) 2242 { 2243 struct se_device *dev = to_device(item); 2244 int bl = 0; 2245 ssize_t read_bytes = 0; 2246 2247 transport_dump_dev_state(dev, page, &bl); 2248 read_bytes += bl; 2249 read_bytes += dev->transport->show_configfs_dev_params(dev, 2250 page+read_bytes); 2251 return read_bytes; 2252 } 2253 2254 static ssize_t target_dev_control_store(struct config_item *item, 2255 const char *page, size_t count) 2256 { 2257 struct se_device *dev = to_device(item); 2258 2259 return dev->transport->set_configfs_dev_params(dev, page, count); 2260 } 2261 2262 static ssize_t target_dev_alias_show(struct config_item *item, char *page) 2263 { 2264 struct se_device *dev = to_device(item); 2265 2266 if (!(dev->dev_flags & DF_USING_ALIAS)) 2267 return 0; 2268 2269 return snprintf(page, PAGE_SIZE, "%s\n", dev->dev_alias); 2270 } 2271 2272 static ssize_t target_dev_alias_store(struct config_item *item, 2273 const char *page, size_t count) 2274 { 2275 struct se_device *dev = to_device(item); 2276 struct se_hba *hba = dev->se_hba; 2277 ssize_t read_bytes; 2278 2279 if (count > (SE_DEV_ALIAS_LEN-1)) { 2280 pr_err("alias count: %d exceeds" 2281 " SE_DEV_ALIAS_LEN-1: %u\n", (int)count, 2282 SE_DEV_ALIAS_LEN-1); 2283 return -EINVAL; 2284 } 2285 2286 read_bytes = snprintf(&dev->dev_alias[0], SE_DEV_ALIAS_LEN, "%s", page); 2287 if (!read_bytes) 2288 return -EINVAL; 2289 if (dev->dev_alias[read_bytes - 1] == '\n') 2290 dev->dev_alias[read_bytes - 1] = '\0'; 2291 2292 dev->dev_flags |= DF_USING_ALIAS; 2293 2294 pr_debug("Target_Core_ConfigFS: %s/%s set alias: %s\n", 2295 config_item_name(&hba->hba_group.cg_item), 2296 config_item_name(&dev->dev_group.cg_item), 2297 dev->dev_alias); 2298 2299 return read_bytes; 2300 } 2301 2302 static ssize_t target_dev_udev_path_show(struct config_item *item, char *page) 2303 { 2304 struct se_device *dev = to_device(item); 2305 2306 if (!(dev->dev_flags & DF_USING_UDEV_PATH)) 2307 return 0; 2308 2309 return snprintf(page, PAGE_SIZE, "%s\n", dev->udev_path); 2310 } 2311 2312 static ssize_t target_dev_udev_path_store(struct config_item *item, 2313 const char *page, size_t count) 2314 { 2315 struct se_device *dev = to_device(item); 2316 struct se_hba *hba = dev->se_hba; 2317 ssize_t read_bytes; 2318 2319 if (count > (SE_UDEV_PATH_LEN-1)) { 2320 pr_err("udev_path count: %d exceeds" 2321 " SE_UDEV_PATH_LEN-1: %u\n", (int)count, 2322 SE_UDEV_PATH_LEN-1); 2323 return -EINVAL; 2324 } 2325 2326 read_bytes = snprintf(&dev->udev_path[0], SE_UDEV_PATH_LEN, 2327 "%s", page); 2328 if (!read_bytes) 2329 return -EINVAL; 2330 if (dev->udev_path[read_bytes - 1] == '\n') 2331 dev->udev_path[read_bytes - 1] = '\0'; 2332 2333 dev->dev_flags |= DF_USING_UDEV_PATH; 2334 2335 pr_debug("Target_Core_ConfigFS: %s/%s set udev_path: %s\n", 2336 config_item_name(&hba->hba_group.cg_item), 2337 config_item_name(&dev->dev_group.cg_item), 2338 dev->udev_path); 2339 2340 return read_bytes; 2341 } 2342 2343 static ssize_t target_dev_enable_show(struct config_item *item, char *page) 2344 { 2345 struct se_device *dev = to_device(item); 2346 2347 return snprintf(page, PAGE_SIZE, "%d\n", target_dev_configured(dev)); 2348 } 2349 2350 static ssize_t target_dev_enable_store(struct config_item *item, 2351 const char *page, size_t count) 2352 { 2353 struct se_device *dev = to_device(item); 2354 char *ptr; 2355 int ret; 2356 2357 ptr = strstr(page, "1"); 2358 if (!ptr) { 2359 pr_err("For dev_enable ops, only valid value" 2360 " is \"1\"\n"); 2361 return -EINVAL; 2362 } 2363 2364 ret = target_configure_device(dev); 2365 if (ret) 2366 return ret; 2367 return count; 2368 } 2369 2370 static ssize_t target_dev_alua_lu_gp_show(struct config_item *item, char *page) 2371 { 2372 struct se_device *dev = to_device(item); 2373 struct config_item *lu_ci; 2374 struct t10_alua_lu_gp *lu_gp; 2375 struct t10_alua_lu_gp_member *lu_gp_mem; 2376 ssize_t len = 0; 2377 2378 lu_gp_mem = dev->dev_alua_lu_gp_mem; 2379 if (!lu_gp_mem) 2380 return 0; 2381 2382 spin_lock(&lu_gp_mem->lu_gp_mem_lock); 2383 lu_gp = lu_gp_mem->lu_gp; 2384 if (lu_gp) { 2385 lu_ci = &lu_gp->lu_gp_group.cg_item; 2386 len += sprintf(page, "LU Group Alias: %s\nLU Group ID: %hu\n", 2387 config_item_name(lu_ci), lu_gp->lu_gp_id); 2388 } 2389 spin_unlock(&lu_gp_mem->lu_gp_mem_lock); 2390 2391 return len; 2392 } 2393 2394 static ssize_t target_dev_alua_lu_gp_store(struct config_item *item, 2395 const char *page, size_t count) 2396 { 2397 struct se_device *dev = to_device(item); 2398 struct se_hba *hba = dev->se_hba; 2399 struct t10_alua_lu_gp *lu_gp = NULL, *lu_gp_new = NULL; 2400 struct t10_alua_lu_gp_member *lu_gp_mem; 2401 unsigned char buf[LU_GROUP_NAME_BUF] = { }; 2402 int move = 0; 2403 2404 lu_gp_mem = dev->dev_alua_lu_gp_mem; 2405 if (!lu_gp_mem) 2406 return count; 2407 2408 if (count > LU_GROUP_NAME_BUF) { 2409 pr_err("ALUA LU Group Alias too large!\n"); 2410 return -EINVAL; 2411 } 2412 memcpy(buf, page, count); 2413 /* 2414 * Any ALUA logical unit alias besides "NULL" means we will be 2415 * making a new group association. 2416 */ 2417 if (strcmp(strstrip(buf), "NULL")) { 2418 /* 2419 * core_alua_get_lu_gp_by_name() will increment reference to 2420 * struct t10_alua_lu_gp. This reference is released with 2421 * core_alua_get_lu_gp_by_name below(). 2422 */ 2423 lu_gp_new = core_alua_get_lu_gp_by_name(strstrip(buf)); 2424 if (!lu_gp_new) 2425 return -ENODEV; 2426 } 2427 2428 spin_lock(&lu_gp_mem->lu_gp_mem_lock); 2429 lu_gp = lu_gp_mem->lu_gp; 2430 if (lu_gp) { 2431 /* 2432 * Clearing an existing lu_gp association, and replacing 2433 * with NULL 2434 */ 2435 if (!lu_gp_new) { 2436 pr_debug("Target_Core_ConfigFS: Releasing %s/%s" 2437 " from ALUA LU Group: core/alua/lu_gps/%s, ID:" 2438 " %hu\n", 2439 config_item_name(&hba->hba_group.cg_item), 2440 config_item_name(&dev->dev_group.cg_item), 2441 config_item_name(&lu_gp->lu_gp_group.cg_item), 2442 lu_gp->lu_gp_id); 2443 2444 __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp); 2445 spin_unlock(&lu_gp_mem->lu_gp_mem_lock); 2446 2447 return count; 2448 } 2449 /* 2450 * Removing existing association of lu_gp_mem with lu_gp 2451 */ 2452 __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp); 2453 move = 1; 2454 } 2455 /* 2456 * Associate lu_gp_mem with lu_gp_new. 2457 */ 2458 __core_alua_attach_lu_gp_mem(lu_gp_mem, lu_gp_new); 2459 spin_unlock(&lu_gp_mem->lu_gp_mem_lock); 2460 2461 pr_debug("Target_Core_ConfigFS: %s %s/%s to ALUA LU Group:" 2462 " core/alua/lu_gps/%s, ID: %hu\n", 2463 (move) ? "Moving" : "Adding", 2464 config_item_name(&hba->hba_group.cg_item), 2465 config_item_name(&dev->dev_group.cg_item), 2466 config_item_name(&lu_gp_new->lu_gp_group.cg_item), 2467 lu_gp_new->lu_gp_id); 2468 2469 core_alua_put_lu_gp_from_name(lu_gp_new); 2470 return count; 2471 } 2472 2473 static ssize_t target_dev_lba_map_show(struct config_item *item, char *page) 2474 { 2475 struct se_device *dev = to_device(item); 2476 struct t10_alua_lba_map *map; 2477 struct t10_alua_lba_map_member *mem; 2478 char *b = page; 2479 int bl = 0; 2480 char state; 2481 2482 spin_lock(&dev->t10_alua.lba_map_lock); 2483 if (!list_empty(&dev->t10_alua.lba_map_list)) 2484 bl += sprintf(b + bl, "%u %u\n", 2485 dev->t10_alua.lba_map_segment_size, 2486 dev->t10_alua.lba_map_segment_multiplier); 2487 list_for_each_entry(map, &dev->t10_alua.lba_map_list, lba_map_list) { 2488 bl += sprintf(b + bl, "%llu %llu", 2489 map->lba_map_first_lba, map->lba_map_last_lba); 2490 list_for_each_entry(mem, &map->lba_map_mem_list, 2491 lba_map_mem_list) { 2492 switch (mem->lba_map_mem_alua_state) { 2493 case ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED: 2494 state = 'O'; 2495 break; 2496 case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED: 2497 state = 'A'; 2498 break; 2499 case ALUA_ACCESS_STATE_STANDBY: 2500 state = 'S'; 2501 break; 2502 case ALUA_ACCESS_STATE_UNAVAILABLE: 2503 state = 'U'; 2504 break; 2505 default: 2506 state = '.'; 2507 break; 2508 } 2509 bl += sprintf(b + bl, " %d:%c", 2510 mem->lba_map_mem_alua_pg_id, state); 2511 } 2512 bl += sprintf(b + bl, "\n"); 2513 } 2514 spin_unlock(&dev->t10_alua.lba_map_lock); 2515 return bl; 2516 } 2517 2518 static ssize_t target_dev_lba_map_store(struct config_item *item, 2519 const char *page, size_t count) 2520 { 2521 struct se_device *dev = to_device(item); 2522 struct t10_alua_lba_map *lba_map = NULL; 2523 struct list_head lba_list; 2524 char *map_entries, *orig, *ptr; 2525 char state; 2526 int pg_num = -1, pg; 2527 int ret = 0, num = 0, pg_id, alua_state; 2528 unsigned long start_lba = -1, end_lba = -1; 2529 unsigned long segment_size = -1, segment_mult = -1; 2530 2531 orig = map_entries = kstrdup(page, GFP_KERNEL); 2532 if (!map_entries) 2533 return -ENOMEM; 2534 2535 INIT_LIST_HEAD(&lba_list); 2536 while ((ptr = strsep(&map_entries, "\n")) != NULL) { 2537 if (!*ptr) 2538 continue; 2539 2540 if (num == 0) { 2541 if (sscanf(ptr, "%lu %lu\n", 2542 &segment_size, &segment_mult) != 2) { 2543 pr_err("Invalid line %d\n", num); 2544 ret = -EINVAL; 2545 break; 2546 } 2547 num++; 2548 continue; 2549 } 2550 if (sscanf(ptr, "%lu %lu", &start_lba, &end_lba) != 2) { 2551 pr_err("Invalid line %d\n", num); 2552 ret = -EINVAL; 2553 break; 2554 } 2555 ptr = strchr(ptr, ' '); 2556 if (!ptr) { 2557 pr_err("Invalid line %d, missing end lba\n", num); 2558 ret = -EINVAL; 2559 break; 2560 } 2561 ptr++; 2562 ptr = strchr(ptr, ' '); 2563 if (!ptr) { 2564 pr_err("Invalid line %d, missing state definitions\n", 2565 num); 2566 ret = -EINVAL; 2567 break; 2568 } 2569 ptr++; 2570 lba_map = core_alua_allocate_lba_map(&lba_list, 2571 start_lba, end_lba); 2572 if (IS_ERR(lba_map)) { 2573 ret = PTR_ERR(lba_map); 2574 break; 2575 } 2576 pg = 0; 2577 while (sscanf(ptr, "%d:%c", &pg_id, &state) == 2) { 2578 switch (state) { 2579 case 'O': 2580 alua_state = ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED; 2581 break; 2582 case 'A': 2583 alua_state = ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED; 2584 break; 2585 case 'S': 2586 alua_state = ALUA_ACCESS_STATE_STANDBY; 2587 break; 2588 case 'U': 2589 alua_state = ALUA_ACCESS_STATE_UNAVAILABLE; 2590 break; 2591 default: 2592 pr_err("Invalid ALUA state '%c'\n", state); 2593 ret = -EINVAL; 2594 goto out; 2595 } 2596 2597 ret = core_alua_allocate_lba_map_mem(lba_map, 2598 pg_id, alua_state); 2599 if (ret) { 2600 pr_err("Invalid target descriptor %d:%c " 2601 "at line %d\n", 2602 pg_id, state, num); 2603 break; 2604 } 2605 pg++; 2606 ptr = strchr(ptr, ' '); 2607 if (ptr) 2608 ptr++; 2609 else 2610 break; 2611 } 2612 if (pg_num == -1) 2613 pg_num = pg; 2614 else if (pg != pg_num) { 2615 pr_err("Only %d from %d port groups definitions " 2616 "at line %d\n", pg, pg_num, num); 2617 ret = -EINVAL; 2618 break; 2619 } 2620 num++; 2621 } 2622 out: 2623 if (ret) { 2624 core_alua_free_lba_map(&lba_list); 2625 count = ret; 2626 } else 2627 core_alua_set_lba_map(dev, &lba_list, 2628 segment_size, segment_mult); 2629 kfree(orig); 2630 return count; 2631 } 2632 2633 CONFIGFS_ATTR_RO(target_dev_, info); 2634 CONFIGFS_ATTR_WO(target_dev_, control); 2635 CONFIGFS_ATTR(target_dev_, alias); 2636 CONFIGFS_ATTR(target_dev_, udev_path); 2637 CONFIGFS_ATTR(target_dev_, enable); 2638 CONFIGFS_ATTR(target_dev_, alua_lu_gp); 2639 CONFIGFS_ATTR(target_dev_, lba_map); 2640 2641 static struct configfs_attribute *target_core_dev_attrs[] = { 2642 &target_dev_attr_info, 2643 &target_dev_attr_control, 2644 &target_dev_attr_alias, 2645 &target_dev_attr_udev_path, 2646 &target_dev_attr_enable, 2647 &target_dev_attr_alua_lu_gp, 2648 &target_dev_attr_lba_map, 2649 NULL, 2650 }; 2651 2652 static void target_core_dev_release(struct config_item *item) 2653 { 2654 struct config_group *dev_cg = to_config_group(item); 2655 struct se_device *dev = 2656 container_of(dev_cg, struct se_device, dev_group); 2657 2658 target_free_device(dev); 2659 } 2660 2661 /* 2662 * Used in target_core_fabric_configfs.c to verify valid se_device symlink 2663 * within target_fabric_port_link() 2664 */ 2665 struct configfs_item_operations target_core_dev_item_ops = { 2666 .release = target_core_dev_release, 2667 }; 2668 2669 TB_CIT_SETUP(dev, &target_core_dev_item_ops, NULL, target_core_dev_attrs); 2670 2671 /* End functions for struct config_item_type tb_dev_cit */ 2672 2673 /* Start functions for struct config_item_type target_core_alua_lu_gp_cit */ 2674 2675 static inline struct t10_alua_lu_gp *to_lu_gp(struct config_item *item) 2676 { 2677 return container_of(to_config_group(item), struct t10_alua_lu_gp, 2678 lu_gp_group); 2679 } 2680 2681 static ssize_t target_lu_gp_lu_gp_id_show(struct config_item *item, char *page) 2682 { 2683 struct t10_alua_lu_gp *lu_gp = to_lu_gp(item); 2684 2685 if (!lu_gp->lu_gp_valid_id) 2686 return 0; 2687 return sprintf(page, "%hu\n", lu_gp->lu_gp_id); 2688 } 2689 2690 static ssize_t target_lu_gp_lu_gp_id_store(struct config_item *item, 2691 const char *page, size_t count) 2692 { 2693 struct t10_alua_lu_gp *lu_gp = to_lu_gp(item); 2694 struct config_group *alua_lu_gp_cg = &lu_gp->lu_gp_group; 2695 unsigned long lu_gp_id; 2696 int ret; 2697 2698 ret = kstrtoul(page, 0, &lu_gp_id); 2699 if (ret < 0) { 2700 pr_err("kstrtoul() returned %d for" 2701 " lu_gp_id\n", ret); 2702 return ret; 2703 } 2704 if (lu_gp_id > 0x0000ffff) { 2705 pr_err("ALUA lu_gp_id: %lu exceeds maximum:" 2706 " 0x0000ffff\n", lu_gp_id); 2707 return -EINVAL; 2708 } 2709 2710 ret = core_alua_set_lu_gp_id(lu_gp, (u16)lu_gp_id); 2711 if (ret < 0) 2712 return -EINVAL; 2713 2714 pr_debug("Target_Core_ConfigFS: Set ALUA Logical Unit" 2715 " Group: core/alua/lu_gps/%s to ID: %hu\n", 2716 config_item_name(&alua_lu_gp_cg->cg_item), 2717 lu_gp->lu_gp_id); 2718 2719 return count; 2720 } 2721 2722 static ssize_t target_lu_gp_members_show(struct config_item *item, char *page) 2723 { 2724 struct t10_alua_lu_gp *lu_gp = to_lu_gp(item); 2725 struct se_device *dev; 2726 struct se_hba *hba; 2727 struct t10_alua_lu_gp_member *lu_gp_mem; 2728 ssize_t len = 0, cur_len; 2729 unsigned char buf[LU_GROUP_NAME_BUF] = { }; 2730 2731 spin_lock(&lu_gp->lu_gp_lock); 2732 list_for_each_entry(lu_gp_mem, &lu_gp->lu_gp_mem_list, lu_gp_mem_list) { 2733 dev = lu_gp_mem->lu_gp_mem_dev; 2734 hba = dev->se_hba; 2735 2736 cur_len = snprintf(buf, LU_GROUP_NAME_BUF, "%s/%s\n", 2737 config_item_name(&hba->hba_group.cg_item), 2738 config_item_name(&dev->dev_group.cg_item)); 2739 cur_len++; /* Extra byte for NULL terminator */ 2740 2741 if ((cur_len + len) > PAGE_SIZE) { 2742 pr_warn("Ran out of lu_gp_show_attr" 2743 "_members buffer\n"); 2744 break; 2745 } 2746 memcpy(page+len, buf, cur_len); 2747 len += cur_len; 2748 } 2749 spin_unlock(&lu_gp->lu_gp_lock); 2750 2751 return len; 2752 } 2753 2754 CONFIGFS_ATTR(target_lu_gp_, lu_gp_id); 2755 CONFIGFS_ATTR_RO(target_lu_gp_, members); 2756 2757 static struct configfs_attribute *target_core_alua_lu_gp_attrs[] = { 2758 &target_lu_gp_attr_lu_gp_id, 2759 &target_lu_gp_attr_members, 2760 NULL, 2761 }; 2762 2763 static void target_core_alua_lu_gp_release(struct config_item *item) 2764 { 2765 struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item), 2766 struct t10_alua_lu_gp, lu_gp_group); 2767 2768 core_alua_free_lu_gp(lu_gp); 2769 } 2770 2771 static struct configfs_item_operations target_core_alua_lu_gp_ops = { 2772 .release = target_core_alua_lu_gp_release, 2773 }; 2774 2775 static const struct config_item_type target_core_alua_lu_gp_cit = { 2776 .ct_item_ops = &target_core_alua_lu_gp_ops, 2777 .ct_attrs = target_core_alua_lu_gp_attrs, 2778 .ct_owner = THIS_MODULE, 2779 }; 2780 2781 /* End functions for struct config_item_type target_core_alua_lu_gp_cit */ 2782 2783 /* Start functions for struct config_item_type target_core_alua_lu_gps_cit */ 2784 2785 static struct config_group *target_core_alua_create_lu_gp( 2786 struct config_group *group, 2787 const char *name) 2788 { 2789 struct t10_alua_lu_gp *lu_gp; 2790 struct config_group *alua_lu_gp_cg = NULL; 2791 struct config_item *alua_lu_gp_ci = NULL; 2792 2793 lu_gp = core_alua_allocate_lu_gp(name, 0); 2794 if (IS_ERR(lu_gp)) 2795 return NULL; 2796 2797 alua_lu_gp_cg = &lu_gp->lu_gp_group; 2798 alua_lu_gp_ci = &alua_lu_gp_cg->cg_item; 2799 2800 config_group_init_type_name(alua_lu_gp_cg, name, 2801 &target_core_alua_lu_gp_cit); 2802 2803 pr_debug("Target_Core_ConfigFS: Allocated ALUA Logical Unit" 2804 " Group: core/alua/lu_gps/%s\n", 2805 config_item_name(alua_lu_gp_ci)); 2806 2807 return alua_lu_gp_cg; 2808 2809 } 2810 2811 static void target_core_alua_drop_lu_gp( 2812 struct config_group *group, 2813 struct config_item *item) 2814 { 2815 struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item), 2816 struct t10_alua_lu_gp, lu_gp_group); 2817 2818 pr_debug("Target_Core_ConfigFS: Releasing ALUA Logical Unit" 2819 " Group: core/alua/lu_gps/%s, ID: %hu\n", 2820 config_item_name(item), lu_gp->lu_gp_id); 2821 /* 2822 * core_alua_free_lu_gp() is called from target_core_alua_lu_gp_ops->release() 2823 * -> target_core_alua_lu_gp_release() 2824 */ 2825 config_item_put(item); 2826 } 2827 2828 static struct configfs_group_operations target_core_alua_lu_gps_group_ops = { 2829 .make_group = &target_core_alua_create_lu_gp, 2830 .drop_item = &target_core_alua_drop_lu_gp, 2831 }; 2832 2833 static const struct config_item_type target_core_alua_lu_gps_cit = { 2834 .ct_item_ops = NULL, 2835 .ct_group_ops = &target_core_alua_lu_gps_group_ops, 2836 .ct_owner = THIS_MODULE, 2837 }; 2838 2839 /* End functions for struct config_item_type target_core_alua_lu_gps_cit */ 2840 2841 /* Start functions for struct config_item_type target_core_alua_tg_pt_gp_cit */ 2842 2843 static inline struct t10_alua_tg_pt_gp *to_tg_pt_gp(struct config_item *item) 2844 { 2845 return container_of(to_config_group(item), struct t10_alua_tg_pt_gp, 2846 tg_pt_gp_group); 2847 } 2848 2849 static ssize_t target_tg_pt_gp_alua_access_state_show(struct config_item *item, 2850 char *page) 2851 { 2852 return sprintf(page, "%d\n", 2853 to_tg_pt_gp(item)->tg_pt_gp_alua_access_state); 2854 } 2855 2856 static ssize_t target_tg_pt_gp_alua_access_state_store(struct config_item *item, 2857 const char *page, size_t count) 2858 { 2859 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); 2860 struct se_device *dev = tg_pt_gp->tg_pt_gp_dev; 2861 unsigned long tmp; 2862 int new_state, ret; 2863 2864 if (!tg_pt_gp->tg_pt_gp_valid_id) { 2865 pr_err("Unable to do implicit ALUA on invalid tg_pt_gp ID\n"); 2866 return -EINVAL; 2867 } 2868 if (!target_dev_configured(dev)) { 2869 pr_err("Unable to set alua_access_state while device is" 2870 " not configured\n"); 2871 return -ENODEV; 2872 } 2873 2874 ret = kstrtoul(page, 0, &tmp); 2875 if (ret < 0) { 2876 pr_err("Unable to extract new ALUA access state from" 2877 " %s\n", page); 2878 return ret; 2879 } 2880 new_state = (int)tmp; 2881 2882 if (!(tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_IMPLICIT_ALUA)) { 2883 pr_err("Unable to process implicit configfs ALUA" 2884 " transition while TPGS_IMPLICIT_ALUA is disabled\n"); 2885 return -EINVAL; 2886 } 2887 if (tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA && 2888 new_state == ALUA_ACCESS_STATE_LBA_DEPENDENT) { 2889 /* LBA DEPENDENT is only allowed with implicit ALUA */ 2890 pr_err("Unable to process implicit configfs ALUA transition" 2891 " while explicit ALUA management is enabled\n"); 2892 return -EINVAL; 2893 } 2894 2895 ret = core_alua_do_port_transition(tg_pt_gp, dev, 2896 NULL, NULL, new_state, 0); 2897 return (!ret) ? count : -EINVAL; 2898 } 2899 2900 static ssize_t target_tg_pt_gp_alua_access_status_show(struct config_item *item, 2901 char *page) 2902 { 2903 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); 2904 return sprintf(page, "%s\n", 2905 core_alua_dump_status(tg_pt_gp->tg_pt_gp_alua_access_status)); 2906 } 2907 2908 static ssize_t target_tg_pt_gp_alua_access_status_store( 2909 struct config_item *item, const char *page, size_t count) 2910 { 2911 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); 2912 unsigned long tmp; 2913 int new_status, ret; 2914 2915 if (!tg_pt_gp->tg_pt_gp_valid_id) { 2916 pr_err("Unable to set ALUA access status on invalid tg_pt_gp ID\n"); 2917 return -EINVAL; 2918 } 2919 2920 ret = kstrtoul(page, 0, &tmp); 2921 if (ret < 0) { 2922 pr_err("Unable to extract new ALUA access status" 2923 " from %s\n", page); 2924 return ret; 2925 } 2926 new_status = (int)tmp; 2927 2928 if ((new_status != ALUA_STATUS_NONE) && 2929 (new_status != ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG) && 2930 (new_status != ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA)) { 2931 pr_err("Illegal ALUA access status: 0x%02x\n", 2932 new_status); 2933 return -EINVAL; 2934 } 2935 2936 tg_pt_gp->tg_pt_gp_alua_access_status = new_status; 2937 return count; 2938 } 2939 2940 static ssize_t target_tg_pt_gp_alua_access_type_show(struct config_item *item, 2941 char *page) 2942 { 2943 return core_alua_show_access_type(to_tg_pt_gp(item), page); 2944 } 2945 2946 static ssize_t target_tg_pt_gp_alua_access_type_store(struct config_item *item, 2947 const char *page, size_t count) 2948 { 2949 return core_alua_store_access_type(to_tg_pt_gp(item), page, count); 2950 } 2951 2952 #define ALUA_SUPPORTED_STATE_ATTR(_name, _bit) \ 2953 static ssize_t target_tg_pt_gp_alua_support_##_name##_show( \ 2954 struct config_item *item, char *p) \ 2955 { \ 2956 struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item); \ 2957 return sprintf(p, "%d\n", \ 2958 !!(t->tg_pt_gp_alua_supported_states & _bit)); \ 2959 } \ 2960 \ 2961 static ssize_t target_tg_pt_gp_alua_support_##_name##_store( \ 2962 struct config_item *item, const char *p, size_t c) \ 2963 { \ 2964 struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item); \ 2965 unsigned long tmp; \ 2966 int ret; \ 2967 \ 2968 if (!t->tg_pt_gp_valid_id) { \ 2969 pr_err("Unable to set " #_name " ALUA state on invalid tg_pt_gp ID\n"); \ 2970 return -EINVAL; \ 2971 } \ 2972 \ 2973 ret = kstrtoul(p, 0, &tmp); \ 2974 if (ret < 0) { \ 2975 pr_err("Invalid value '%s', must be '0' or '1'\n", p); \ 2976 return -EINVAL; \ 2977 } \ 2978 if (tmp > 1) { \ 2979 pr_err("Invalid value '%ld', must be '0' or '1'\n", tmp); \ 2980 return -EINVAL; \ 2981 } \ 2982 if (tmp) \ 2983 t->tg_pt_gp_alua_supported_states |= _bit; \ 2984 else \ 2985 t->tg_pt_gp_alua_supported_states &= ~_bit; \ 2986 \ 2987 return c; \ 2988 } 2989 2990 ALUA_SUPPORTED_STATE_ATTR(transitioning, ALUA_T_SUP); 2991 ALUA_SUPPORTED_STATE_ATTR(offline, ALUA_O_SUP); 2992 ALUA_SUPPORTED_STATE_ATTR(lba_dependent, ALUA_LBD_SUP); 2993 ALUA_SUPPORTED_STATE_ATTR(unavailable, ALUA_U_SUP); 2994 ALUA_SUPPORTED_STATE_ATTR(standby, ALUA_S_SUP); 2995 ALUA_SUPPORTED_STATE_ATTR(active_optimized, ALUA_AO_SUP); 2996 ALUA_SUPPORTED_STATE_ATTR(active_nonoptimized, ALUA_AN_SUP); 2997 2998 static ssize_t target_tg_pt_gp_alua_write_metadata_show( 2999 struct config_item *item, char *page) 3000 { 3001 return sprintf(page, "%d\n", 3002 to_tg_pt_gp(item)->tg_pt_gp_write_metadata); 3003 } 3004 3005 static ssize_t target_tg_pt_gp_alua_write_metadata_store( 3006 struct config_item *item, const char *page, size_t count) 3007 { 3008 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); 3009 unsigned long tmp; 3010 int ret; 3011 3012 ret = kstrtoul(page, 0, &tmp); 3013 if (ret < 0) { 3014 pr_err("Unable to extract alua_write_metadata\n"); 3015 return ret; 3016 } 3017 3018 if ((tmp != 0) && (tmp != 1)) { 3019 pr_err("Illegal value for alua_write_metadata:" 3020 " %lu\n", tmp); 3021 return -EINVAL; 3022 } 3023 tg_pt_gp->tg_pt_gp_write_metadata = (int)tmp; 3024 3025 return count; 3026 } 3027 3028 static ssize_t target_tg_pt_gp_nonop_delay_msecs_show(struct config_item *item, 3029 char *page) 3030 { 3031 return core_alua_show_nonop_delay_msecs(to_tg_pt_gp(item), page); 3032 } 3033 3034 static ssize_t target_tg_pt_gp_nonop_delay_msecs_store(struct config_item *item, 3035 const char *page, size_t count) 3036 { 3037 return core_alua_store_nonop_delay_msecs(to_tg_pt_gp(item), page, 3038 count); 3039 } 3040 3041 static ssize_t target_tg_pt_gp_trans_delay_msecs_show(struct config_item *item, 3042 char *page) 3043 { 3044 return core_alua_show_trans_delay_msecs(to_tg_pt_gp(item), page); 3045 } 3046 3047 static ssize_t target_tg_pt_gp_trans_delay_msecs_store(struct config_item *item, 3048 const char *page, size_t count) 3049 { 3050 return core_alua_store_trans_delay_msecs(to_tg_pt_gp(item), page, 3051 count); 3052 } 3053 3054 static ssize_t target_tg_pt_gp_implicit_trans_secs_show( 3055 struct config_item *item, char *page) 3056 { 3057 return core_alua_show_implicit_trans_secs(to_tg_pt_gp(item), page); 3058 } 3059 3060 static ssize_t target_tg_pt_gp_implicit_trans_secs_store( 3061 struct config_item *item, const char *page, size_t count) 3062 { 3063 return core_alua_store_implicit_trans_secs(to_tg_pt_gp(item), page, 3064 count); 3065 } 3066 3067 static ssize_t target_tg_pt_gp_preferred_show(struct config_item *item, 3068 char *page) 3069 { 3070 return core_alua_show_preferred_bit(to_tg_pt_gp(item), page); 3071 } 3072 3073 static ssize_t target_tg_pt_gp_preferred_store(struct config_item *item, 3074 const char *page, size_t count) 3075 { 3076 return core_alua_store_preferred_bit(to_tg_pt_gp(item), page, count); 3077 } 3078 3079 static ssize_t target_tg_pt_gp_tg_pt_gp_id_show(struct config_item *item, 3080 char *page) 3081 { 3082 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); 3083 3084 if (!tg_pt_gp->tg_pt_gp_valid_id) 3085 return 0; 3086 return sprintf(page, "%hu\n", tg_pt_gp->tg_pt_gp_id); 3087 } 3088 3089 static ssize_t target_tg_pt_gp_tg_pt_gp_id_store(struct config_item *item, 3090 const char *page, size_t count) 3091 { 3092 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); 3093 struct config_group *alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group; 3094 unsigned long tg_pt_gp_id; 3095 int ret; 3096 3097 ret = kstrtoul(page, 0, &tg_pt_gp_id); 3098 if (ret < 0) { 3099 pr_err("ALUA tg_pt_gp_id: invalid value '%s' for tg_pt_gp_id\n", 3100 page); 3101 return ret; 3102 } 3103 if (tg_pt_gp_id > 0x0000ffff) { 3104 pr_err("ALUA tg_pt_gp_id: %lu exceeds maximum: 0x0000ffff\n", 3105 tg_pt_gp_id); 3106 return -EINVAL; 3107 } 3108 3109 ret = core_alua_set_tg_pt_gp_id(tg_pt_gp, (u16)tg_pt_gp_id); 3110 if (ret < 0) 3111 return -EINVAL; 3112 3113 pr_debug("Target_Core_ConfigFS: Set ALUA Target Port Group: " 3114 "core/alua/tg_pt_gps/%s to ID: %hu\n", 3115 config_item_name(&alua_tg_pt_gp_cg->cg_item), 3116 tg_pt_gp->tg_pt_gp_id); 3117 3118 return count; 3119 } 3120 3121 static ssize_t target_tg_pt_gp_members_show(struct config_item *item, 3122 char *page) 3123 { 3124 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item); 3125 struct se_lun *lun; 3126 ssize_t len = 0, cur_len; 3127 unsigned char buf[TG_PT_GROUP_NAME_BUF] = { }; 3128 3129 spin_lock(&tg_pt_gp->tg_pt_gp_lock); 3130 list_for_each_entry(lun, &tg_pt_gp->tg_pt_gp_lun_list, 3131 lun_tg_pt_gp_link) { 3132 struct se_portal_group *tpg = lun->lun_tpg; 3133 3134 cur_len = snprintf(buf, TG_PT_GROUP_NAME_BUF, "%s/%s/tpgt_%hu" 3135 "/%s\n", tpg->se_tpg_tfo->fabric_name, 3136 tpg->se_tpg_tfo->tpg_get_wwn(tpg), 3137 tpg->se_tpg_tfo->tpg_get_tag(tpg), 3138 config_item_name(&lun->lun_group.cg_item)); 3139 cur_len++; /* Extra byte for NULL terminator */ 3140 3141 if ((cur_len + len) > PAGE_SIZE) { 3142 pr_warn("Ran out of lu_gp_show_attr" 3143 "_members buffer\n"); 3144 break; 3145 } 3146 memcpy(page+len, buf, cur_len); 3147 len += cur_len; 3148 } 3149 spin_unlock(&tg_pt_gp->tg_pt_gp_lock); 3150 3151 return len; 3152 } 3153 3154 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_state); 3155 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_status); 3156 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_type); 3157 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_transitioning); 3158 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_offline); 3159 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_lba_dependent); 3160 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_unavailable); 3161 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_standby); 3162 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_optimized); 3163 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_nonoptimized); 3164 CONFIGFS_ATTR(target_tg_pt_gp_, alua_write_metadata); 3165 CONFIGFS_ATTR(target_tg_pt_gp_, nonop_delay_msecs); 3166 CONFIGFS_ATTR(target_tg_pt_gp_, trans_delay_msecs); 3167 CONFIGFS_ATTR(target_tg_pt_gp_, implicit_trans_secs); 3168 CONFIGFS_ATTR(target_tg_pt_gp_, preferred); 3169 CONFIGFS_ATTR(target_tg_pt_gp_, tg_pt_gp_id); 3170 CONFIGFS_ATTR_RO(target_tg_pt_gp_, members); 3171 3172 static struct configfs_attribute *target_core_alua_tg_pt_gp_attrs[] = { 3173 &target_tg_pt_gp_attr_alua_access_state, 3174 &target_tg_pt_gp_attr_alua_access_status, 3175 &target_tg_pt_gp_attr_alua_access_type, 3176 &target_tg_pt_gp_attr_alua_support_transitioning, 3177 &target_tg_pt_gp_attr_alua_support_offline, 3178 &target_tg_pt_gp_attr_alua_support_lba_dependent, 3179 &target_tg_pt_gp_attr_alua_support_unavailable, 3180 &target_tg_pt_gp_attr_alua_support_standby, 3181 &target_tg_pt_gp_attr_alua_support_active_nonoptimized, 3182 &target_tg_pt_gp_attr_alua_support_active_optimized, 3183 &target_tg_pt_gp_attr_alua_write_metadata, 3184 &target_tg_pt_gp_attr_nonop_delay_msecs, 3185 &target_tg_pt_gp_attr_trans_delay_msecs, 3186 &target_tg_pt_gp_attr_implicit_trans_secs, 3187 &target_tg_pt_gp_attr_preferred, 3188 &target_tg_pt_gp_attr_tg_pt_gp_id, 3189 &target_tg_pt_gp_attr_members, 3190 NULL, 3191 }; 3192 3193 static void target_core_alua_tg_pt_gp_release(struct config_item *item) 3194 { 3195 struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item), 3196 struct t10_alua_tg_pt_gp, tg_pt_gp_group); 3197 3198 core_alua_free_tg_pt_gp(tg_pt_gp); 3199 } 3200 3201 static struct configfs_item_operations target_core_alua_tg_pt_gp_ops = { 3202 .release = target_core_alua_tg_pt_gp_release, 3203 }; 3204 3205 static const struct config_item_type target_core_alua_tg_pt_gp_cit = { 3206 .ct_item_ops = &target_core_alua_tg_pt_gp_ops, 3207 .ct_attrs = target_core_alua_tg_pt_gp_attrs, 3208 .ct_owner = THIS_MODULE, 3209 }; 3210 3211 /* End functions for struct config_item_type target_core_alua_tg_pt_gp_cit */ 3212 3213 /* Start functions for struct config_item_type tb_alua_tg_pt_gps_cit */ 3214 3215 static struct config_group *target_core_alua_create_tg_pt_gp( 3216 struct config_group *group, 3217 const char *name) 3218 { 3219 struct t10_alua *alua = container_of(group, struct t10_alua, 3220 alua_tg_pt_gps_group); 3221 struct t10_alua_tg_pt_gp *tg_pt_gp; 3222 struct config_group *alua_tg_pt_gp_cg = NULL; 3223 struct config_item *alua_tg_pt_gp_ci = NULL; 3224 3225 tg_pt_gp = core_alua_allocate_tg_pt_gp(alua->t10_dev, name, 0); 3226 if (!tg_pt_gp) 3227 return NULL; 3228 3229 alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group; 3230 alua_tg_pt_gp_ci = &alua_tg_pt_gp_cg->cg_item; 3231 3232 config_group_init_type_name(alua_tg_pt_gp_cg, name, 3233 &target_core_alua_tg_pt_gp_cit); 3234 3235 pr_debug("Target_Core_ConfigFS: Allocated ALUA Target Port" 3236 " Group: alua/tg_pt_gps/%s\n", 3237 config_item_name(alua_tg_pt_gp_ci)); 3238 3239 return alua_tg_pt_gp_cg; 3240 } 3241 3242 static void target_core_alua_drop_tg_pt_gp( 3243 struct config_group *group, 3244 struct config_item *item) 3245 { 3246 struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item), 3247 struct t10_alua_tg_pt_gp, tg_pt_gp_group); 3248 3249 pr_debug("Target_Core_ConfigFS: Releasing ALUA Target Port" 3250 " Group: alua/tg_pt_gps/%s, ID: %hu\n", 3251 config_item_name(item), tg_pt_gp->tg_pt_gp_id); 3252 /* 3253 * core_alua_free_tg_pt_gp() is called from target_core_alua_tg_pt_gp_ops->release() 3254 * -> target_core_alua_tg_pt_gp_release(). 3255 */ 3256 config_item_put(item); 3257 } 3258 3259 static struct configfs_group_operations target_core_alua_tg_pt_gps_group_ops = { 3260 .make_group = &target_core_alua_create_tg_pt_gp, 3261 .drop_item = &target_core_alua_drop_tg_pt_gp, 3262 }; 3263 3264 TB_CIT_SETUP(dev_alua_tg_pt_gps, NULL, &target_core_alua_tg_pt_gps_group_ops, NULL); 3265 3266 /* End functions for struct config_item_type tb_alua_tg_pt_gps_cit */ 3267 3268 /* Start functions for struct config_item_type target_core_alua_cit */ 3269 3270 /* 3271 * target_core_alua_cit is a ConfigFS group that lives under 3272 * /sys/kernel/config/target/core/alua. There are default groups 3273 * core/alua/lu_gps and core/alua/tg_pt_gps that are attached to 3274 * target_core_alua_cit in target_core_init_configfs() below. 3275 */ 3276 static const struct config_item_type target_core_alua_cit = { 3277 .ct_item_ops = NULL, 3278 .ct_attrs = NULL, 3279 .ct_owner = THIS_MODULE, 3280 }; 3281 3282 /* End functions for struct config_item_type target_core_alua_cit */ 3283 3284 /* Start functions for struct config_item_type tb_dev_stat_cit */ 3285 3286 static struct config_group *target_core_stat_mkdir( 3287 struct config_group *group, 3288 const char *name) 3289 { 3290 return ERR_PTR(-ENOSYS); 3291 } 3292 3293 static void target_core_stat_rmdir( 3294 struct config_group *group, 3295 struct config_item *item) 3296 { 3297 return; 3298 } 3299 3300 static struct configfs_group_operations target_core_stat_group_ops = { 3301 .make_group = &target_core_stat_mkdir, 3302 .drop_item = &target_core_stat_rmdir, 3303 }; 3304 3305 TB_CIT_SETUP(dev_stat, NULL, &target_core_stat_group_ops, NULL); 3306 3307 /* End functions for struct config_item_type tb_dev_stat_cit */ 3308 3309 /* Start functions for struct config_item_type target_core_hba_cit */ 3310 3311 static struct config_group *target_core_make_subdev( 3312 struct config_group *group, 3313 const char *name) 3314 { 3315 struct t10_alua_tg_pt_gp *tg_pt_gp; 3316 struct config_item *hba_ci = &group->cg_item; 3317 struct se_hba *hba = item_to_hba(hba_ci); 3318 struct target_backend *tb = hba->backend; 3319 struct se_device *dev; 3320 int errno = -ENOMEM, ret; 3321 3322 ret = mutex_lock_interruptible(&hba->hba_access_mutex); 3323 if (ret) 3324 return ERR_PTR(ret); 3325 3326 dev = target_alloc_device(hba, name); 3327 if (!dev) 3328 goto out_unlock; 3329 3330 config_group_init_type_name(&dev->dev_group, name, &tb->tb_dev_cit); 3331 3332 config_group_init_type_name(&dev->dev_action_group, "action", 3333 &tb->tb_dev_action_cit); 3334 configfs_add_default_group(&dev->dev_action_group, &dev->dev_group); 3335 3336 config_group_init_type_name(&dev->dev_attrib.da_group, "attrib", 3337 &tb->tb_dev_attrib_cit); 3338 configfs_add_default_group(&dev->dev_attrib.da_group, &dev->dev_group); 3339 3340 config_group_init_type_name(&dev->dev_pr_group, "pr", 3341 &tb->tb_dev_pr_cit); 3342 configfs_add_default_group(&dev->dev_pr_group, &dev->dev_group); 3343 3344 config_group_init_type_name(&dev->t10_wwn.t10_wwn_group, "wwn", 3345 &tb->tb_dev_wwn_cit); 3346 configfs_add_default_group(&dev->t10_wwn.t10_wwn_group, 3347 &dev->dev_group); 3348 3349 config_group_init_type_name(&dev->t10_alua.alua_tg_pt_gps_group, 3350 "alua", &tb->tb_dev_alua_tg_pt_gps_cit); 3351 configfs_add_default_group(&dev->t10_alua.alua_tg_pt_gps_group, 3352 &dev->dev_group); 3353 3354 config_group_init_type_name(&dev->dev_stat_grps.stat_group, 3355 "statistics", &tb->tb_dev_stat_cit); 3356 configfs_add_default_group(&dev->dev_stat_grps.stat_group, 3357 &dev->dev_group); 3358 3359 /* 3360 * Add core/$HBA/$DEV/alua/default_tg_pt_gp 3361 */ 3362 tg_pt_gp = core_alua_allocate_tg_pt_gp(dev, "default_tg_pt_gp", 1); 3363 if (!tg_pt_gp) 3364 goto out_free_device; 3365 dev->t10_alua.default_tg_pt_gp = tg_pt_gp; 3366 3367 config_group_init_type_name(&tg_pt_gp->tg_pt_gp_group, 3368 "default_tg_pt_gp", &target_core_alua_tg_pt_gp_cit); 3369 configfs_add_default_group(&tg_pt_gp->tg_pt_gp_group, 3370 &dev->t10_alua.alua_tg_pt_gps_group); 3371 3372 /* 3373 * Add core/$HBA/$DEV/statistics/ default groups 3374 */ 3375 target_stat_setup_dev_default_groups(dev); 3376 3377 mutex_lock(&target_devices_lock); 3378 target_devices++; 3379 mutex_unlock(&target_devices_lock); 3380 3381 mutex_unlock(&hba->hba_access_mutex); 3382 return &dev->dev_group; 3383 3384 out_free_device: 3385 target_free_device(dev); 3386 out_unlock: 3387 mutex_unlock(&hba->hba_access_mutex); 3388 return ERR_PTR(errno); 3389 } 3390 3391 static void target_core_drop_subdev( 3392 struct config_group *group, 3393 struct config_item *item) 3394 { 3395 struct config_group *dev_cg = to_config_group(item); 3396 struct se_device *dev = 3397 container_of(dev_cg, struct se_device, dev_group); 3398 struct se_hba *hba; 3399 3400 hba = item_to_hba(&dev->se_hba->hba_group.cg_item); 3401 3402 mutex_lock(&hba->hba_access_mutex); 3403 3404 configfs_remove_default_groups(&dev->dev_stat_grps.stat_group); 3405 configfs_remove_default_groups(&dev->t10_alua.alua_tg_pt_gps_group); 3406 3407 /* 3408 * core_alua_free_tg_pt_gp() is called from ->default_tg_pt_gp 3409 * directly from target_core_alua_tg_pt_gp_release(). 3410 */ 3411 dev->t10_alua.default_tg_pt_gp = NULL; 3412 3413 configfs_remove_default_groups(dev_cg); 3414 3415 /* 3416 * se_dev is released from target_core_dev_item_ops->release() 3417 */ 3418 config_item_put(item); 3419 3420 mutex_lock(&target_devices_lock); 3421 target_devices--; 3422 mutex_unlock(&target_devices_lock); 3423 3424 mutex_unlock(&hba->hba_access_mutex); 3425 } 3426 3427 static struct configfs_group_operations target_core_hba_group_ops = { 3428 .make_group = target_core_make_subdev, 3429 .drop_item = target_core_drop_subdev, 3430 }; 3431 3432 3433 static inline struct se_hba *to_hba(struct config_item *item) 3434 { 3435 return container_of(to_config_group(item), struct se_hba, hba_group); 3436 } 3437 3438 static ssize_t target_hba_info_show(struct config_item *item, char *page) 3439 { 3440 struct se_hba *hba = to_hba(item); 3441 3442 return sprintf(page, "HBA Index: %d plugin: %s version: %s\n", 3443 hba->hba_id, hba->backend->ops->name, 3444 TARGET_CORE_VERSION); 3445 } 3446 3447 static ssize_t target_hba_mode_show(struct config_item *item, char *page) 3448 { 3449 struct se_hba *hba = to_hba(item); 3450 int hba_mode = 0; 3451 3452 if (hba->hba_flags & HBA_FLAGS_PSCSI_MODE) 3453 hba_mode = 1; 3454 3455 return sprintf(page, "%d\n", hba_mode); 3456 } 3457 3458 static ssize_t target_hba_mode_store(struct config_item *item, 3459 const char *page, size_t count) 3460 { 3461 struct se_hba *hba = to_hba(item); 3462 unsigned long mode_flag; 3463 int ret; 3464 3465 if (hba->backend->ops->pmode_enable_hba == NULL) 3466 return -EINVAL; 3467 3468 ret = kstrtoul(page, 0, &mode_flag); 3469 if (ret < 0) { 3470 pr_err("Unable to extract hba mode flag: %d\n", ret); 3471 return ret; 3472 } 3473 3474 if (hba->dev_count) { 3475 pr_err("Unable to set hba_mode with active devices\n"); 3476 return -EINVAL; 3477 } 3478 3479 ret = hba->backend->ops->pmode_enable_hba(hba, mode_flag); 3480 if (ret < 0) 3481 return -EINVAL; 3482 if (ret > 0) 3483 hba->hba_flags |= HBA_FLAGS_PSCSI_MODE; 3484 else if (ret == 0) 3485 hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE; 3486 3487 return count; 3488 } 3489 3490 CONFIGFS_ATTR_RO(target_, hba_info); 3491 CONFIGFS_ATTR(target_, hba_mode); 3492 3493 static void target_core_hba_release(struct config_item *item) 3494 { 3495 struct se_hba *hba = container_of(to_config_group(item), 3496 struct se_hba, hba_group); 3497 core_delete_hba(hba); 3498 } 3499 3500 static struct configfs_attribute *target_core_hba_attrs[] = { 3501 &target_attr_hba_info, 3502 &target_attr_hba_mode, 3503 NULL, 3504 }; 3505 3506 static struct configfs_item_operations target_core_hba_item_ops = { 3507 .release = target_core_hba_release, 3508 }; 3509 3510 static const struct config_item_type target_core_hba_cit = { 3511 .ct_item_ops = &target_core_hba_item_ops, 3512 .ct_group_ops = &target_core_hba_group_ops, 3513 .ct_attrs = target_core_hba_attrs, 3514 .ct_owner = THIS_MODULE, 3515 }; 3516 3517 static struct config_group *target_core_call_addhbatotarget( 3518 struct config_group *group, 3519 const char *name) 3520 { 3521 char *se_plugin_str, *str, *str2; 3522 struct se_hba *hba; 3523 char buf[TARGET_CORE_NAME_MAX_LEN] = { }; 3524 unsigned long plugin_dep_id = 0; 3525 int ret; 3526 3527 if (strlen(name) >= TARGET_CORE_NAME_MAX_LEN) { 3528 pr_err("Passed *name strlen(): %d exceeds" 3529 " TARGET_CORE_NAME_MAX_LEN: %d\n", (int)strlen(name), 3530 TARGET_CORE_NAME_MAX_LEN); 3531 return ERR_PTR(-ENAMETOOLONG); 3532 } 3533 snprintf(buf, TARGET_CORE_NAME_MAX_LEN, "%s", name); 3534 3535 str = strstr(buf, "_"); 3536 if (!str) { 3537 pr_err("Unable to locate \"_\" for $SUBSYSTEM_PLUGIN_$HOST_ID\n"); 3538 return ERR_PTR(-EINVAL); 3539 } 3540 se_plugin_str = buf; 3541 /* 3542 * Special case for subsystem plugins that have "_" in their names. 3543 * Namely rd_direct and rd_mcp.. 3544 */ 3545 str2 = strstr(str+1, "_"); 3546 if (str2) { 3547 *str2 = '\0'; /* Terminate for *se_plugin_str */ 3548 str2++; /* Skip to start of plugin dependent ID */ 3549 str = str2; 3550 } else { 3551 *str = '\0'; /* Terminate for *se_plugin_str */ 3552 str++; /* Skip to start of plugin dependent ID */ 3553 } 3554 3555 ret = kstrtoul(str, 0, &plugin_dep_id); 3556 if (ret < 0) { 3557 pr_err("kstrtoul() returned %d for" 3558 " plugin_dep_id\n", ret); 3559 return ERR_PTR(ret); 3560 } 3561 /* 3562 * Load up TCM subsystem plugins if they have not already been loaded. 3563 */ 3564 transport_subsystem_check_init(); 3565 3566 hba = core_alloc_hba(se_plugin_str, plugin_dep_id, 0); 3567 if (IS_ERR(hba)) 3568 return ERR_CAST(hba); 3569 3570 config_group_init_type_name(&hba->hba_group, name, 3571 &target_core_hba_cit); 3572 3573 return &hba->hba_group; 3574 } 3575 3576 static void target_core_call_delhbafromtarget( 3577 struct config_group *group, 3578 struct config_item *item) 3579 { 3580 /* 3581 * core_delete_hba() is called from target_core_hba_item_ops->release() 3582 * -> target_core_hba_release() 3583 */ 3584 config_item_put(item); 3585 } 3586 3587 static struct configfs_group_operations target_core_group_ops = { 3588 .make_group = target_core_call_addhbatotarget, 3589 .drop_item = target_core_call_delhbafromtarget, 3590 }; 3591 3592 static const struct config_item_type target_core_cit = { 3593 .ct_item_ops = NULL, 3594 .ct_group_ops = &target_core_group_ops, 3595 .ct_attrs = NULL, 3596 .ct_owner = THIS_MODULE, 3597 }; 3598 3599 /* Stop functions for struct config_item_type target_core_hba_cit */ 3600 3601 void target_setup_backend_cits(struct target_backend *tb) 3602 { 3603 target_core_setup_dev_cit(tb); 3604 target_core_setup_dev_action_cit(tb); 3605 target_core_setup_dev_attrib_cit(tb); 3606 target_core_setup_dev_pr_cit(tb); 3607 target_core_setup_dev_wwn_cit(tb); 3608 target_core_setup_dev_alua_tg_pt_gps_cit(tb); 3609 target_core_setup_dev_stat_cit(tb); 3610 } 3611 3612 static void target_init_dbroot(void) 3613 { 3614 struct file *fp; 3615 3616 snprintf(db_root_stage, DB_ROOT_LEN, DB_ROOT_PREFERRED); 3617 fp = filp_open(db_root_stage, O_RDONLY, 0); 3618 if (IS_ERR(fp)) { 3619 pr_err("db_root: cannot open: %s\n", db_root_stage); 3620 return; 3621 } 3622 if (!S_ISDIR(file_inode(fp)->i_mode)) { 3623 filp_close(fp, NULL); 3624 pr_err("db_root: not a valid directory: %s\n", db_root_stage); 3625 return; 3626 } 3627 filp_close(fp, NULL); 3628 3629 strncpy(db_root, db_root_stage, DB_ROOT_LEN); 3630 pr_debug("Target_Core_ConfigFS: db_root set to %s\n", db_root); 3631 } 3632 3633 static int __init target_core_init_configfs(void) 3634 { 3635 struct configfs_subsystem *subsys = &target_core_fabrics; 3636 struct t10_alua_lu_gp *lu_gp; 3637 int ret; 3638 3639 pr_debug("TARGET_CORE[0]: Loading Generic Kernel Storage" 3640 " Engine: %s on %s/%s on "UTS_RELEASE"\n", 3641 TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine); 3642 3643 config_group_init(&subsys->su_group); 3644 mutex_init(&subsys->su_mutex); 3645 3646 ret = init_se_kmem_caches(); 3647 if (ret < 0) 3648 return ret; 3649 /* 3650 * Create $CONFIGFS/target/core default group for HBA <-> Storage Object 3651 * and ALUA Logical Unit Group and Target Port Group infrastructure. 3652 */ 3653 config_group_init_type_name(&target_core_hbagroup, "core", 3654 &target_core_cit); 3655 configfs_add_default_group(&target_core_hbagroup, &subsys->su_group); 3656 3657 /* 3658 * Create ALUA infrastructure under /sys/kernel/config/target/core/alua/ 3659 */ 3660 config_group_init_type_name(&alua_group, "alua", &target_core_alua_cit); 3661 configfs_add_default_group(&alua_group, &target_core_hbagroup); 3662 3663 /* 3664 * Add ALUA Logical Unit Group and Target Port Group ConfigFS 3665 * groups under /sys/kernel/config/target/core/alua/ 3666 */ 3667 config_group_init_type_name(&alua_lu_gps_group, "lu_gps", 3668 &target_core_alua_lu_gps_cit); 3669 configfs_add_default_group(&alua_lu_gps_group, &alua_group); 3670 3671 /* 3672 * Add core/alua/lu_gps/default_lu_gp 3673 */ 3674 lu_gp = core_alua_allocate_lu_gp("default_lu_gp", 1); 3675 if (IS_ERR(lu_gp)) { 3676 ret = -ENOMEM; 3677 goto out_global; 3678 } 3679 3680 config_group_init_type_name(&lu_gp->lu_gp_group, "default_lu_gp", 3681 &target_core_alua_lu_gp_cit); 3682 configfs_add_default_group(&lu_gp->lu_gp_group, &alua_lu_gps_group); 3683 3684 default_lu_gp = lu_gp; 3685 3686 /* 3687 * Register the target_core_mod subsystem with configfs. 3688 */ 3689 ret = configfs_register_subsystem(subsys); 3690 if (ret < 0) { 3691 pr_err("Error %d while registering subsystem %s\n", 3692 ret, subsys->su_group.cg_item.ci_namebuf); 3693 goto out_global; 3694 } 3695 pr_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric" 3696 " Infrastructure: "TARGET_CORE_VERSION" on %s/%s" 3697 " on "UTS_RELEASE"\n", utsname()->sysname, utsname()->machine); 3698 /* 3699 * Register built-in RAMDISK subsystem logic for virtual LUN 0 3700 */ 3701 ret = rd_module_init(); 3702 if (ret < 0) 3703 goto out; 3704 3705 ret = core_dev_setup_virtual_lun0(); 3706 if (ret < 0) 3707 goto out; 3708 3709 ret = target_xcopy_setup_pt(); 3710 if (ret < 0) 3711 goto out; 3712 3713 target_init_dbroot(); 3714 3715 return 0; 3716 3717 out: 3718 configfs_unregister_subsystem(subsys); 3719 core_dev_release_virtual_lun0(); 3720 rd_module_exit(); 3721 out_global: 3722 if (default_lu_gp) { 3723 core_alua_free_lu_gp(default_lu_gp); 3724 default_lu_gp = NULL; 3725 } 3726 release_se_kmem_caches(); 3727 return ret; 3728 } 3729 3730 static void __exit target_core_exit_configfs(void) 3731 { 3732 configfs_remove_default_groups(&alua_lu_gps_group); 3733 configfs_remove_default_groups(&alua_group); 3734 configfs_remove_default_groups(&target_core_hbagroup); 3735 3736 /* 3737 * We expect subsys->su_group.default_groups to be released 3738 * by configfs subsystem provider logic.. 3739 */ 3740 configfs_unregister_subsystem(&target_core_fabrics); 3741 3742 core_alua_free_lu_gp(default_lu_gp); 3743 default_lu_gp = NULL; 3744 3745 pr_debug("TARGET_CORE[0]: Released ConfigFS Fabric" 3746 " Infrastructure\n"); 3747 3748 core_dev_release_virtual_lun0(); 3749 rd_module_exit(); 3750 target_xcopy_release_pt(); 3751 release_se_kmem_caches(); 3752 } 3753 3754 MODULE_DESCRIPTION("Target_Core_Mod/ConfigFS"); 3755 MODULE_AUTHOR("nab@Linux-iSCSI.org"); 3756 MODULE_LICENSE("GPL"); 3757 3758 module_init(target_core_init_configfs); 3759 module_exit(target_core_exit_configfs); 3760