1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /******************************************************************************* 3 * Filename: target_core_device.c (based on iscsi_target_device.c) 4 * 5 * This file contains the TCM Virtual Device and Disk Transport 6 * agnostic related functions. 7 * 8 * (c) Copyright 2003-2013 Datera, Inc. 9 * 10 * Nicholas A. Bellinger <nab@kernel.org> 11 * 12 ******************************************************************************/ 13 14 #include <linux/net.h> 15 #include <linux/string.h> 16 #include <linux/delay.h> 17 #include <linux/timer.h> 18 #include <linux/slab.h> 19 #include <linux/spinlock.h> 20 #include <linux/kthread.h> 21 #include <linux/in.h> 22 #include <linux/export.h> 23 #include <linux/t10-pi.h> 24 #include <asm/unaligned.h> 25 #include <net/sock.h> 26 #include <net/tcp.h> 27 #include <scsi/scsi_common.h> 28 #include <scsi/scsi_proto.h> 29 30 #include <target/target_core_base.h> 31 #include <target/target_core_backend.h> 32 #include <target/target_core_fabric.h> 33 34 #include "target_core_internal.h" 35 #include "target_core_alua.h" 36 #include "target_core_pr.h" 37 #include "target_core_ua.h" 38 39 static DEFINE_MUTEX(device_mutex); 40 static LIST_HEAD(device_list); 41 static DEFINE_IDR(devices_idr); 42 43 static struct se_hba *lun0_hba; 44 /* not static, needed by tpg.c */ 45 struct se_device *g_lun0_dev; 46 47 sense_reason_t 48 transport_lookup_cmd_lun(struct se_cmd *se_cmd) 49 { 50 struct se_lun *se_lun = NULL; 51 struct se_session *se_sess = se_cmd->se_sess; 52 struct se_node_acl *nacl = se_sess->se_node_acl; 53 struct se_dev_entry *deve; 54 sense_reason_t ret = TCM_NO_SENSE; 55 56 rcu_read_lock(); 57 deve = target_nacl_find_deve(nacl, se_cmd->orig_fe_lun); 58 if (deve) { 59 atomic_long_inc(&deve->total_cmds); 60 61 if (se_cmd->data_direction == DMA_TO_DEVICE) 62 atomic_long_add(se_cmd->data_length, 63 &deve->write_bytes); 64 else if (se_cmd->data_direction == DMA_FROM_DEVICE) 65 atomic_long_add(se_cmd->data_length, 66 &deve->read_bytes); 67 68 if ((se_cmd->data_direction == DMA_TO_DEVICE) && 69 deve->lun_access_ro) { 70 pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN" 71 " Access for 0x%08llx\n", 72 se_cmd->se_tfo->fabric_name, 73 se_cmd->orig_fe_lun); 74 rcu_read_unlock(); 75 return TCM_WRITE_PROTECTED; 76 } 77 78 se_lun = deve->se_lun; 79 80 if (!percpu_ref_tryget_live(&se_lun->lun_ref)) { 81 se_lun = NULL; 82 goto out_unlock; 83 } 84 85 se_cmd->se_lun = se_lun; 86 se_cmd->pr_res_key = deve->pr_res_key; 87 se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD; 88 se_cmd->lun_ref_active = true; 89 } 90 out_unlock: 91 rcu_read_unlock(); 92 93 if (!se_lun) { 94 /* 95 * Use the se_portal_group->tpg_virt_lun0 to allow for 96 * REPORT_LUNS, et al to be returned when no active 97 * MappedLUN=0 exists for this Initiator Port. 98 */ 99 if (se_cmd->orig_fe_lun != 0) { 100 pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN" 101 " Access for 0x%08llx from %s\n", 102 se_cmd->se_tfo->fabric_name, 103 se_cmd->orig_fe_lun, 104 nacl->initiatorname); 105 return TCM_NON_EXISTENT_LUN; 106 } 107 108 /* 109 * Force WRITE PROTECT for virtual LUN 0 110 */ 111 if ((se_cmd->data_direction != DMA_FROM_DEVICE) && 112 (se_cmd->data_direction != DMA_NONE)) 113 return TCM_WRITE_PROTECTED; 114 115 se_lun = se_sess->se_tpg->tpg_virt_lun0; 116 if (!percpu_ref_tryget_live(&se_lun->lun_ref)) 117 return TCM_NON_EXISTENT_LUN; 118 119 se_cmd->se_lun = se_sess->se_tpg->tpg_virt_lun0; 120 se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD; 121 se_cmd->lun_ref_active = true; 122 } 123 /* 124 * RCU reference protected by percpu se_lun->lun_ref taken above that 125 * must drop to zero (including initial reference) before this se_lun 126 * pointer can be kfree_rcu() by the final se_lun->lun_group put via 127 * target_core_fabric_configfs.c:target_fabric_port_release 128 */ 129 se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev); 130 atomic_long_inc(&se_cmd->se_dev->num_cmds); 131 132 if (se_cmd->data_direction == DMA_TO_DEVICE) 133 atomic_long_add(se_cmd->data_length, 134 &se_cmd->se_dev->write_bytes); 135 else if (se_cmd->data_direction == DMA_FROM_DEVICE) 136 atomic_long_add(se_cmd->data_length, 137 &se_cmd->se_dev->read_bytes); 138 139 return ret; 140 } 141 EXPORT_SYMBOL(transport_lookup_cmd_lun); 142 143 int transport_lookup_tmr_lun(struct se_cmd *se_cmd) 144 { 145 struct se_dev_entry *deve; 146 struct se_lun *se_lun = NULL; 147 struct se_session *se_sess = se_cmd->se_sess; 148 struct se_node_acl *nacl = se_sess->se_node_acl; 149 struct se_tmr_req *se_tmr = se_cmd->se_tmr_req; 150 151 rcu_read_lock(); 152 deve = target_nacl_find_deve(nacl, se_cmd->orig_fe_lun); 153 if (deve) { 154 se_lun = deve->se_lun; 155 156 if (!percpu_ref_tryget_live(&se_lun->lun_ref)) { 157 se_lun = NULL; 158 goto out_unlock; 159 } 160 161 se_cmd->se_lun = se_lun; 162 se_cmd->pr_res_key = deve->pr_res_key; 163 se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD; 164 se_cmd->lun_ref_active = true; 165 } 166 out_unlock: 167 rcu_read_unlock(); 168 169 if (!se_lun) { 170 pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN" 171 " Access for 0x%08llx for %s\n", 172 se_cmd->se_tfo->fabric_name, 173 se_cmd->orig_fe_lun, 174 nacl->initiatorname); 175 return -ENODEV; 176 } 177 se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev); 178 se_tmr->tmr_dev = rcu_dereference_raw(se_lun->lun_se_dev); 179 180 return 0; 181 } 182 EXPORT_SYMBOL(transport_lookup_tmr_lun); 183 184 bool target_lun_is_rdonly(struct se_cmd *cmd) 185 { 186 struct se_session *se_sess = cmd->se_sess; 187 struct se_dev_entry *deve; 188 bool ret; 189 190 rcu_read_lock(); 191 deve = target_nacl_find_deve(se_sess->se_node_acl, cmd->orig_fe_lun); 192 ret = deve && deve->lun_access_ro; 193 rcu_read_unlock(); 194 195 return ret; 196 } 197 EXPORT_SYMBOL(target_lun_is_rdonly); 198 199 /* 200 * This function is called from core_scsi3_emulate_pro_register_and_move() 201 * and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_kref 202 * when a matching rtpi is found. 203 */ 204 struct se_dev_entry *core_get_se_deve_from_rtpi( 205 struct se_node_acl *nacl, 206 u16 rtpi) 207 { 208 struct se_dev_entry *deve; 209 struct se_lun *lun; 210 struct se_portal_group *tpg = nacl->se_tpg; 211 212 rcu_read_lock(); 213 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) { 214 lun = deve->se_lun; 215 if (!lun) { 216 pr_err("%s device entries device pointer is" 217 " NULL, but Initiator has access.\n", 218 tpg->se_tpg_tfo->fabric_name); 219 continue; 220 } 221 if (lun->lun_tpg->tpg_rtpi != rtpi) 222 continue; 223 224 kref_get(&deve->pr_kref); 225 rcu_read_unlock(); 226 227 return deve; 228 } 229 rcu_read_unlock(); 230 231 return NULL; 232 } 233 234 void core_free_device_list_for_node( 235 struct se_node_acl *nacl, 236 struct se_portal_group *tpg) 237 { 238 struct se_dev_entry *deve; 239 240 mutex_lock(&nacl->lun_entry_mutex); 241 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) 242 core_disable_device_list_for_node(deve->se_lun, deve, nacl, tpg); 243 mutex_unlock(&nacl->lun_entry_mutex); 244 } 245 246 void core_update_device_list_access( 247 u64 mapped_lun, 248 bool lun_access_ro, 249 struct se_node_acl *nacl) 250 { 251 struct se_dev_entry *deve; 252 253 mutex_lock(&nacl->lun_entry_mutex); 254 deve = target_nacl_find_deve(nacl, mapped_lun); 255 if (deve) 256 deve->lun_access_ro = lun_access_ro; 257 mutex_unlock(&nacl->lun_entry_mutex); 258 } 259 260 /* 261 * Called with rcu_read_lock or nacl->device_list_lock held. 262 */ 263 struct se_dev_entry *target_nacl_find_deve(struct se_node_acl *nacl, u64 mapped_lun) 264 { 265 struct se_dev_entry *deve; 266 267 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) 268 if (deve->mapped_lun == mapped_lun) 269 return deve; 270 271 return NULL; 272 } 273 EXPORT_SYMBOL(target_nacl_find_deve); 274 275 void target_pr_kref_release(struct kref *kref) 276 { 277 struct se_dev_entry *deve = container_of(kref, struct se_dev_entry, 278 pr_kref); 279 complete(&deve->pr_comp); 280 } 281 282 /* 283 * Establish UA condition on SCSI device - all LUNs 284 */ 285 void target_dev_ua_allocate(struct se_device *dev, u8 asc, u8 ascq) 286 { 287 struct se_dev_entry *se_deve; 288 struct se_lun *lun; 289 290 spin_lock(&dev->se_port_lock); 291 list_for_each_entry(lun, &dev->dev_sep_list, lun_dev_link) { 292 293 spin_lock(&lun->lun_deve_lock); 294 list_for_each_entry(se_deve, &lun->lun_deve_list, lun_link) 295 core_scsi3_ua_allocate(se_deve, asc, ascq); 296 spin_unlock(&lun->lun_deve_lock); 297 } 298 spin_unlock(&dev->se_port_lock); 299 } 300 301 static void 302 target_luns_data_has_changed(struct se_node_acl *nacl, struct se_dev_entry *new, 303 bool skip_new) 304 { 305 struct se_dev_entry *tmp; 306 307 rcu_read_lock(); 308 hlist_for_each_entry_rcu(tmp, &nacl->lun_entry_hlist, link) { 309 if (skip_new && tmp == new) 310 continue; 311 core_scsi3_ua_allocate(tmp, 0x3F, 312 ASCQ_3FH_REPORTED_LUNS_DATA_HAS_CHANGED); 313 } 314 rcu_read_unlock(); 315 } 316 317 int core_enable_device_list_for_node( 318 struct se_lun *lun, 319 struct se_lun_acl *lun_acl, 320 u64 mapped_lun, 321 bool lun_access_ro, 322 struct se_node_acl *nacl, 323 struct se_portal_group *tpg) 324 { 325 struct se_dev_entry *orig, *new; 326 327 new = kzalloc(sizeof(*new), GFP_KERNEL); 328 if (!new) { 329 pr_err("Unable to allocate se_dev_entry memory\n"); 330 return -ENOMEM; 331 } 332 333 spin_lock_init(&new->ua_lock); 334 INIT_LIST_HEAD(&new->ua_list); 335 INIT_LIST_HEAD(&new->lun_link); 336 337 new->mapped_lun = mapped_lun; 338 kref_init(&new->pr_kref); 339 init_completion(&new->pr_comp); 340 341 new->lun_access_ro = lun_access_ro; 342 new->creation_time = get_jiffies_64(); 343 new->attach_count++; 344 345 mutex_lock(&nacl->lun_entry_mutex); 346 orig = target_nacl_find_deve(nacl, mapped_lun); 347 if (orig && orig->se_lun) { 348 struct se_lun *orig_lun = orig->se_lun; 349 350 if (orig_lun != lun) { 351 pr_err("Existing orig->se_lun doesn't match new lun" 352 " for dynamic -> explicit NodeACL conversion:" 353 " %s\n", nacl->initiatorname); 354 mutex_unlock(&nacl->lun_entry_mutex); 355 kfree(new); 356 return -EINVAL; 357 } 358 if (orig->se_lun_acl != NULL) { 359 pr_warn_ratelimited("Detected existing explicit" 360 " se_lun_acl->se_lun_group reference for %s" 361 " mapped_lun: %llu, failing\n", 362 nacl->initiatorname, mapped_lun); 363 mutex_unlock(&nacl->lun_entry_mutex); 364 kfree(new); 365 return -EINVAL; 366 } 367 368 new->se_lun = lun; 369 new->se_lun_acl = lun_acl; 370 hlist_del_rcu(&orig->link); 371 hlist_add_head_rcu(&new->link, &nacl->lun_entry_hlist); 372 mutex_unlock(&nacl->lun_entry_mutex); 373 374 spin_lock(&lun->lun_deve_lock); 375 list_del(&orig->lun_link); 376 list_add_tail(&new->lun_link, &lun->lun_deve_list); 377 spin_unlock(&lun->lun_deve_lock); 378 379 kref_put(&orig->pr_kref, target_pr_kref_release); 380 wait_for_completion(&orig->pr_comp); 381 382 target_luns_data_has_changed(nacl, new, true); 383 kfree_rcu(orig, rcu_head); 384 return 0; 385 } 386 387 new->se_lun = lun; 388 new->se_lun_acl = lun_acl; 389 hlist_add_head_rcu(&new->link, &nacl->lun_entry_hlist); 390 mutex_unlock(&nacl->lun_entry_mutex); 391 392 spin_lock(&lun->lun_deve_lock); 393 list_add_tail(&new->lun_link, &lun->lun_deve_list); 394 spin_unlock(&lun->lun_deve_lock); 395 396 target_luns_data_has_changed(nacl, new, true); 397 return 0; 398 } 399 400 void core_disable_device_list_for_node( 401 struct se_lun *lun, 402 struct se_dev_entry *orig, 403 struct se_node_acl *nacl, 404 struct se_portal_group *tpg) 405 { 406 /* 407 * rcu_dereference_raw protected by se_lun->lun_group symlink 408 * reference to se_device->dev_group. 409 */ 410 struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev); 411 412 lockdep_assert_held(&nacl->lun_entry_mutex); 413 414 /* 415 * If the MappedLUN entry is being disabled, the entry in 416 * lun->lun_deve_list must be removed now before clearing the 417 * struct se_dev_entry pointers below as logic in 418 * core_alua_do_transition_tg_pt() depends on these being present. 419 * 420 * deve->se_lun_acl will be NULL for demo-mode created LUNs 421 * that have not been explicitly converted to MappedLUNs -> 422 * struct se_lun_acl, but we remove deve->lun_link from 423 * lun->lun_deve_list. This also means that active UAs and 424 * NodeACL context specific PR metadata for demo-mode 425 * MappedLUN *deve will be released below.. 426 */ 427 spin_lock(&lun->lun_deve_lock); 428 list_del(&orig->lun_link); 429 spin_unlock(&lun->lun_deve_lock); 430 /* 431 * Disable struct se_dev_entry LUN ACL mapping 432 */ 433 core_scsi3_ua_release_all(orig); 434 435 hlist_del_rcu(&orig->link); 436 clear_bit(DEF_PR_REG_ACTIVE, &orig->deve_flags); 437 orig->lun_access_ro = false; 438 orig->creation_time = 0; 439 orig->attach_count--; 440 /* 441 * Before firing off RCU callback, wait for any in process SPEC_I_PT=1 442 * or REGISTER_AND_MOVE PR operation to complete. 443 */ 444 kref_put(&orig->pr_kref, target_pr_kref_release); 445 wait_for_completion(&orig->pr_comp); 446 447 kfree_rcu(orig, rcu_head); 448 449 core_scsi3_free_pr_reg_from_nacl(dev, nacl); 450 target_luns_data_has_changed(nacl, NULL, false); 451 } 452 453 /* core_clear_lun_from_tpg(): 454 * 455 * 456 */ 457 void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg) 458 { 459 struct se_node_acl *nacl; 460 struct se_dev_entry *deve; 461 462 mutex_lock(&tpg->acl_node_mutex); 463 list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) { 464 465 mutex_lock(&nacl->lun_entry_mutex); 466 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) { 467 if (lun != deve->se_lun) 468 continue; 469 470 core_disable_device_list_for_node(lun, deve, nacl, tpg); 471 } 472 mutex_unlock(&nacl->lun_entry_mutex); 473 } 474 mutex_unlock(&tpg->acl_node_mutex); 475 } 476 477 static void se_release_vpd_for_dev(struct se_device *dev) 478 { 479 struct t10_vpd *vpd, *vpd_tmp; 480 481 spin_lock(&dev->t10_wwn.t10_vpd_lock); 482 list_for_each_entry_safe(vpd, vpd_tmp, 483 &dev->t10_wwn.t10_vpd_list, vpd_list) { 484 list_del(&vpd->vpd_list); 485 kfree(vpd); 486 } 487 spin_unlock(&dev->t10_wwn.t10_vpd_lock); 488 } 489 490 static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size) 491 { 492 u32 aligned_max_sectors; 493 u32 alignment; 494 /* 495 * Limit max_sectors to a PAGE_SIZE aligned value for modern 496 * transport_allocate_data_tasks() operation. 497 */ 498 alignment = max(1ul, PAGE_SIZE / block_size); 499 aligned_max_sectors = rounddown(max_sectors, alignment); 500 501 if (max_sectors != aligned_max_sectors) 502 pr_info("Rounding down aligned max_sectors from %u to %u\n", 503 max_sectors, aligned_max_sectors); 504 505 return aligned_max_sectors; 506 } 507 508 int core_dev_add_lun( 509 struct se_portal_group *tpg, 510 struct se_device *dev, 511 struct se_lun *lun) 512 { 513 int rc; 514 515 rc = core_tpg_add_lun(tpg, lun, false, dev); 516 if (rc < 0) 517 return rc; 518 519 pr_debug("%s_TPG[%u]_LUN[%llu] - Activated %s Logical Unit from" 520 " CORE HBA: %u\n", tpg->se_tpg_tfo->fabric_name, 521 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, 522 tpg->se_tpg_tfo->fabric_name, dev->se_hba->hba_id); 523 /* 524 * Update LUN maps for dynamically added initiators when 525 * generate_node_acl is enabled. 526 */ 527 if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) { 528 struct se_node_acl *acl; 529 530 mutex_lock(&tpg->acl_node_mutex); 531 list_for_each_entry(acl, &tpg->acl_node_list, acl_list) { 532 if (acl->dynamic_node_acl && 533 (!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only || 534 !tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) { 535 core_tpg_add_node_to_devs(acl, tpg, lun); 536 } 537 } 538 mutex_unlock(&tpg->acl_node_mutex); 539 } 540 541 return 0; 542 } 543 544 /* core_dev_del_lun(): 545 * 546 * 547 */ 548 void core_dev_del_lun( 549 struct se_portal_group *tpg, 550 struct se_lun *lun) 551 { 552 pr_debug("%s_TPG[%u]_LUN[%llu] - Deactivating %s Logical Unit from" 553 " device object\n", tpg->se_tpg_tfo->fabric_name, 554 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, 555 tpg->se_tpg_tfo->fabric_name); 556 557 core_tpg_remove_lun(tpg, lun); 558 } 559 560 struct se_lun_acl *core_dev_init_initiator_node_lun_acl( 561 struct se_portal_group *tpg, 562 struct se_node_acl *nacl, 563 u64 mapped_lun, 564 int *ret) 565 { 566 struct se_lun_acl *lacl; 567 568 if (strlen(nacl->initiatorname) >= TRANSPORT_IQN_LEN) { 569 pr_err("%s InitiatorName exceeds maximum size.\n", 570 tpg->se_tpg_tfo->fabric_name); 571 *ret = -EOVERFLOW; 572 return NULL; 573 } 574 lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL); 575 if (!lacl) { 576 pr_err("Unable to allocate memory for struct se_lun_acl.\n"); 577 *ret = -ENOMEM; 578 return NULL; 579 } 580 581 lacl->mapped_lun = mapped_lun; 582 lacl->se_lun_nacl = nacl; 583 584 return lacl; 585 } 586 587 int core_dev_add_initiator_node_lun_acl( 588 struct se_portal_group *tpg, 589 struct se_lun_acl *lacl, 590 struct se_lun *lun, 591 bool lun_access_ro) 592 { 593 struct se_node_acl *nacl = lacl->se_lun_nacl; 594 /* 595 * rcu_dereference_raw protected by se_lun->lun_group symlink 596 * reference to se_device->dev_group. 597 */ 598 struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev); 599 600 if (!nacl) 601 return -EINVAL; 602 603 if (lun->lun_access_ro) 604 lun_access_ro = true; 605 606 lacl->se_lun = lun; 607 608 if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun, 609 lun_access_ro, nacl, tpg) < 0) 610 return -EINVAL; 611 612 pr_debug("%s_TPG[%hu]_LUN[%llu->%llu] - Added %s ACL for " 613 " InitiatorNode: %s\n", tpg->se_tpg_tfo->fabric_name, 614 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, lacl->mapped_lun, 615 lun_access_ro ? "RO" : "RW", 616 nacl->initiatorname); 617 /* 618 * Check to see if there are any existing persistent reservation APTPL 619 * pre-registrations that need to be enabled for this LUN ACL.. 620 */ 621 core_scsi3_check_aptpl_registration(dev, tpg, lun, nacl, 622 lacl->mapped_lun); 623 return 0; 624 } 625 626 int core_dev_del_initiator_node_lun_acl( 627 struct se_lun *lun, 628 struct se_lun_acl *lacl) 629 { 630 struct se_portal_group *tpg = lun->lun_tpg; 631 struct se_node_acl *nacl; 632 struct se_dev_entry *deve; 633 634 nacl = lacl->se_lun_nacl; 635 if (!nacl) 636 return -EINVAL; 637 638 mutex_lock(&nacl->lun_entry_mutex); 639 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 640 if (deve) 641 core_disable_device_list_for_node(lun, deve, nacl, tpg); 642 mutex_unlock(&nacl->lun_entry_mutex); 643 644 pr_debug("%s_TPG[%hu]_LUN[%llu] - Removed ACL for" 645 " InitiatorNode: %s Mapped LUN: %llu\n", 646 tpg->se_tpg_tfo->fabric_name, 647 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, 648 nacl->initiatorname, lacl->mapped_lun); 649 650 return 0; 651 } 652 653 void core_dev_free_initiator_node_lun_acl( 654 struct se_portal_group *tpg, 655 struct se_lun_acl *lacl) 656 { 657 pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s" 658 " Mapped LUN: %llu\n", tpg->se_tpg_tfo->fabric_name, 659 tpg->se_tpg_tfo->tpg_get_tag(tpg), 660 tpg->se_tpg_tfo->fabric_name, 661 lacl->se_lun_nacl->initiatorname, lacl->mapped_lun); 662 663 kfree(lacl); 664 } 665 666 static void scsi_dump_inquiry(struct se_device *dev) 667 { 668 struct t10_wwn *wwn = &dev->t10_wwn; 669 int device_type = dev->transport->get_device_type(dev); 670 671 /* 672 * Print Linux/SCSI style INQUIRY formatting to the kernel ring buffer 673 */ 674 pr_debug(" Vendor: %-" __stringify(INQUIRY_VENDOR_LEN) "s\n", 675 wwn->vendor); 676 pr_debug(" Model: %-" __stringify(INQUIRY_MODEL_LEN) "s\n", 677 wwn->model); 678 pr_debug(" Revision: %-" __stringify(INQUIRY_REVISION_LEN) "s\n", 679 wwn->revision); 680 pr_debug(" Type: %s ", scsi_device_type(device_type)); 681 } 682 683 struct se_device *target_alloc_device(struct se_hba *hba, const char *name) 684 { 685 struct se_device *dev; 686 struct se_lun *xcopy_lun; 687 int i; 688 689 dev = hba->backend->ops->alloc_device(hba, name); 690 if (!dev) 691 return NULL; 692 693 dev->queues = kcalloc(nr_cpu_ids, sizeof(*dev->queues), GFP_KERNEL); 694 if (!dev->queues) { 695 dev->transport->free_device(dev); 696 return NULL; 697 } 698 699 dev->queue_cnt = nr_cpu_ids; 700 for (i = 0; i < dev->queue_cnt; i++) { 701 struct se_device_queue *q; 702 703 q = &dev->queues[i]; 704 INIT_LIST_HEAD(&q->state_list); 705 spin_lock_init(&q->lock); 706 707 init_llist_head(&q->sq.cmd_list); 708 INIT_WORK(&q->sq.work, target_queued_submit_work); 709 } 710 711 dev->se_hba = hba; 712 dev->transport = hba->backend->ops; 713 dev->transport_flags = dev->transport->transport_flags_default; 714 dev->prot_length = sizeof(struct t10_pi_tuple); 715 dev->hba_index = hba->hba_index; 716 717 INIT_LIST_HEAD(&dev->dev_sep_list); 718 INIT_LIST_HEAD(&dev->dev_tmr_list); 719 INIT_LIST_HEAD(&dev->delayed_cmd_list); 720 INIT_LIST_HEAD(&dev->qf_cmd_list); 721 spin_lock_init(&dev->delayed_cmd_lock); 722 spin_lock_init(&dev->dev_reservation_lock); 723 spin_lock_init(&dev->se_port_lock); 724 spin_lock_init(&dev->se_tmr_lock); 725 spin_lock_init(&dev->qf_cmd_lock); 726 sema_init(&dev->caw_sem, 1); 727 INIT_LIST_HEAD(&dev->t10_wwn.t10_vpd_list); 728 spin_lock_init(&dev->t10_wwn.t10_vpd_lock); 729 INIT_LIST_HEAD(&dev->t10_pr.registration_list); 730 INIT_LIST_HEAD(&dev->t10_pr.aptpl_reg_list); 731 spin_lock_init(&dev->t10_pr.registration_lock); 732 spin_lock_init(&dev->t10_pr.aptpl_reg_lock); 733 INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list); 734 spin_lock_init(&dev->t10_alua.tg_pt_gps_lock); 735 INIT_LIST_HEAD(&dev->t10_alua.lba_map_list); 736 spin_lock_init(&dev->t10_alua.lba_map_lock); 737 738 INIT_WORK(&dev->delayed_cmd_work, target_do_delayed_work); 739 mutex_init(&dev->lun_reset_mutex); 740 741 dev->t10_wwn.t10_dev = dev; 742 /* 743 * Use OpenFabrics IEEE Company ID: 00 14 05 744 */ 745 dev->t10_wwn.company_id = 0x001405; 746 747 dev->t10_alua.t10_dev = dev; 748 749 dev->dev_attrib.da_dev = dev; 750 dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS; 751 dev->dev_attrib.emulate_dpo = 1; 752 dev->dev_attrib.emulate_fua_write = 1; 753 dev->dev_attrib.emulate_fua_read = 1; 754 dev->dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE; 755 dev->dev_attrib.emulate_ua_intlck_ctrl = TARGET_UA_INTLCK_CTRL_CLEAR; 756 dev->dev_attrib.emulate_tas = DA_EMULATE_TAS; 757 dev->dev_attrib.emulate_tpu = DA_EMULATE_TPU; 758 dev->dev_attrib.emulate_tpws = DA_EMULATE_TPWS; 759 dev->dev_attrib.emulate_caw = DA_EMULATE_CAW; 760 dev->dev_attrib.emulate_3pc = DA_EMULATE_3PC; 761 dev->dev_attrib.emulate_pr = DA_EMULATE_PR; 762 dev->dev_attrib.emulate_rsoc = DA_EMULATE_RSOC; 763 dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE0_PROT; 764 dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS; 765 dev->dev_attrib.force_pr_aptpl = DA_FORCE_PR_APTPL; 766 dev->dev_attrib.is_nonrot = DA_IS_NONROT; 767 dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD; 768 dev->dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT; 769 dev->dev_attrib.max_unmap_block_desc_count = 770 DA_MAX_UNMAP_BLOCK_DESC_COUNT; 771 dev->dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT; 772 dev->dev_attrib.unmap_granularity_alignment = 773 DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT; 774 dev->dev_attrib.unmap_zeroes_data = 775 DA_UNMAP_ZEROES_DATA_DEFAULT; 776 dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN; 777 778 xcopy_lun = &dev->xcopy_lun; 779 rcu_assign_pointer(xcopy_lun->lun_se_dev, dev); 780 init_completion(&xcopy_lun->lun_shutdown_comp); 781 INIT_LIST_HEAD(&xcopy_lun->lun_deve_list); 782 INIT_LIST_HEAD(&xcopy_lun->lun_dev_link); 783 mutex_init(&xcopy_lun->lun_tg_pt_md_mutex); 784 xcopy_lun->lun_tpg = &xcopy_pt_tpg; 785 786 /* Preload the default INQUIRY const values */ 787 strscpy(dev->t10_wwn.vendor, "LIO-ORG", sizeof(dev->t10_wwn.vendor)); 788 strscpy(dev->t10_wwn.model, dev->transport->inquiry_prod, 789 sizeof(dev->t10_wwn.model)); 790 strscpy(dev->t10_wwn.revision, dev->transport->inquiry_rev, 791 sizeof(dev->t10_wwn.revision)); 792 793 return dev; 794 } 795 796 /* 797 * Check if the underlying struct block_device supports discard and if yes 798 * configure the UNMAP parameters. 799 */ 800 bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib, 801 struct block_device *bdev) 802 { 803 int block_size = bdev_logical_block_size(bdev); 804 805 if (!bdev_max_discard_sectors(bdev)) 806 return false; 807 808 attrib->max_unmap_lba_count = 809 bdev_max_discard_sectors(bdev) >> (ilog2(block_size) - 9); 810 /* 811 * Currently hardcoded to 1 in Linux/SCSI code.. 812 */ 813 attrib->max_unmap_block_desc_count = 1; 814 attrib->unmap_granularity = bdev_discard_granularity(bdev) / block_size; 815 attrib->unmap_granularity_alignment = 816 bdev_discard_alignment(bdev) / block_size; 817 return true; 818 } 819 EXPORT_SYMBOL(target_configure_unmap_from_queue); 820 821 /* 822 * Convert from blocksize advertised to the initiator to the 512 byte 823 * units unconditionally used by the Linux block layer. 824 */ 825 sector_t target_to_linux_sector(struct se_device *dev, sector_t lb) 826 { 827 switch (dev->dev_attrib.block_size) { 828 case 4096: 829 return lb << 3; 830 case 2048: 831 return lb << 2; 832 case 1024: 833 return lb << 1; 834 default: 835 return lb; 836 } 837 } 838 EXPORT_SYMBOL(target_to_linux_sector); 839 840 struct devices_idr_iter { 841 int (*fn)(struct se_device *dev, void *data); 842 void *data; 843 }; 844 845 static int target_devices_idr_iter(int id, void *p, void *data) 846 __must_hold(&device_mutex) 847 { 848 struct devices_idr_iter *iter = data; 849 struct se_device *dev = p; 850 struct config_item *item; 851 int ret; 852 853 /* 854 * We add the device early to the idr, so it can be used 855 * by backend modules during configuration. We do not want 856 * to allow other callers to access partially setup devices, 857 * so we skip them here. 858 */ 859 if (!target_dev_configured(dev)) 860 return 0; 861 862 item = config_item_get_unless_zero(&dev->dev_group.cg_item); 863 if (!item) 864 return 0; 865 mutex_unlock(&device_mutex); 866 867 ret = iter->fn(dev, iter->data); 868 config_item_put(item); 869 870 mutex_lock(&device_mutex); 871 return ret; 872 } 873 874 /** 875 * target_for_each_device - iterate over configured devices 876 * @fn: iterator function 877 * @data: pointer to data that will be passed to fn 878 * 879 * fn must return 0 to continue looping over devices. non-zero will break 880 * from the loop and return that value to the caller. 881 */ 882 int target_for_each_device(int (*fn)(struct se_device *dev, void *data), 883 void *data) 884 { 885 struct devices_idr_iter iter = { .fn = fn, .data = data }; 886 int ret; 887 888 mutex_lock(&device_mutex); 889 ret = idr_for_each(&devices_idr, target_devices_idr_iter, &iter); 890 mutex_unlock(&device_mutex); 891 return ret; 892 } 893 894 int target_configure_device(struct se_device *dev) 895 { 896 struct se_hba *hba = dev->se_hba; 897 int ret, id; 898 899 if (target_dev_configured(dev)) { 900 pr_err("se_dev->se_dev_ptr already set for storage" 901 " object\n"); 902 return -EEXIST; 903 } 904 905 /* 906 * Add early so modules like tcmu can use during its 907 * configuration. 908 */ 909 mutex_lock(&device_mutex); 910 /* 911 * Use cyclic to try and avoid collisions with devices 912 * that were recently removed. 913 */ 914 id = idr_alloc_cyclic(&devices_idr, dev, 0, INT_MAX, GFP_KERNEL); 915 mutex_unlock(&device_mutex); 916 if (id < 0) { 917 ret = -ENOMEM; 918 goto out; 919 } 920 dev->dev_index = id; 921 922 ret = dev->transport->configure_device(dev); 923 if (ret) 924 goto out_free_index; 925 926 if (dev->transport->configure_unmap && 927 dev->transport->configure_unmap(dev)) { 928 pr_debug("Discard support available, but disabled by default.\n"); 929 } 930 931 /* 932 * XXX: there is not much point to have two different values here.. 933 */ 934 dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size; 935 dev->dev_attrib.queue_depth = dev->dev_attrib.hw_queue_depth; 936 937 /* 938 * Align max_hw_sectors down to PAGE_SIZE I/O transfers 939 */ 940 dev->dev_attrib.hw_max_sectors = 941 se_dev_align_max_sectors(dev->dev_attrib.hw_max_sectors, 942 dev->dev_attrib.hw_block_size); 943 dev->dev_attrib.optimal_sectors = dev->dev_attrib.hw_max_sectors; 944 945 dev->creation_time = get_jiffies_64(); 946 947 ret = core_setup_alua(dev); 948 if (ret) 949 goto out_destroy_device; 950 951 /* 952 * Setup work_queue for QUEUE_FULL 953 */ 954 INIT_WORK(&dev->qf_work_queue, target_qf_do_work); 955 956 scsi_dump_inquiry(dev); 957 958 spin_lock(&hba->device_lock); 959 hba->dev_count++; 960 spin_unlock(&hba->device_lock); 961 962 dev->dev_flags |= DF_CONFIGURED; 963 964 return 0; 965 966 out_destroy_device: 967 dev->transport->destroy_device(dev); 968 out_free_index: 969 mutex_lock(&device_mutex); 970 idr_remove(&devices_idr, dev->dev_index); 971 mutex_unlock(&device_mutex); 972 out: 973 se_release_vpd_for_dev(dev); 974 return ret; 975 } 976 977 void target_free_device(struct se_device *dev) 978 { 979 struct se_hba *hba = dev->se_hba; 980 981 WARN_ON(!list_empty(&dev->dev_sep_list)); 982 983 if (target_dev_configured(dev)) { 984 dev->transport->destroy_device(dev); 985 986 mutex_lock(&device_mutex); 987 idr_remove(&devices_idr, dev->dev_index); 988 mutex_unlock(&device_mutex); 989 990 spin_lock(&hba->device_lock); 991 hba->dev_count--; 992 spin_unlock(&hba->device_lock); 993 } 994 995 core_alua_free_lu_gp_mem(dev); 996 core_alua_set_lba_map(dev, NULL, 0, 0); 997 core_scsi3_free_all_registrations(dev); 998 se_release_vpd_for_dev(dev); 999 1000 if (dev->transport->free_prot) 1001 dev->transport->free_prot(dev); 1002 1003 kfree(dev->queues); 1004 dev->transport->free_device(dev); 1005 } 1006 1007 int core_dev_setup_virtual_lun0(void) 1008 { 1009 struct se_hba *hba; 1010 struct se_device *dev; 1011 char buf[] = "rd_pages=8,rd_nullio=1,rd_dummy=1"; 1012 int ret; 1013 1014 hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE); 1015 if (IS_ERR(hba)) 1016 return PTR_ERR(hba); 1017 1018 dev = target_alloc_device(hba, "virt_lun0"); 1019 if (!dev) { 1020 ret = -ENOMEM; 1021 goto out_free_hba; 1022 } 1023 1024 hba->backend->ops->set_configfs_dev_params(dev, buf, sizeof(buf)); 1025 1026 ret = target_configure_device(dev); 1027 if (ret) 1028 goto out_free_se_dev; 1029 1030 lun0_hba = hba; 1031 g_lun0_dev = dev; 1032 return 0; 1033 1034 out_free_se_dev: 1035 target_free_device(dev); 1036 out_free_hba: 1037 core_delete_hba(hba); 1038 return ret; 1039 } 1040 1041 1042 void core_dev_release_virtual_lun0(void) 1043 { 1044 struct se_hba *hba = lun0_hba; 1045 1046 if (!hba) 1047 return; 1048 1049 if (g_lun0_dev) 1050 target_free_device(g_lun0_dev); 1051 core_delete_hba(hba); 1052 } 1053 1054 /* 1055 * Common CDB parsing for kernel and user passthrough. 1056 */ 1057 sense_reason_t 1058 passthrough_parse_cdb(struct se_cmd *cmd, 1059 sense_reason_t (*exec_cmd)(struct se_cmd *cmd)) 1060 { 1061 unsigned char *cdb = cmd->t_task_cdb; 1062 struct se_device *dev = cmd->se_dev; 1063 unsigned int size; 1064 1065 /* 1066 * For REPORT LUNS we always need to emulate the response, for everything 1067 * else, pass it up. 1068 */ 1069 if (cdb[0] == REPORT_LUNS) { 1070 cmd->execute_cmd = spc_emulate_report_luns; 1071 return TCM_NO_SENSE; 1072 } 1073 1074 /* 1075 * With emulate_pr disabled, all reservation requests should fail, 1076 * regardless of whether or not TRANSPORT_FLAG_PASSTHROUGH_PGR is set. 1077 */ 1078 if (!dev->dev_attrib.emulate_pr && 1079 ((cdb[0] == PERSISTENT_RESERVE_IN) || 1080 (cdb[0] == PERSISTENT_RESERVE_OUT) || 1081 (cdb[0] == RELEASE || cdb[0] == RELEASE_10) || 1082 (cdb[0] == RESERVE || cdb[0] == RESERVE_10))) { 1083 return TCM_UNSUPPORTED_SCSI_OPCODE; 1084 } 1085 1086 /* 1087 * For PERSISTENT RESERVE IN/OUT, RELEASE, and RESERVE we need to 1088 * emulate the response, since tcmu does not have the information 1089 * required to process these commands. 1090 */ 1091 if (!(dev->transport_flags & 1092 TRANSPORT_FLAG_PASSTHROUGH_PGR)) { 1093 if (cdb[0] == PERSISTENT_RESERVE_IN) { 1094 cmd->execute_cmd = target_scsi3_emulate_pr_in; 1095 size = get_unaligned_be16(&cdb[7]); 1096 return target_cmd_size_check(cmd, size); 1097 } 1098 if (cdb[0] == PERSISTENT_RESERVE_OUT) { 1099 cmd->execute_cmd = target_scsi3_emulate_pr_out; 1100 size = get_unaligned_be32(&cdb[5]); 1101 return target_cmd_size_check(cmd, size); 1102 } 1103 1104 if (cdb[0] == RELEASE || cdb[0] == RELEASE_10) { 1105 cmd->execute_cmd = target_scsi2_reservation_release; 1106 if (cdb[0] == RELEASE_10) 1107 size = get_unaligned_be16(&cdb[7]); 1108 else 1109 size = cmd->data_length; 1110 return target_cmd_size_check(cmd, size); 1111 } 1112 if (cdb[0] == RESERVE || cdb[0] == RESERVE_10) { 1113 cmd->execute_cmd = target_scsi2_reservation_reserve; 1114 if (cdb[0] == RESERVE_10) 1115 size = get_unaligned_be16(&cdb[7]); 1116 else 1117 size = cmd->data_length; 1118 return target_cmd_size_check(cmd, size); 1119 } 1120 } 1121 1122 /* Set DATA_CDB flag for ops that should have it */ 1123 switch (cdb[0]) { 1124 case READ_6: 1125 case READ_10: 1126 case READ_12: 1127 case READ_16: 1128 case WRITE_6: 1129 case WRITE_10: 1130 case WRITE_12: 1131 case WRITE_16: 1132 case WRITE_VERIFY: 1133 case WRITE_VERIFY_12: 1134 case WRITE_VERIFY_16: 1135 case COMPARE_AND_WRITE: 1136 case XDWRITEREAD_10: 1137 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 1138 break; 1139 case VARIABLE_LENGTH_CMD: 1140 switch (get_unaligned_be16(&cdb[8])) { 1141 case READ_32: 1142 case WRITE_32: 1143 case WRITE_VERIFY_32: 1144 case XDWRITEREAD_32: 1145 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 1146 break; 1147 } 1148 } 1149 1150 cmd->execute_cmd = exec_cmd; 1151 1152 return TCM_NO_SENSE; 1153 } 1154 EXPORT_SYMBOL(passthrough_parse_cdb); 1155