1155 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*******************************************************************************3 * Filename: target_core_device.c (based on iscsi_target_device.c)4 *5 * This file contains the TCM Virtual Device and Disk Transport6 * 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 39static DEFINE_MUTEX(device_mutex);40static DEFINE_IDR(devices_idr);41 42static struct se_hba *lun0_hba;43/* not static, needed by tpg.c */44struct se_device *g_lun0_dev;45 46sense_reason_t47transport_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 }89out_unlock:90 rcu_read_unlock();91 92 if (!se_lun) {93 /*94 * Use the se_portal_group->tpg_virt_lun0 to allow for95 * REPORT_LUNS, et al to be returned when no active96 * 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 0109 */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 that124 * must drop to zero (including initial reference) before this se_lun125 * pointer can be kfree_rcu() by the final se_lun->lun_group put via126 * target_core_fabric_configfs.c:target_fabric_port_release127 */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}140EXPORT_SYMBOL(transport_lookup_cmd_lun);141 142int 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 }165out_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}181EXPORT_SYMBOL(transport_lookup_tmr_lun);182 183bool 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}196EXPORT_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_kref201 * when a matching rtpi is found.202 */203struct 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 233void 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 245void 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 */262struct 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}272EXPORT_SYMBOL(target_nacl_find_deve);273 274void 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 LUNs283 */284void 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 300static void301target_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 316int 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 399void 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 symlink407 * 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 in415 * lun->lun_deve_list must be removed now before clearing the416 * struct se_dev_entry pointers below as logic in417 * core_alua_do_transition_tg_pt() depends on these being present.418 *419 * deve->se_lun_acl will be NULL for demo-mode created LUNs420 * that have not been explicitly converted to MappedLUNs ->421 * struct se_lun_acl, but we remove deve->lun_link from422 * lun->lun_deve_list. This also means that active UAs and423 * NodeACL context specific PR metadata for demo-mode424 * 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 mapping431 */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=1441 * 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 */456void 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 476static 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 489static 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 modern495 * 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 507int 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 when524 * 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 */547void 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 559struct 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 586int 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 symlink595 * 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 APTPL618 * 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 625int 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 652void 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 665static 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 buffer672 */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 682struct 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 05743 */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 yes798 * configure the UNMAP parameters.799 */800bool 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}819EXPORT_SYMBOL(target_configure_unmap_from_queue);820 821/*822 * Convert from blocksize advertised to the initiator to the 512 byte823 * units unconditionally used by the Linux block layer.824 */825sector_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}838EXPORT_SYMBOL(target_to_linux_sector);839 840struct devices_idr_iter {841 int (*fn)(struct se_device *dev, void *data);842 void *data;843};844 845static 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 used855 * by backend modules during configuration. We do not want856 * 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 devices876 * @fn: iterator function877 * @data: pointer to data that will be passed to fn878 *879 * fn must return 0 to continue looping over devices. non-zero will break880 * from the loop and return that value to the caller.881 */882int 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 894int 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 its907 * configuration.908 */909 mutex_lock(&device_mutex);910 /*911 * Use cyclic to try and avoid collisions with devices912 * 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 transfers939 */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_FULL953 */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 966out_destroy_device:967 dev->transport->destroy_device(dev);968out_free_index:969 mutex_lock(&device_mutex);970 idr_remove(&devices_idr, dev->dev_index);971 mutex_unlock(&device_mutex);972out:973 se_release_vpd_for_dev(dev);974 return ret;975}976 977void 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 1007int 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 1034out_free_se_dev:1035 target_free_device(dev);1036out_free_hba:1037 core_delete_hba(hba);1038 return ret;1039}1040 1041 1042void 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 */1057sense_reason_t1058passthrough_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 everything1067 * 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 to1088 * emulate the response, since tcmu does not have the information1089 * 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 else1109 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 else1117 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}1154EXPORT_SYMBOL(passthrough_parse_cdb);1155