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 <linux/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 DEFINE_IDR(devices_idr); 41 42 static struct se_hba *lun0_hba; 43 /* not static, needed by tpg.c */ 44 struct se_device *g_lun0_dev; 45 46 sense_reason_t 47 transport_lookup_cmd_lun(struct se_cmd *se_cmd) 48 { 49 struct se_lun *se_lun = NULL; 50 struct se_session *se_sess = se_cmd->se_sess; 51 struct se_node_acl *nacl = se_sess->se_node_acl; 52 struct se_dev_entry *deve; 53 sense_reason_t ret = TCM_NO_SENSE; 54 55 rcu_read_lock(); 56 deve = target_nacl_find_deve(nacl, se_cmd->orig_fe_lun); 57 if (deve) { 58 atomic_long_inc(&deve->total_cmds); 59 60 if (se_cmd->data_direction == DMA_TO_DEVICE) 61 atomic_long_add(se_cmd->data_length, 62 &deve->write_bytes); 63 else if (se_cmd->data_direction == DMA_FROM_DEVICE) 64 atomic_long_add(se_cmd->data_length, 65 &deve->read_bytes); 66 67 if ((se_cmd->data_direction == DMA_TO_DEVICE) && 68 deve->lun_access_ro) { 69 pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN" 70 " Access for 0x%08llx\n", 71 se_cmd->se_tfo->fabric_name, 72 se_cmd->orig_fe_lun); 73 rcu_read_unlock(); 74 return TCM_WRITE_PROTECTED; 75 } 76 77 se_lun = deve->se_lun; 78 79 if (!percpu_ref_tryget_live(&se_lun->lun_ref)) { 80 se_lun = NULL; 81 goto out_unlock; 82 } 83 84 se_cmd->se_lun = se_lun; 85 se_cmd->pr_res_key = deve->pr_res_key; 86 se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD; 87 se_cmd->lun_ref_active = true; 88 } 89 out_unlock: 90 rcu_read_unlock(); 91 92 if (!se_lun) { 93 /* 94 * Use the se_portal_group->tpg_virt_lun0 to allow for 95 * REPORT_LUNS, et al to be returned when no active 96 * MappedLUN=0 exists for this Initiator Port. 97 */ 98 if (se_cmd->orig_fe_lun != 0) { 99 pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN" 100 " Access for 0x%08llx from %s\n", 101 se_cmd->se_tfo->fabric_name, 102 se_cmd->orig_fe_lun, 103 nacl->initiatorname); 104 return TCM_NON_EXISTENT_LUN; 105 } 106 107 /* 108 * Force WRITE PROTECT for virtual LUN 0 109 */ 110 if ((se_cmd->data_direction != DMA_FROM_DEVICE) && 111 (se_cmd->data_direction != DMA_NONE)) 112 return TCM_WRITE_PROTECTED; 113 114 se_lun = se_sess->se_tpg->tpg_virt_lun0; 115 if (!percpu_ref_tryget_live(&se_lun->lun_ref)) 116 return TCM_NON_EXISTENT_LUN; 117 118 se_cmd->se_lun = se_sess->se_tpg->tpg_virt_lun0; 119 se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD; 120 se_cmd->lun_ref_active = true; 121 } 122 /* 123 * RCU reference protected by percpu se_lun->lun_ref taken above that 124 * must drop to zero (including initial reference) before this se_lun 125 * pointer can be kfree_rcu() by the final se_lun->lun_group put via 126 * target_core_fabric_configfs.c:target_fabric_port_release 127 */ 128 se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev); 129 atomic_long_inc(&se_cmd->se_dev->num_cmds); 130 131 if (se_cmd->data_direction == DMA_TO_DEVICE) 132 atomic_long_add(se_cmd->data_length, 133 &se_cmd->se_dev->write_bytes); 134 else if (se_cmd->data_direction == DMA_FROM_DEVICE) 135 atomic_long_add(se_cmd->data_length, 136 &se_cmd->se_dev->read_bytes); 137 138 return ret; 139 } 140 EXPORT_SYMBOL(transport_lookup_cmd_lun); 141 142 int transport_lookup_tmr_lun(struct se_cmd *se_cmd) 143 { 144 struct se_dev_entry *deve; 145 struct se_lun *se_lun = NULL; 146 struct se_session *se_sess = se_cmd->se_sess; 147 struct se_node_acl *nacl = se_sess->se_node_acl; 148 struct se_tmr_req *se_tmr = se_cmd->se_tmr_req; 149 150 rcu_read_lock(); 151 deve = target_nacl_find_deve(nacl, se_cmd->orig_fe_lun); 152 if (deve) { 153 se_lun = deve->se_lun; 154 155 if (!percpu_ref_tryget_live(&se_lun->lun_ref)) { 156 se_lun = NULL; 157 goto out_unlock; 158 } 159 160 se_cmd->se_lun = se_lun; 161 se_cmd->pr_res_key = deve->pr_res_key; 162 se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD; 163 se_cmd->lun_ref_active = true; 164 } 165 out_unlock: 166 rcu_read_unlock(); 167 168 if (!se_lun) { 169 pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN" 170 " Access for 0x%08llx for %s\n", 171 se_cmd->se_tfo->fabric_name, 172 se_cmd->orig_fe_lun, 173 nacl->initiatorname); 174 return -ENODEV; 175 } 176 se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev); 177 se_tmr->tmr_dev = rcu_dereference_raw(se_lun->lun_se_dev); 178 179 return 0; 180 } 181 EXPORT_SYMBOL(transport_lookup_tmr_lun); 182 183 bool target_lun_is_rdonly(struct se_cmd *cmd) 184 { 185 struct se_session *se_sess = cmd->se_sess; 186 struct se_dev_entry *deve; 187 bool ret; 188 189 rcu_read_lock(); 190 deve = target_nacl_find_deve(se_sess->se_node_acl, cmd->orig_fe_lun); 191 ret = deve && deve->lun_access_ro; 192 rcu_read_unlock(); 193 194 return ret; 195 } 196 EXPORT_SYMBOL(target_lun_is_rdonly); 197 198 /* 199 * This function is called from core_scsi3_emulate_pro_register_and_move() 200 * and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_kref 201 * when a matching rtpi is found. 202 */ 203 struct se_dev_entry *core_get_se_deve_from_rtpi( 204 struct se_node_acl *nacl, 205 u16 rtpi) 206 { 207 struct se_dev_entry *deve; 208 struct se_lun *lun; 209 struct se_portal_group *tpg = nacl->se_tpg; 210 211 rcu_read_lock(); 212 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) { 213 lun = deve->se_lun; 214 if (!lun) { 215 pr_err("%s device entries device pointer is" 216 " NULL, but Initiator has access.\n", 217 tpg->se_tpg_tfo->fabric_name); 218 continue; 219 } 220 if (lun->lun_tpg->tpg_rtpi != rtpi) 221 continue; 222 223 kref_get(&deve->pr_kref); 224 rcu_read_unlock(); 225 226 return deve; 227 } 228 rcu_read_unlock(); 229 230 return NULL; 231 } 232 233 void core_free_device_list_for_node( 234 struct se_node_acl *nacl, 235 struct se_portal_group *tpg) 236 { 237 struct se_dev_entry *deve; 238 239 mutex_lock(&nacl->lun_entry_mutex); 240 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) 241 core_disable_device_list_for_node(deve->se_lun, deve, nacl, tpg); 242 mutex_unlock(&nacl->lun_entry_mutex); 243 } 244 245 void core_update_device_list_access( 246 u64 mapped_lun, 247 bool lun_access_ro, 248 struct se_node_acl *nacl) 249 { 250 struct se_dev_entry *deve; 251 252 mutex_lock(&nacl->lun_entry_mutex); 253 deve = target_nacl_find_deve(nacl, mapped_lun); 254 if (deve) 255 deve->lun_access_ro = lun_access_ro; 256 mutex_unlock(&nacl->lun_entry_mutex); 257 } 258 259 /* 260 * Called with rcu_read_lock or nacl->device_list_lock held. 261 */ 262 struct se_dev_entry *target_nacl_find_deve(struct se_node_acl *nacl, u64 mapped_lun) 263 { 264 struct se_dev_entry *deve; 265 266 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) 267 if (deve->mapped_lun == mapped_lun) 268 return deve; 269 270 return NULL; 271 } 272 EXPORT_SYMBOL(target_nacl_find_deve); 273 274 void target_pr_kref_release(struct kref *kref) 275 { 276 struct se_dev_entry *deve = container_of(kref, struct se_dev_entry, 277 pr_kref); 278 complete(&deve->pr_comp); 279 } 280 281 /* 282 * Establish UA condition on SCSI device - all LUNs 283 */ 284 void target_dev_ua_allocate(struct se_device *dev, u8 asc, u8 ascq) 285 { 286 struct se_dev_entry *se_deve; 287 struct se_lun *lun; 288 289 spin_lock(&dev->se_port_lock); 290 list_for_each_entry(lun, &dev->dev_sep_list, lun_dev_link) { 291 292 spin_lock(&lun->lun_deve_lock); 293 list_for_each_entry(se_deve, &lun->lun_deve_list, lun_link) 294 core_scsi3_ua_allocate(se_deve, asc, ascq); 295 spin_unlock(&lun->lun_deve_lock); 296 } 297 spin_unlock(&dev->se_port_lock); 298 } 299 300 static void 301 target_luns_data_has_changed(struct se_node_acl *nacl, struct se_dev_entry *new, 302 bool skip_new) 303 { 304 struct se_dev_entry *tmp; 305 306 rcu_read_lock(); 307 hlist_for_each_entry_rcu(tmp, &nacl->lun_entry_hlist, link) { 308 if (skip_new && tmp == new) 309 continue; 310 core_scsi3_ua_allocate(tmp, 0x3F, 311 ASCQ_3FH_REPORTED_LUNS_DATA_HAS_CHANGED); 312 } 313 rcu_read_unlock(); 314 } 315 316 int core_enable_device_list_for_node( 317 struct se_lun *lun, 318 struct se_lun_acl *lun_acl, 319 u64 mapped_lun, 320 bool lun_access_ro, 321 struct se_node_acl *nacl, 322 struct se_portal_group *tpg) 323 { 324 struct se_dev_entry *orig, *new; 325 326 new = kzalloc(sizeof(*new), GFP_KERNEL); 327 if (!new) { 328 pr_err("Unable to allocate se_dev_entry memory\n"); 329 return -ENOMEM; 330 } 331 332 spin_lock_init(&new->ua_lock); 333 INIT_LIST_HEAD(&new->ua_list); 334 INIT_LIST_HEAD(&new->lun_link); 335 336 new->mapped_lun = mapped_lun; 337 kref_init(&new->pr_kref); 338 init_completion(&new->pr_comp); 339 340 new->lun_access_ro = lun_access_ro; 341 new->creation_time = get_jiffies_64(); 342 new->attach_count++; 343 344 mutex_lock(&nacl->lun_entry_mutex); 345 orig = target_nacl_find_deve(nacl, mapped_lun); 346 if (orig && orig->se_lun) { 347 struct se_lun *orig_lun = orig->se_lun; 348 349 if (orig_lun != lun) { 350 pr_err("Existing orig->se_lun doesn't match new lun" 351 " for dynamic -> explicit NodeACL conversion:" 352 " %s\n", nacl->initiatorname); 353 mutex_unlock(&nacl->lun_entry_mutex); 354 kfree(new); 355 return -EINVAL; 356 } 357 if (orig->se_lun_acl != NULL) { 358 pr_warn_ratelimited("Detected existing explicit" 359 " se_lun_acl->se_lun_group reference for %s" 360 " mapped_lun: %llu, failing\n", 361 nacl->initiatorname, mapped_lun); 362 mutex_unlock(&nacl->lun_entry_mutex); 363 kfree(new); 364 return -EINVAL; 365 } 366 367 new->se_lun = lun; 368 new->se_lun_acl = lun_acl; 369 hlist_del_rcu(&orig->link); 370 hlist_add_head_rcu(&new->link, &nacl->lun_entry_hlist); 371 mutex_unlock(&nacl->lun_entry_mutex); 372 373 spin_lock(&lun->lun_deve_lock); 374 list_del(&orig->lun_link); 375 list_add_tail(&new->lun_link, &lun->lun_deve_list); 376 spin_unlock(&lun->lun_deve_lock); 377 378 kref_put(&orig->pr_kref, target_pr_kref_release); 379 wait_for_completion(&orig->pr_comp); 380 381 target_luns_data_has_changed(nacl, new, true); 382 kfree_rcu(orig, rcu_head); 383 return 0; 384 } 385 386 new->se_lun = lun; 387 new->se_lun_acl = lun_acl; 388 hlist_add_head_rcu(&new->link, &nacl->lun_entry_hlist); 389 mutex_unlock(&nacl->lun_entry_mutex); 390 391 spin_lock(&lun->lun_deve_lock); 392 list_add_tail(&new->lun_link, &lun->lun_deve_list); 393 spin_unlock(&lun->lun_deve_lock); 394 395 target_luns_data_has_changed(nacl, new, true); 396 return 0; 397 } 398 399 void core_disable_device_list_for_node( 400 struct se_lun *lun, 401 struct se_dev_entry *orig, 402 struct se_node_acl *nacl, 403 struct se_portal_group *tpg) 404 { 405 /* 406 * rcu_dereference_raw protected by se_lun->lun_group symlink 407 * reference to se_device->dev_group. 408 */ 409 struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev); 410 411 lockdep_assert_held(&nacl->lun_entry_mutex); 412 413 /* 414 * If the MappedLUN entry is being disabled, the entry in 415 * lun->lun_deve_list must be removed now before clearing the 416 * struct se_dev_entry pointers below as logic in 417 * core_alua_do_transition_tg_pt() depends on these being present. 418 * 419 * deve->se_lun_acl will be NULL for demo-mode created LUNs 420 * that have not been explicitly converted to MappedLUNs -> 421 * struct se_lun_acl, but we remove deve->lun_link from 422 * lun->lun_deve_list. This also means that active UAs and 423 * NodeACL context specific PR metadata for demo-mode 424 * MappedLUN *deve will be released below.. 425 */ 426 spin_lock(&lun->lun_deve_lock); 427 list_del(&orig->lun_link); 428 spin_unlock(&lun->lun_deve_lock); 429 /* 430 * Disable struct se_dev_entry LUN ACL mapping 431 */ 432 core_scsi3_ua_release_all(orig); 433 434 hlist_del_rcu(&orig->link); 435 clear_bit(DEF_PR_REG_ACTIVE, &orig->deve_flags); 436 orig->lun_access_ro = false; 437 orig->creation_time = 0; 438 orig->attach_count--; 439 /* 440 * Before firing off RCU callback, wait for any in process SPEC_I_PT=1 441 * or REGISTER_AND_MOVE PR operation to complete. 442 */ 443 kref_put(&orig->pr_kref, target_pr_kref_release); 444 wait_for_completion(&orig->pr_comp); 445 446 kfree_rcu(orig, rcu_head); 447 448 core_scsi3_free_pr_reg_from_nacl(dev, nacl); 449 target_luns_data_has_changed(nacl, NULL, false); 450 } 451 452 /* core_clear_lun_from_tpg(): 453 * 454 * 455 */ 456 void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg) 457 { 458 struct se_node_acl *nacl; 459 struct se_dev_entry *deve; 460 461 mutex_lock(&tpg->acl_node_mutex); 462 list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) { 463 464 mutex_lock(&nacl->lun_entry_mutex); 465 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) { 466 if (lun != deve->se_lun) 467 continue; 468 469 core_disable_device_list_for_node(lun, deve, nacl, tpg); 470 } 471 mutex_unlock(&nacl->lun_entry_mutex); 472 } 473 mutex_unlock(&tpg->acl_node_mutex); 474 } 475 476 static void se_release_vpd_for_dev(struct se_device *dev) 477 { 478 struct t10_vpd *vpd, *vpd_tmp; 479 480 spin_lock(&dev->t10_wwn.t10_vpd_lock); 481 list_for_each_entry_safe(vpd, vpd_tmp, 482 &dev->t10_wwn.t10_vpd_list, vpd_list) { 483 list_del(&vpd->vpd_list); 484 kfree(vpd); 485 } 486 spin_unlock(&dev->t10_wwn.t10_vpd_lock); 487 } 488 489 static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size) 490 { 491 u32 aligned_max_sectors; 492 u32 alignment; 493 /* 494 * Limit max_sectors to a PAGE_SIZE aligned value for modern 495 * transport_allocate_data_tasks() operation. 496 */ 497 alignment = max(1ul, PAGE_SIZE / block_size); 498 aligned_max_sectors = rounddown(max_sectors, alignment); 499 500 if (max_sectors != aligned_max_sectors) 501 pr_info("Rounding down aligned max_sectors from %u to %u\n", 502 max_sectors, aligned_max_sectors); 503 504 return aligned_max_sectors; 505 } 506 507 int core_dev_add_lun( 508 struct se_portal_group *tpg, 509 struct se_device *dev, 510 struct se_lun *lun) 511 { 512 int rc; 513 514 rc = core_tpg_add_lun(tpg, lun, false, dev); 515 if (rc < 0) 516 return rc; 517 518 pr_debug("%s_TPG[%u]_LUN[%llu] - Activated %s Logical Unit from" 519 " CORE HBA: %u\n", tpg->se_tpg_tfo->fabric_name, 520 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, 521 tpg->se_tpg_tfo->fabric_name, dev->se_hba->hba_id); 522 /* 523 * Update LUN maps for dynamically added initiators when 524 * generate_node_acl is enabled. 525 */ 526 if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) { 527 struct se_node_acl *acl; 528 529 mutex_lock(&tpg->acl_node_mutex); 530 list_for_each_entry(acl, &tpg->acl_node_list, acl_list) { 531 if (acl->dynamic_node_acl && 532 (!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only || 533 !tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) { 534 core_tpg_add_node_to_devs(acl, tpg, lun); 535 } 536 } 537 mutex_unlock(&tpg->acl_node_mutex); 538 } 539 540 return 0; 541 } 542 543 /* core_dev_del_lun(): 544 * 545 * 546 */ 547 void core_dev_del_lun( 548 struct se_portal_group *tpg, 549 struct se_lun *lun) 550 { 551 pr_debug("%s_TPG[%u]_LUN[%llu] - Deactivating %s Logical Unit from" 552 " device object\n", tpg->se_tpg_tfo->fabric_name, 553 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, 554 tpg->se_tpg_tfo->fabric_name); 555 556 core_tpg_remove_lun(tpg, lun); 557 } 558 559 struct se_lun_acl *core_dev_init_initiator_node_lun_acl( 560 struct se_portal_group *tpg, 561 struct se_node_acl *nacl, 562 u64 mapped_lun, 563 int *ret) 564 { 565 struct se_lun_acl *lacl; 566 567 if (strlen(nacl->initiatorname) >= TRANSPORT_IQN_LEN) { 568 pr_err("%s InitiatorName exceeds maximum size.\n", 569 tpg->se_tpg_tfo->fabric_name); 570 *ret = -EOVERFLOW; 571 return NULL; 572 } 573 lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL); 574 if (!lacl) { 575 pr_err("Unable to allocate memory for struct se_lun_acl.\n"); 576 *ret = -ENOMEM; 577 return NULL; 578 } 579 580 lacl->mapped_lun = mapped_lun; 581 lacl->se_lun_nacl = nacl; 582 583 return lacl; 584 } 585 586 int core_dev_add_initiator_node_lun_acl( 587 struct se_portal_group *tpg, 588 struct se_lun_acl *lacl, 589 struct se_lun *lun, 590 bool lun_access_ro) 591 { 592 struct se_node_acl *nacl = lacl->se_lun_nacl; 593 /* 594 * rcu_dereference_raw protected by se_lun->lun_group symlink 595 * reference to se_device->dev_group. 596 */ 597 struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev); 598 599 if (!nacl) 600 return -EINVAL; 601 602 if (lun->lun_access_ro) 603 lun_access_ro = true; 604 605 lacl->se_lun = lun; 606 607 if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun, 608 lun_access_ro, nacl, tpg) < 0) 609 return -EINVAL; 610 611 pr_debug("%s_TPG[%hu]_LUN[%llu->%llu] - Added %s ACL for " 612 " InitiatorNode: %s\n", tpg->se_tpg_tfo->fabric_name, 613 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, lacl->mapped_lun, 614 lun_access_ro ? "RO" : "RW", 615 nacl->initiatorname); 616 /* 617 * Check to see if there are any existing persistent reservation APTPL 618 * pre-registrations that need to be enabled for this LUN ACL.. 619 */ 620 core_scsi3_check_aptpl_registration(dev, tpg, lun, nacl, 621 lacl->mapped_lun); 622 return 0; 623 } 624 625 int core_dev_del_initiator_node_lun_acl( 626 struct se_lun *lun, 627 struct se_lun_acl *lacl) 628 { 629 struct se_portal_group *tpg = lun->lun_tpg; 630 struct se_node_acl *nacl; 631 struct se_dev_entry *deve; 632 633 nacl = lacl->se_lun_nacl; 634 if (!nacl) 635 return -EINVAL; 636 637 mutex_lock(&nacl->lun_entry_mutex); 638 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 639 if (deve) 640 core_disable_device_list_for_node(lun, deve, nacl, tpg); 641 mutex_unlock(&nacl->lun_entry_mutex); 642 643 pr_debug("%s_TPG[%hu]_LUN[%llu] - Removed ACL for" 644 " InitiatorNode: %s Mapped LUN: %llu\n", 645 tpg->se_tpg_tfo->fabric_name, 646 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, 647 nacl->initiatorname, lacl->mapped_lun); 648 649 return 0; 650 } 651 652 void core_dev_free_initiator_node_lun_acl( 653 struct se_portal_group *tpg, 654 struct se_lun_acl *lacl) 655 { 656 pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s" 657 " Mapped LUN: %llu\n", tpg->se_tpg_tfo->fabric_name, 658 tpg->se_tpg_tfo->tpg_get_tag(tpg), 659 tpg->se_tpg_tfo->fabric_name, 660 lacl->se_lun_nacl->initiatorname, lacl->mapped_lun); 661 662 kfree(lacl); 663 } 664 665 static void scsi_dump_inquiry(struct se_device *dev) 666 { 667 struct t10_wwn *wwn = &dev->t10_wwn; 668 int device_type = dev->transport->get_device_type(dev); 669 670 /* 671 * Print Linux/SCSI style INQUIRY formatting to the kernel ring buffer 672 */ 673 pr_debug(" Vendor: %-" __stringify(INQUIRY_VENDOR_LEN) "s\n", 674 wwn->vendor); 675 pr_debug(" Model: %-" __stringify(INQUIRY_MODEL_LEN) "s\n", 676 wwn->model); 677 pr_debug(" Revision: %-" __stringify(INQUIRY_REVISION_LEN) "s\n", 678 wwn->revision); 679 pr_debug(" Type: %s ", scsi_device_type(device_type)); 680 } 681 682 struct se_device *target_alloc_device(struct se_hba *hba, const char *name) 683 { 684 struct se_device *dev; 685 struct se_lun *xcopy_lun; 686 int i; 687 688 dev = hba->backend->ops->alloc_device(hba, name); 689 if (!dev) 690 return NULL; 691 692 dev->queues = kcalloc(nr_cpu_ids, sizeof(*dev->queues), GFP_KERNEL); 693 if (!dev->queues) { 694 hba->backend->ops->free_device(dev); 695 return NULL; 696 } 697 698 dev->queue_cnt = nr_cpu_ids; 699 for (i = 0; i < dev->queue_cnt; i++) { 700 struct se_device_queue *q; 701 702 q = &dev->queues[i]; 703 INIT_LIST_HEAD(&q->state_list); 704 spin_lock_init(&q->lock); 705 706 init_llist_head(&q->sq.cmd_list); 707 INIT_WORK(&q->sq.work, target_queued_submit_work); 708 } 709 710 dev->se_hba = hba; 711 dev->transport = hba->backend->ops; 712 dev->transport_flags = dev->transport->transport_flags_default; 713 dev->prot_length = sizeof(struct t10_pi_tuple); 714 dev->hba_index = hba->hba_index; 715 716 INIT_LIST_HEAD(&dev->dev_sep_list); 717 INIT_LIST_HEAD(&dev->dev_tmr_list); 718 INIT_LIST_HEAD(&dev->delayed_cmd_list); 719 INIT_LIST_HEAD(&dev->qf_cmd_list); 720 spin_lock_init(&dev->delayed_cmd_lock); 721 spin_lock_init(&dev->dev_reservation_lock); 722 spin_lock_init(&dev->se_port_lock); 723 spin_lock_init(&dev->se_tmr_lock); 724 spin_lock_init(&dev->qf_cmd_lock); 725 sema_init(&dev->caw_sem, 1); 726 INIT_LIST_HEAD(&dev->t10_wwn.t10_vpd_list); 727 spin_lock_init(&dev->t10_wwn.t10_vpd_lock); 728 INIT_LIST_HEAD(&dev->t10_pr.registration_list); 729 INIT_LIST_HEAD(&dev->t10_pr.aptpl_reg_list); 730 spin_lock_init(&dev->t10_pr.registration_lock); 731 spin_lock_init(&dev->t10_pr.aptpl_reg_lock); 732 INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list); 733 spin_lock_init(&dev->t10_alua.tg_pt_gps_lock); 734 INIT_LIST_HEAD(&dev->t10_alua.lba_map_list); 735 spin_lock_init(&dev->t10_alua.lba_map_lock); 736 737 INIT_WORK(&dev->delayed_cmd_work, target_do_delayed_work); 738 mutex_init(&dev->lun_reset_mutex); 739 740 dev->t10_wwn.t10_dev = dev; 741 /* 742 * Use OpenFabrics IEEE Company ID: 00 14 05 743 */ 744 dev->t10_wwn.company_id = 0x001405; 745 746 dev->t10_alua.t10_dev = dev; 747 748 dev->dev_attrib.da_dev = dev; 749 dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS; 750 dev->dev_attrib.emulate_dpo = 1; 751 dev->dev_attrib.emulate_fua_write = 1; 752 dev->dev_attrib.emulate_fua_read = 1; 753 dev->dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE; 754 dev->dev_attrib.emulate_ua_intlck_ctrl = TARGET_UA_INTLCK_CTRL_CLEAR; 755 dev->dev_attrib.emulate_tas = DA_EMULATE_TAS; 756 dev->dev_attrib.emulate_tpu = DA_EMULATE_TPU; 757 dev->dev_attrib.emulate_tpws = DA_EMULATE_TPWS; 758 dev->dev_attrib.emulate_caw = DA_EMULATE_CAW; 759 dev->dev_attrib.emulate_3pc = DA_EMULATE_3PC; 760 dev->dev_attrib.emulate_pr = DA_EMULATE_PR; 761 dev->dev_attrib.emulate_rsoc = DA_EMULATE_RSOC; 762 dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE0_PROT; 763 dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS; 764 dev->dev_attrib.force_pr_aptpl = DA_FORCE_PR_APTPL; 765 dev->dev_attrib.is_nonrot = DA_IS_NONROT; 766 dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD; 767 dev->dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT; 768 dev->dev_attrib.max_unmap_block_desc_count = 769 DA_MAX_UNMAP_BLOCK_DESC_COUNT; 770 dev->dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT; 771 dev->dev_attrib.unmap_granularity_alignment = 772 DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT; 773 dev->dev_attrib.unmap_zeroes_data = 774 DA_UNMAP_ZEROES_DATA_DEFAULT; 775 dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN; 776 dev->dev_attrib.submit_type = TARGET_FABRIC_DEFAULT_SUBMIT; 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