1 /******************************************************************************* 2 * Filename: target_core_transport.c 3 * 4 * This file contains the Generic Target Engine Core. 5 * 6 * Copyright (c) 2002, 2003, 2004, 2005 PyX Technologies, Inc. 7 * Copyright (c) 2005, 2006, 2007 SBE, Inc. 8 * Copyright (c) 2007-2010 Rising Tide Systems 9 * Copyright (c) 2008-2010 Linux-iSCSI.org 10 * 11 * Nicholas A. Bellinger <nab@kernel.org> 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License 24 * along with this program; if not, write to the Free Software 25 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 26 * 27 ******************************************************************************/ 28 29 #include <linux/net.h> 30 #include <linux/delay.h> 31 #include <linux/string.h> 32 #include <linux/timer.h> 33 #include <linux/slab.h> 34 #include <linux/blkdev.h> 35 #include <linux/spinlock.h> 36 #include <linux/kthread.h> 37 #include <linux/in.h> 38 #include <linux/cdrom.h> 39 #include <linux/module.h> 40 #include <linux/ratelimit.h> 41 #include <asm/unaligned.h> 42 #include <net/sock.h> 43 #include <net/tcp.h> 44 #include <scsi/scsi.h> 45 #include <scsi/scsi_cmnd.h> 46 #include <scsi/scsi_tcq.h> 47 48 #include <target/target_core_base.h> 49 #include <target/target_core_backend.h> 50 #include <target/target_core_fabric.h> 51 #include <target/target_core_configfs.h> 52 53 #include "target_core_internal.h" 54 #include "target_core_alua.h" 55 #include "target_core_pr.h" 56 #include "target_core_ua.h" 57 58 static struct workqueue_struct *target_completion_wq; 59 static struct kmem_cache *se_sess_cache; 60 struct kmem_cache *se_ua_cache; 61 struct kmem_cache *t10_pr_reg_cache; 62 struct kmem_cache *t10_alua_lu_gp_cache; 63 struct kmem_cache *t10_alua_lu_gp_mem_cache; 64 struct kmem_cache *t10_alua_tg_pt_gp_cache; 65 struct kmem_cache *t10_alua_tg_pt_gp_mem_cache; 66 67 static void transport_complete_task_attr(struct se_cmd *cmd); 68 static void transport_handle_queue_full(struct se_cmd *cmd, 69 struct se_device *dev); 70 static int transport_generic_get_mem(struct se_cmd *cmd); 71 static int target_get_sess_cmd(struct se_session *, struct se_cmd *, bool); 72 static void transport_put_cmd(struct se_cmd *cmd); 73 static int transport_set_sense_codes(struct se_cmd *cmd, u8 asc, u8 ascq); 74 static void target_complete_ok_work(struct work_struct *work); 75 76 int init_se_kmem_caches(void) 77 { 78 se_sess_cache = kmem_cache_create("se_sess_cache", 79 sizeof(struct se_session), __alignof__(struct se_session), 80 0, NULL); 81 if (!se_sess_cache) { 82 pr_err("kmem_cache_create() for struct se_session" 83 " failed\n"); 84 goto out; 85 } 86 se_ua_cache = kmem_cache_create("se_ua_cache", 87 sizeof(struct se_ua), __alignof__(struct se_ua), 88 0, NULL); 89 if (!se_ua_cache) { 90 pr_err("kmem_cache_create() for struct se_ua failed\n"); 91 goto out_free_sess_cache; 92 } 93 t10_pr_reg_cache = kmem_cache_create("t10_pr_reg_cache", 94 sizeof(struct t10_pr_registration), 95 __alignof__(struct t10_pr_registration), 0, NULL); 96 if (!t10_pr_reg_cache) { 97 pr_err("kmem_cache_create() for struct t10_pr_registration" 98 " failed\n"); 99 goto out_free_ua_cache; 100 } 101 t10_alua_lu_gp_cache = kmem_cache_create("t10_alua_lu_gp_cache", 102 sizeof(struct t10_alua_lu_gp), __alignof__(struct t10_alua_lu_gp), 103 0, NULL); 104 if (!t10_alua_lu_gp_cache) { 105 pr_err("kmem_cache_create() for t10_alua_lu_gp_cache" 106 " failed\n"); 107 goto out_free_pr_reg_cache; 108 } 109 t10_alua_lu_gp_mem_cache = kmem_cache_create("t10_alua_lu_gp_mem_cache", 110 sizeof(struct t10_alua_lu_gp_member), 111 __alignof__(struct t10_alua_lu_gp_member), 0, NULL); 112 if (!t10_alua_lu_gp_mem_cache) { 113 pr_err("kmem_cache_create() for t10_alua_lu_gp_mem_" 114 "cache failed\n"); 115 goto out_free_lu_gp_cache; 116 } 117 t10_alua_tg_pt_gp_cache = kmem_cache_create("t10_alua_tg_pt_gp_cache", 118 sizeof(struct t10_alua_tg_pt_gp), 119 __alignof__(struct t10_alua_tg_pt_gp), 0, NULL); 120 if (!t10_alua_tg_pt_gp_cache) { 121 pr_err("kmem_cache_create() for t10_alua_tg_pt_gp_" 122 "cache failed\n"); 123 goto out_free_lu_gp_mem_cache; 124 } 125 t10_alua_tg_pt_gp_mem_cache = kmem_cache_create( 126 "t10_alua_tg_pt_gp_mem_cache", 127 sizeof(struct t10_alua_tg_pt_gp_member), 128 __alignof__(struct t10_alua_tg_pt_gp_member), 129 0, NULL); 130 if (!t10_alua_tg_pt_gp_mem_cache) { 131 pr_err("kmem_cache_create() for t10_alua_tg_pt_gp_" 132 "mem_t failed\n"); 133 goto out_free_tg_pt_gp_cache; 134 } 135 136 target_completion_wq = alloc_workqueue("target_completion", 137 WQ_MEM_RECLAIM, 0); 138 if (!target_completion_wq) 139 goto out_free_tg_pt_gp_mem_cache; 140 141 return 0; 142 143 out_free_tg_pt_gp_mem_cache: 144 kmem_cache_destroy(t10_alua_tg_pt_gp_mem_cache); 145 out_free_tg_pt_gp_cache: 146 kmem_cache_destroy(t10_alua_tg_pt_gp_cache); 147 out_free_lu_gp_mem_cache: 148 kmem_cache_destroy(t10_alua_lu_gp_mem_cache); 149 out_free_lu_gp_cache: 150 kmem_cache_destroy(t10_alua_lu_gp_cache); 151 out_free_pr_reg_cache: 152 kmem_cache_destroy(t10_pr_reg_cache); 153 out_free_ua_cache: 154 kmem_cache_destroy(se_ua_cache); 155 out_free_sess_cache: 156 kmem_cache_destroy(se_sess_cache); 157 out: 158 return -ENOMEM; 159 } 160 161 void release_se_kmem_caches(void) 162 { 163 destroy_workqueue(target_completion_wq); 164 kmem_cache_destroy(se_sess_cache); 165 kmem_cache_destroy(se_ua_cache); 166 kmem_cache_destroy(t10_pr_reg_cache); 167 kmem_cache_destroy(t10_alua_lu_gp_cache); 168 kmem_cache_destroy(t10_alua_lu_gp_mem_cache); 169 kmem_cache_destroy(t10_alua_tg_pt_gp_cache); 170 kmem_cache_destroy(t10_alua_tg_pt_gp_mem_cache); 171 } 172 173 /* This code ensures unique mib indexes are handed out. */ 174 static DEFINE_SPINLOCK(scsi_mib_index_lock); 175 static u32 scsi_mib_index[SCSI_INDEX_TYPE_MAX]; 176 177 /* 178 * Allocate a new row index for the entry type specified 179 */ 180 u32 scsi_get_new_index(scsi_index_t type) 181 { 182 u32 new_index; 183 184 BUG_ON((type < 0) || (type >= SCSI_INDEX_TYPE_MAX)); 185 186 spin_lock(&scsi_mib_index_lock); 187 new_index = ++scsi_mib_index[type]; 188 spin_unlock(&scsi_mib_index_lock); 189 190 return new_index; 191 } 192 193 void transport_subsystem_check_init(void) 194 { 195 int ret; 196 static int sub_api_initialized; 197 198 if (sub_api_initialized) 199 return; 200 201 ret = request_module("target_core_iblock"); 202 if (ret != 0) 203 pr_err("Unable to load target_core_iblock\n"); 204 205 ret = request_module("target_core_file"); 206 if (ret != 0) 207 pr_err("Unable to load target_core_file\n"); 208 209 ret = request_module("target_core_pscsi"); 210 if (ret != 0) 211 pr_err("Unable to load target_core_pscsi\n"); 212 213 sub_api_initialized = 1; 214 } 215 216 struct se_session *transport_init_session(void) 217 { 218 struct se_session *se_sess; 219 220 se_sess = kmem_cache_zalloc(se_sess_cache, GFP_KERNEL); 221 if (!se_sess) { 222 pr_err("Unable to allocate struct se_session from" 223 " se_sess_cache\n"); 224 return ERR_PTR(-ENOMEM); 225 } 226 INIT_LIST_HEAD(&se_sess->sess_list); 227 INIT_LIST_HEAD(&se_sess->sess_acl_list); 228 INIT_LIST_HEAD(&se_sess->sess_cmd_list); 229 spin_lock_init(&se_sess->sess_cmd_lock); 230 kref_init(&se_sess->sess_kref); 231 232 return se_sess; 233 } 234 EXPORT_SYMBOL(transport_init_session); 235 236 /* 237 * Called with spin_lock_irqsave(&struct se_portal_group->session_lock called. 238 */ 239 void __transport_register_session( 240 struct se_portal_group *se_tpg, 241 struct se_node_acl *se_nacl, 242 struct se_session *se_sess, 243 void *fabric_sess_ptr) 244 { 245 unsigned char buf[PR_REG_ISID_LEN]; 246 247 se_sess->se_tpg = se_tpg; 248 se_sess->fabric_sess_ptr = fabric_sess_ptr; 249 /* 250 * Used by struct se_node_acl's under ConfigFS to locate active se_session-t 251 * 252 * Only set for struct se_session's that will actually be moving I/O. 253 * eg: *NOT* discovery sessions. 254 */ 255 if (se_nacl) { 256 /* 257 * If the fabric module supports an ISID based TransportID, 258 * save this value in binary from the fabric I_T Nexus now. 259 */ 260 if (se_tpg->se_tpg_tfo->sess_get_initiator_sid != NULL) { 261 memset(&buf[0], 0, PR_REG_ISID_LEN); 262 se_tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, 263 &buf[0], PR_REG_ISID_LEN); 264 se_sess->sess_bin_isid = get_unaligned_be64(&buf[0]); 265 } 266 kref_get(&se_nacl->acl_kref); 267 268 spin_lock_irq(&se_nacl->nacl_sess_lock); 269 /* 270 * The se_nacl->nacl_sess pointer will be set to the 271 * last active I_T Nexus for each struct se_node_acl. 272 */ 273 se_nacl->nacl_sess = se_sess; 274 275 list_add_tail(&se_sess->sess_acl_list, 276 &se_nacl->acl_sess_list); 277 spin_unlock_irq(&se_nacl->nacl_sess_lock); 278 } 279 list_add_tail(&se_sess->sess_list, &se_tpg->tpg_sess_list); 280 281 pr_debug("TARGET_CORE[%s]: Registered fabric_sess_ptr: %p\n", 282 se_tpg->se_tpg_tfo->get_fabric_name(), se_sess->fabric_sess_ptr); 283 } 284 EXPORT_SYMBOL(__transport_register_session); 285 286 void transport_register_session( 287 struct se_portal_group *se_tpg, 288 struct se_node_acl *se_nacl, 289 struct se_session *se_sess, 290 void *fabric_sess_ptr) 291 { 292 unsigned long flags; 293 294 spin_lock_irqsave(&se_tpg->session_lock, flags); 295 __transport_register_session(se_tpg, se_nacl, se_sess, fabric_sess_ptr); 296 spin_unlock_irqrestore(&se_tpg->session_lock, flags); 297 } 298 EXPORT_SYMBOL(transport_register_session); 299 300 void target_release_session(struct kref *kref) 301 { 302 struct se_session *se_sess = container_of(kref, 303 struct se_session, sess_kref); 304 struct se_portal_group *se_tpg = se_sess->se_tpg; 305 306 se_tpg->se_tpg_tfo->close_session(se_sess); 307 } 308 309 void target_get_session(struct se_session *se_sess) 310 { 311 kref_get(&se_sess->sess_kref); 312 } 313 EXPORT_SYMBOL(target_get_session); 314 315 void target_put_session(struct se_session *se_sess) 316 { 317 struct se_portal_group *tpg = se_sess->se_tpg; 318 319 if (tpg->se_tpg_tfo->put_session != NULL) { 320 tpg->se_tpg_tfo->put_session(se_sess); 321 return; 322 } 323 kref_put(&se_sess->sess_kref, target_release_session); 324 } 325 EXPORT_SYMBOL(target_put_session); 326 327 static void target_complete_nacl(struct kref *kref) 328 { 329 struct se_node_acl *nacl = container_of(kref, 330 struct se_node_acl, acl_kref); 331 332 complete(&nacl->acl_free_comp); 333 } 334 335 void target_put_nacl(struct se_node_acl *nacl) 336 { 337 kref_put(&nacl->acl_kref, target_complete_nacl); 338 } 339 340 void transport_deregister_session_configfs(struct se_session *se_sess) 341 { 342 struct se_node_acl *se_nacl; 343 unsigned long flags; 344 /* 345 * Used by struct se_node_acl's under ConfigFS to locate active struct se_session 346 */ 347 se_nacl = se_sess->se_node_acl; 348 if (se_nacl) { 349 spin_lock_irqsave(&se_nacl->nacl_sess_lock, flags); 350 if (se_nacl->acl_stop == 0) 351 list_del(&se_sess->sess_acl_list); 352 /* 353 * If the session list is empty, then clear the pointer. 354 * Otherwise, set the struct se_session pointer from the tail 355 * element of the per struct se_node_acl active session list. 356 */ 357 if (list_empty(&se_nacl->acl_sess_list)) 358 se_nacl->nacl_sess = NULL; 359 else { 360 se_nacl->nacl_sess = container_of( 361 se_nacl->acl_sess_list.prev, 362 struct se_session, sess_acl_list); 363 } 364 spin_unlock_irqrestore(&se_nacl->nacl_sess_lock, flags); 365 } 366 } 367 EXPORT_SYMBOL(transport_deregister_session_configfs); 368 369 void transport_free_session(struct se_session *se_sess) 370 { 371 kmem_cache_free(se_sess_cache, se_sess); 372 } 373 EXPORT_SYMBOL(transport_free_session); 374 375 void transport_deregister_session(struct se_session *se_sess) 376 { 377 struct se_portal_group *se_tpg = se_sess->se_tpg; 378 struct target_core_fabric_ops *se_tfo; 379 struct se_node_acl *se_nacl; 380 unsigned long flags; 381 bool comp_nacl = true; 382 383 if (!se_tpg) { 384 transport_free_session(se_sess); 385 return; 386 } 387 se_tfo = se_tpg->se_tpg_tfo; 388 389 spin_lock_irqsave(&se_tpg->session_lock, flags); 390 list_del(&se_sess->sess_list); 391 se_sess->se_tpg = NULL; 392 se_sess->fabric_sess_ptr = NULL; 393 spin_unlock_irqrestore(&se_tpg->session_lock, flags); 394 395 /* 396 * Determine if we need to do extra work for this initiator node's 397 * struct se_node_acl if it had been previously dynamically generated. 398 */ 399 se_nacl = se_sess->se_node_acl; 400 401 spin_lock_irqsave(&se_tpg->acl_node_lock, flags); 402 if (se_nacl && se_nacl->dynamic_node_acl) { 403 if (!se_tfo->tpg_check_demo_mode_cache(se_tpg)) { 404 list_del(&se_nacl->acl_list); 405 se_tpg->num_node_acls--; 406 spin_unlock_irqrestore(&se_tpg->acl_node_lock, flags); 407 core_tpg_wait_for_nacl_pr_ref(se_nacl); 408 core_free_device_list_for_node(se_nacl, se_tpg); 409 se_tfo->tpg_release_fabric_acl(se_tpg, se_nacl); 410 411 comp_nacl = false; 412 spin_lock_irqsave(&se_tpg->acl_node_lock, flags); 413 } 414 } 415 spin_unlock_irqrestore(&se_tpg->acl_node_lock, flags); 416 417 pr_debug("TARGET_CORE[%s]: Deregistered fabric_sess\n", 418 se_tpg->se_tpg_tfo->get_fabric_name()); 419 /* 420 * If last kref is dropping now for an explict NodeACL, awake sleeping 421 * ->acl_free_comp caller to wakeup configfs se_node_acl->acl_group 422 * removal context. 423 */ 424 if (se_nacl && comp_nacl == true) 425 target_put_nacl(se_nacl); 426 427 transport_free_session(se_sess); 428 } 429 EXPORT_SYMBOL(transport_deregister_session); 430 431 /* 432 * Called with cmd->t_state_lock held. 433 */ 434 static void target_remove_from_state_list(struct se_cmd *cmd) 435 { 436 struct se_device *dev = cmd->se_dev; 437 unsigned long flags; 438 439 if (!dev) 440 return; 441 442 if (cmd->transport_state & CMD_T_BUSY) 443 return; 444 445 spin_lock_irqsave(&dev->execute_task_lock, flags); 446 if (cmd->state_active) { 447 list_del(&cmd->state_list); 448 cmd->state_active = false; 449 } 450 spin_unlock_irqrestore(&dev->execute_task_lock, flags); 451 } 452 453 static int transport_cmd_check_stop(struct se_cmd *cmd, bool remove_from_lists) 454 { 455 unsigned long flags; 456 457 spin_lock_irqsave(&cmd->t_state_lock, flags); 458 /* 459 * Determine if IOCTL context caller in requesting the stopping of this 460 * command for LUN shutdown purposes. 461 */ 462 if (cmd->transport_state & CMD_T_LUN_STOP) { 463 pr_debug("%s:%d CMD_T_LUN_STOP for ITT: 0x%08x\n", 464 __func__, __LINE__, cmd->se_tfo->get_task_tag(cmd)); 465 466 cmd->transport_state &= ~CMD_T_ACTIVE; 467 if (remove_from_lists) 468 target_remove_from_state_list(cmd); 469 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 470 471 complete(&cmd->transport_lun_stop_comp); 472 return 1; 473 } 474 475 if (remove_from_lists) { 476 target_remove_from_state_list(cmd); 477 478 /* 479 * Clear struct se_cmd->se_lun before the handoff to FE. 480 */ 481 cmd->se_lun = NULL; 482 } 483 484 /* 485 * Determine if frontend context caller is requesting the stopping of 486 * this command for frontend exceptions. 487 */ 488 if (cmd->transport_state & CMD_T_STOP) { 489 pr_debug("%s:%d CMD_T_STOP for ITT: 0x%08x\n", 490 __func__, __LINE__, 491 cmd->se_tfo->get_task_tag(cmd)); 492 493 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 494 495 complete(&cmd->t_transport_stop_comp); 496 return 1; 497 } 498 499 cmd->transport_state &= ~CMD_T_ACTIVE; 500 if (remove_from_lists) { 501 /* 502 * Some fabric modules like tcm_loop can release 503 * their internally allocated I/O reference now and 504 * struct se_cmd now. 505 * 506 * Fabric modules are expected to return '1' here if the 507 * se_cmd being passed is released at this point, 508 * or zero if not being released. 509 */ 510 if (cmd->se_tfo->check_stop_free != NULL) { 511 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 512 return cmd->se_tfo->check_stop_free(cmd); 513 } 514 } 515 516 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 517 return 0; 518 } 519 520 static int transport_cmd_check_stop_to_fabric(struct se_cmd *cmd) 521 { 522 return transport_cmd_check_stop(cmd, true); 523 } 524 525 static void transport_lun_remove_cmd(struct se_cmd *cmd) 526 { 527 struct se_lun *lun = cmd->se_lun; 528 unsigned long flags; 529 530 if (!lun) 531 return; 532 533 spin_lock_irqsave(&cmd->t_state_lock, flags); 534 if (cmd->transport_state & CMD_T_DEV_ACTIVE) { 535 cmd->transport_state &= ~CMD_T_DEV_ACTIVE; 536 target_remove_from_state_list(cmd); 537 } 538 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 539 540 spin_lock_irqsave(&lun->lun_cmd_lock, flags); 541 if (!list_empty(&cmd->se_lun_node)) 542 list_del_init(&cmd->se_lun_node); 543 spin_unlock_irqrestore(&lun->lun_cmd_lock, flags); 544 } 545 546 void transport_cmd_finish_abort(struct se_cmd *cmd, int remove) 547 { 548 if (!(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) 549 transport_lun_remove_cmd(cmd); 550 551 if (transport_cmd_check_stop_to_fabric(cmd)) 552 return; 553 if (remove) 554 transport_put_cmd(cmd); 555 } 556 557 static void target_complete_failure_work(struct work_struct *work) 558 { 559 struct se_cmd *cmd = container_of(work, struct se_cmd, work); 560 561 transport_generic_request_failure(cmd); 562 } 563 564 /* 565 * Used when asking transport to copy Sense Data from the underlying 566 * Linux/SCSI struct scsi_cmnd 567 */ 568 static unsigned char *transport_get_sense_buffer(struct se_cmd *cmd) 569 { 570 struct se_device *dev = cmd->se_dev; 571 572 WARN_ON(!cmd->se_lun); 573 574 if (!dev) 575 return NULL; 576 577 if (cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) 578 return NULL; 579 580 cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER; 581 582 pr_debug("HBA_[%u]_PLUG[%s]: Requesting sense for SAM STATUS: 0x%02x\n", 583 dev->se_hba->hba_id, dev->transport->name, cmd->scsi_status); 584 return cmd->sense_buffer; 585 } 586 587 void target_complete_cmd(struct se_cmd *cmd, u8 scsi_status) 588 { 589 struct se_device *dev = cmd->se_dev; 590 int success = scsi_status == GOOD; 591 unsigned long flags; 592 593 cmd->scsi_status = scsi_status; 594 595 596 spin_lock_irqsave(&cmd->t_state_lock, flags); 597 cmd->transport_state &= ~CMD_T_BUSY; 598 599 if (dev && dev->transport->transport_complete) { 600 dev->transport->transport_complete(cmd, 601 cmd->t_data_sg, 602 transport_get_sense_buffer(cmd)); 603 if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) 604 success = 1; 605 } 606 607 /* 608 * See if we are waiting to complete for an exception condition. 609 */ 610 if (cmd->transport_state & CMD_T_REQUEST_STOP) { 611 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 612 complete(&cmd->task_stop_comp); 613 return; 614 } 615 616 if (!success) 617 cmd->transport_state |= CMD_T_FAILED; 618 619 /* 620 * Check for case where an explict ABORT_TASK has been received 621 * and transport_wait_for_tasks() will be waiting for completion.. 622 */ 623 if (cmd->transport_state & CMD_T_ABORTED && 624 cmd->transport_state & CMD_T_STOP) { 625 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 626 complete(&cmd->t_transport_stop_comp); 627 return; 628 } else if (cmd->transport_state & CMD_T_FAILED) { 629 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 630 INIT_WORK(&cmd->work, target_complete_failure_work); 631 } else { 632 INIT_WORK(&cmd->work, target_complete_ok_work); 633 } 634 635 cmd->t_state = TRANSPORT_COMPLETE; 636 cmd->transport_state |= (CMD_T_COMPLETE | CMD_T_ACTIVE); 637 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 638 639 queue_work(target_completion_wq, &cmd->work); 640 } 641 EXPORT_SYMBOL(target_complete_cmd); 642 643 static void target_add_to_state_list(struct se_cmd *cmd) 644 { 645 struct se_device *dev = cmd->se_dev; 646 unsigned long flags; 647 648 spin_lock_irqsave(&dev->execute_task_lock, flags); 649 if (!cmd->state_active) { 650 list_add_tail(&cmd->state_list, &dev->state_list); 651 cmd->state_active = true; 652 } 653 spin_unlock_irqrestore(&dev->execute_task_lock, flags); 654 } 655 656 /* 657 * Handle QUEUE_FULL / -EAGAIN and -ENOMEM status 658 */ 659 static void transport_write_pending_qf(struct se_cmd *cmd); 660 static void transport_complete_qf(struct se_cmd *cmd); 661 662 static void target_qf_do_work(struct work_struct *work) 663 { 664 struct se_device *dev = container_of(work, struct se_device, 665 qf_work_queue); 666 LIST_HEAD(qf_cmd_list); 667 struct se_cmd *cmd, *cmd_tmp; 668 669 spin_lock_irq(&dev->qf_cmd_lock); 670 list_splice_init(&dev->qf_cmd_list, &qf_cmd_list); 671 spin_unlock_irq(&dev->qf_cmd_lock); 672 673 list_for_each_entry_safe(cmd, cmd_tmp, &qf_cmd_list, se_qf_node) { 674 list_del(&cmd->se_qf_node); 675 atomic_dec(&dev->dev_qf_count); 676 smp_mb__after_atomic_dec(); 677 678 pr_debug("Processing %s cmd: %p QUEUE_FULL in work queue" 679 " context: %s\n", cmd->se_tfo->get_fabric_name(), cmd, 680 (cmd->t_state == TRANSPORT_COMPLETE_QF_OK) ? "COMPLETE_OK" : 681 (cmd->t_state == TRANSPORT_COMPLETE_QF_WP) ? "WRITE_PENDING" 682 : "UNKNOWN"); 683 684 if (cmd->t_state == TRANSPORT_COMPLETE_QF_WP) 685 transport_write_pending_qf(cmd); 686 else if (cmd->t_state == TRANSPORT_COMPLETE_QF_OK) 687 transport_complete_qf(cmd); 688 } 689 } 690 691 unsigned char *transport_dump_cmd_direction(struct se_cmd *cmd) 692 { 693 switch (cmd->data_direction) { 694 case DMA_NONE: 695 return "NONE"; 696 case DMA_FROM_DEVICE: 697 return "READ"; 698 case DMA_TO_DEVICE: 699 return "WRITE"; 700 case DMA_BIDIRECTIONAL: 701 return "BIDI"; 702 default: 703 break; 704 } 705 706 return "UNKNOWN"; 707 } 708 709 void transport_dump_dev_state( 710 struct se_device *dev, 711 char *b, 712 int *bl) 713 { 714 *bl += sprintf(b + *bl, "Status: "); 715 switch (dev->dev_status) { 716 case TRANSPORT_DEVICE_ACTIVATED: 717 *bl += sprintf(b + *bl, "ACTIVATED"); 718 break; 719 case TRANSPORT_DEVICE_DEACTIVATED: 720 *bl += sprintf(b + *bl, "DEACTIVATED"); 721 break; 722 case TRANSPORT_DEVICE_SHUTDOWN: 723 *bl += sprintf(b + *bl, "SHUTDOWN"); 724 break; 725 case TRANSPORT_DEVICE_OFFLINE_ACTIVATED: 726 case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED: 727 *bl += sprintf(b + *bl, "OFFLINE"); 728 break; 729 default: 730 *bl += sprintf(b + *bl, "UNKNOWN=%d", dev->dev_status); 731 break; 732 } 733 734 *bl += sprintf(b + *bl, " Max Queue Depth: %d", dev->queue_depth); 735 *bl += sprintf(b + *bl, " SectorSize: %u HwMaxSectors: %u\n", 736 dev->se_sub_dev->se_dev_attrib.block_size, 737 dev->se_sub_dev->se_dev_attrib.hw_max_sectors); 738 *bl += sprintf(b + *bl, " "); 739 } 740 741 void transport_dump_vpd_proto_id( 742 struct t10_vpd *vpd, 743 unsigned char *p_buf, 744 int p_buf_len) 745 { 746 unsigned char buf[VPD_TMP_BUF_SIZE]; 747 int len; 748 749 memset(buf, 0, VPD_TMP_BUF_SIZE); 750 len = sprintf(buf, "T10 VPD Protocol Identifier: "); 751 752 switch (vpd->protocol_identifier) { 753 case 0x00: 754 sprintf(buf+len, "Fibre Channel\n"); 755 break; 756 case 0x10: 757 sprintf(buf+len, "Parallel SCSI\n"); 758 break; 759 case 0x20: 760 sprintf(buf+len, "SSA\n"); 761 break; 762 case 0x30: 763 sprintf(buf+len, "IEEE 1394\n"); 764 break; 765 case 0x40: 766 sprintf(buf+len, "SCSI Remote Direct Memory Access" 767 " Protocol\n"); 768 break; 769 case 0x50: 770 sprintf(buf+len, "Internet SCSI (iSCSI)\n"); 771 break; 772 case 0x60: 773 sprintf(buf+len, "SAS Serial SCSI Protocol\n"); 774 break; 775 case 0x70: 776 sprintf(buf+len, "Automation/Drive Interface Transport" 777 " Protocol\n"); 778 break; 779 case 0x80: 780 sprintf(buf+len, "AT Attachment Interface ATA/ATAPI\n"); 781 break; 782 default: 783 sprintf(buf+len, "Unknown 0x%02x\n", 784 vpd->protocol_identifier); 785 break; 786 } 787 788 if (p_buf) 789 strncpy(p_buf, buf, p_buf_len); 790 else 791 pr_debug("%s", buf); 792 } 793 794 void 795 transport_set_vpd_proto_id(struct t10_vpd *vpd, unsigned char *page_83) 796 { 797 /* 798 * Check if the Protocol Identifier Valid (PIV) bit is set.. 799 * 800 * from spc3r23.pdf section 7.5.1 801 */ 802 if (page_83[1] & 0x80) { 803 vpd->protocol_identifier = (page_83[0] & 0xf0); 804 vpd->protocol_identifier_set = 1; 805 transport_dump_vpd_proto_id(vpd, NULL, 0); 806 } 807 } 808 EXPORT_SYMBOL(transport_set_vpd_proto_id); 809 810 int transport_dump_vpd_assoc( 811 struct t10_vpd *vpd, 812 unsigned char *p_buf, 813 int p_buf_len) 814 { 815 unsigned char buf[VPD_TMP_BUF_SIZE]; 816 int ret = 0; 817 int len; 818 819 memset(buf, 0, VPD_TMP_BUF_SIZE); 820 len = sprintf(buf, "T10 VPD Identifier Association: "); 821 822 switch (vpd->association) { 823 case 0x00: 824 sprintf(buf+len, "addressed logical unit\n"); 825 break; 826 case 0x10: 827 sprintf(buf+len, "target port\n"); 828 break; 829 case 0x20: 830 sprintf(buf+len, "SCSI target device\n"); 831 break; 832 default: 833 sprintf(buf+len, "Unknown 0x%02x\n", vpd->association); 834 ret = -EINVAL; 835 break; 836 } 837 838 if (p_buf) 839 strncpy(p_buf, buf, p_buf_len); 840 else 841 pr_debug("%s", buf); 842 843 return ret; 844 } 845 846 int transport_set_vpd_assoc(struct t10_vpd *vpd, unsigned char *page_83) 847 { 848 /* 849 * The VPD identification association.. 850 * 851 * from spc3r23.pdf Section 7.6.3.1 Table 297 852 */ 853 vpd->association = (page_83[1] & 0x30); 854 return transport_dump_vpd_assoc(vpd, NULL, 0); 855 } 856 EXPORT_SYMBOL(transport_set_vpd_assoc); 857 858 int transport_dump_vpd_ident_type( 859 struct t10_vpd *vpd, 860 unsigned char *p_buf, 861 int p_buf_len) 862 { 863 unsigned char buf[VPD_TMP_BUF_SIZE]; 864 int ret = 0; 865 int len; 866 867 memset(buf, 0, VPD_TMP_BUF_SIZE); 868 len = sprintf(buf, "T10 VPD Identifier Type: "); 869 870 switch (vpd->device_identifier_type) { 871 case 0x00: 872 sprintf(buf+len, "Vendor specific\n"); 873 break; 874 case 0x01: 875 sprintf(buf+len, "T10 Vendor ID based\n"); 876 break; 877 case 0x02: 878 sprintf(buf+len, "EUI-64 based\n"); 879 break; 880 case 0x03: 881 sprintf(buf+len, "NAA\n"); 882 break; 883 case 0x04: 884 sprintf(buf+len, "Relative target port identifier\n"); 885 break; 886 case 0x08: 887 sprintf(buf+len, "SCSI name string\n"); 888 break; 889 default: 890 sprintf(buf+len, "Unsupported: 0x%02x\n", 891 vpd->device_identifier_type); 892 ret = -EINVAL; 893 break; 894 } 895 896 if (p_buf) { 897 if (p_buf_len < strlen(buf)+1) 898 return -EINVAL; 899 strncpy(p_buf, buf, p_buf_len); 900 } else { 901 pr_debug("%s", buf); 902 } 903 904 return ret; 905 } 906 907 int transport_set_vpd_ident_type(struct t10_vpd *vpd, unsigned char *page_83) 908 { 909 /* 910 * The VPD identifier type.. 911 * 912 * from spc3r23.pdf Section 7.6.3.1 Table 298 913 */ 914 vpd->device_identifier_type = (page_83[1] & 0x0f); 915 return transport_dump_vpd_ident_type(vpd, NULL, 0); 916 } 917 EXPORT_SYMBOL(transport_set_vpd_ident_type); 918 919 int transport_dump_vpd_ident( 920 struct t10_vpd *vpd, 921 unsigned char *p_buf, 922 int p_buf_len) 923 { 924 unsigned char buf[VPD_TMP_BUF_SIZE]; 925 int ret = 0; 926 927 memset(buf, 0, VPD_TMP_BUF_SIZE); 928 929 switch (vpd->device_identifier_code_set) { 930 case 0x01: /* Binary */ 931 sprintf(buf, "T10 VPD Binary Device Identifier: %s\n", 932 &vpd->device_identifier[0]); 933 break; 934 case 0x02: /* ASCII */ 935 sprintf(buf, "T10 VPD ASCII Device Identifier: %s\n", 936 &vpd->device_identifier[0]); 937 break; 938 case 0x03: /* UTF-8 */ 939 sprintf(buf, "T10 VPD UTF-8 Device Identifier: %s\n", 940 &vpd->device_identifier[0]); 941 break; 942 default: 943 sprintf(buf, "T10 VPD Device Identifier encoding unsupported:" 944 " 0x%02x", vpd->device_identifier_code_set); 945 ret = -EINVAL; 946 break; 947 } 948 949 if (p_buf) 950 strncpy(p_buf, buf, p_buf_len); 951 else 952 pr_debug("%s", buf); 953 954 return ret; 955 } 956 957 int 958 transport_set_vpd_ident(struct t10_vpd *vpd, unsigned char *page_83) 959 { 960 static const char hex_str[] = "0123456789abcdef"; 961 int j = 0, i = 4; /* offset to start of the identifier */ 962 963 /* 964 * The VPD Code Set (encoding) 965 * 966 * from spc3r23.pdf Section 7.6.3.1 Table 296 967 */ 968 vpd->device_identifier_code_set = (page_83[0] & 0x0f); 969 switch (vpd->device_identifier_code_set) { 970 case 0x01: /* Binary */ 971 vpd->device_identifier[j++] = 972 hex_str[vpd->device_identifier_type]; 973 while (i < (4 + page_83[3])) { 974 vpd->device_identifier[j++] = 975 hex_str[(page_83[i] & 0xf0) >> 4]; 976 vpd->device_identifier[j++] = 977 hex_str[page_83[i] & 0x0f]; 978 i++; 979 } 980 break; 981 case 0x02: /* ASCII */ 982 case 0x03: /* UTF-8 */ 983 while (i < (4 + page_83[3])) 984 vpd->device_identifier[j++] = page_83[i++]; 985 break; 986 default: 987 break; 988 } 989 990 return transport_dump_vpd_ident(vpd, NULL, 0); 991 } 992 EXPORT_SYMBOL(transport_set_vpd_ident); 993 994 static void core_setup_task_attr_emulation(struct se_device *dev) 995 { 996 /* 997 * If this device is from Target_Core_Mod/pSCSI, disable the 998 * SAM Task Attribute emulation. 999 * 1000 * This is currently not available in upsream Linux/SCSI Target 1001 * mode code, and is assumed to be disabled while using TCM/pSCSI. 1002 */ 1003 if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) { 1004 dev->dev_task_attr_type = SAM_TASK_ATTR_PASSTHROUGH; 1005 return; 1006 } 1007 1008 dev->dev_task_attr_type = SAM_TASK_ATTR_EMULATED; 1009 pr_debug("%s: Using SAM_TASK_ATTR_EMULATED for SPC: 0x%02x" 1010 " device\n", dev->transport->name, 1011 dev->transport->get_device_rev(dev)); 1012 } 1013 1014 static void scsi_dump_inquiry(struct se_device *dev) 1015 { 1016 struct t10_wwn *wwn = &dev->se_sub_dev->t10_wwn; 1017 char buf[17]; 1018 int i, device_type; 1019 /* 1020 * Print Linux/SCSI style INQUIRY formatting to the kernel ring buffer 1021 */ 1022 for (i = 0; i < 8; i++) 1023 if (wwn->vendor[i] >= 0x20) 1024 buf[i] = wwn->vendor[i]; 1025 else 1026 buf[i] = ' '; 1027 buf[i] = '\0'; 1028 pr_debug(" Vendor: %s\n", buf); 1029 1030 for (i = 0; i < 16; i++) 1031 if (wwn->model[i] >= 0x20) 1032 buf[i] = wwn->model[i]; 1033 else 1034 buf[i] = ' '; 1035 buf[i] = '\0'; 1036 pr_debug(" Model: %s\n", buf); 1037 1038 for (i = 0; i < 4; i++) 1039 if (wwn->revision[i] >= 0x20) 1040 buf[i] = wwn->revision[i]; 1041 else 1042 buf[i] = ' '; 1043 buf[i] = '\0'; 1044 pr_debug(" Revision: %s\n", buf); 1045 1046 device_type = dev->transport->get_device_type(dev); 1047 pr_debug(" Type: %s ", scsi_device_type(device_type)); 1048 pr_debug(" ANSI SCSI revision: %02x\n", 1049 dev->transport->get_device_rev(dev)); 1050 } 1051 1052 struct se_device *transport_add_device_to_core_hba( 1053 struct se_hba *hba, 1054 struct se_subsystem_api *transport, 1055 struct se_subsystem_dev *se_dev, 1056 u32 device_flags, 1057 void *transport_dev, 1058 struct se_dev_limits *dev_limits, 1059 const char *inquiry_prod, 1060 const char *inquiry_rev) 1061 { 1062 int force_pt; 1063 struct se_device *dev; 1064 1065 dev = kzalloc(sizeof(struct se_device), GFP_KERNEL); 1066 if (!dev) { 1067 pr_err("Unable to allocate memory for se_dev_t\n"); 1068 return NULL; 1069 } 1070 1071 dev->dev_flags = device_flags; 1072 dev->dev_status |= TRANSPORT_DEVICE_DEACTIVATED; 1073 dev->dev_ptr = transport_dev; 1074 dev->se_hba = hba; 1075 dev->se_sub_dev = se_dev; 1076 dev->transport = transport; 1077 INIT_LIST_HEAD(&dev->dev_list); 1078 INIT_LIST_HEAD(&dev->dev_sep_list); 1079 INIT_LIST_HEAD(&dev->dev_tmr_list); 1080 INIT_LIST_HEAD(&dev->delayed_cmd_list); 1081 INIT_LIST_HEAD(&dev->state_list); 1082 INIT_LIST_HEAD(&dev->qf_cmd_list); 1083 spin_lock_init(&dev->execute_task_lock); 1084 spin_lock_init(&dev->delayed_cmd_lock); 1085 spin_lock_init(&dev->dev_reservation_lock); 1086 spin_lock_init(&dev->dev_status_lock); 1087 spin_lock_init(&dev->se_port_lock); 1088 spin_lock_init(&dev->se_tmr_lock); 1089 spin_lock_init(&dev->qf_cmd_lock); 1090 atomic_set(&dev->dev_ordered_id, 0); 1091 1092 se_dev_set_default_attribs(dev, dev_limits); 1093 1094 dev->dev_index = scsi_get_new_index(SCSI_DEVICE_INDEX); 1095 dev->creation_time = get_jiffies_64(); 1096 spin_lock_init(&dev->stats_lock); 1097 1098 spin_lock(&hba->device_lock); 1099 list_add_tail(&dev->dev_list, &hba->hba_dev_list); 1100 hba->dev_count++; 1101 spin_unlock(&hba->device_lock); 1102 /* 1103 * Setup the SAM Task Attribute emulation for struct se_device 1104 */ 1105 core_setup_task_attr_emulation(dev); 1106 /* 1107 * Force PR and ALUA passthrough emulation with internal object use. 1108 */ 1109 force_pt = (hba->hba_flags & HBA_FLAGS_INTERNAL_USE); 1110 /* 1111 * Setup the Reservations infrastructure for struct se_device 1112 */ 1113 core_setup_reservations(dev, force_pt); 1114 /* 1115 * Setup the Asymmetric Logical Unit Assignment for struct se_device 1116 */ 1117 if (core_setup_alua(dev, force_pt) < 0) 1118 goto err_dev_list; 1119 1120 /* 1121 * Startup the struct se_device processing thread 1122 */ 1123 dev->tmr_wq = alloc_workqueue("tmr-%s", WQ_MEM_RECLAIM | WQ_UNBOUND, 1, 1124 dev->transport->name); 1125 if (!dev->tmr_wq) { 1126 pr_err("Unable to create tmr workqueue for %s\n", 1127 dev->transport->name); 1128 goto err_dev_list; 1129 } 1130 /* 1131 * Setup work_queue for QUEUE_FULL 1132 */ 1133 INIT_WORK(&dev->qf_work_queue, target_qf_do_work); 1134 /* 1135 * Preload the initial INQUIRY const values if we are doing 1136 * anything virtual (IBLOCK, FILEIO, RAMDISK), but not for TCM/pSCSI 1137 * passthrough because this is being provided by the backend LLD. 1138 * This is required so that transport_get_inquiry() copies these 1139 * originals once back into DEV_T10_WWN(dev) for the virtual device 1140 * setup. 1141 */ 1142 if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV) { 1143 if (!inquiry_prod || !inquiry_rev) { 1144 pr_err("All non TCM/pSCSI plugins require" 1145 " INQUIRY consts\n"); 1146 goto err_wq; 1147 } 1148 1149 strncpy(&dev->se_sub_dev->t10_wwn.vendor[0], "LIO-ORG", 8); 1150 strncpy(&dev->se_sub_dev->t10_wwn.model[0], inquiry_prod, 16); 1151 strncpy(&dev->se_sub_dev->t10_wwn.revision[0], inquiry_rev, 4); 1152 } 1153 scsi_dump_inquiry(dev); 1154 1155 return dev; 1156 1157 err_wq: 1158 destroy_workqueue(dev->tmr_wq); 1159 err_dev_list: 1160 spin_lock(&hba->device_lock); 1161 list_del(&dev->dev_list); 1162 hba->dev_count--; 1163 spin_unlock(&hba->device_lock); 1164 1165 se_release_vpd_for_dev(dev); 1166 1167 kfree(dev); 1168 1169 return NULL; 1170 } 1171 EXPORT_SYMBOL(transport_add_device_to_core_hba); 1172 1173 int target_cmd_size_check(struct se_cmd *cmd, unsigned int size) 1174 { 1175 struct se_device *dev = cmd->se_dev; 1176 1177 if (cmd->unknown_data_length) { 1178 cmd->data_length = size; 1179 } else if (size != cmd->data_length) { 1180 pr_warn("TARGET_CORE[%s]: Expected Transfer Length:" 1181 " %u does not match SCSI CDB Length: %u for SAM Opcode:" 1182 " 0x%02x\n", cmd->se_tfo->get_fabric_name(), 1183 cmd->data_length, size, cmd->t_task_cdb[0]); 1184 1185 if (cmd->data_direction == DMA_TO_DEVICE) { 1186 pr_err("Rejecting underflow/overflow" 1187 " WRITE data\n"); 1188 goto out_invalid_cdb_field; 1189 } 1190 /* 1191 * Reject READ_* or WRITE_* with overflow/underflow for 1192 * type SCF_SCSI_DATA_CDB. 1193 */ 1194 if (dev->se_sub_dev->se_dev_attrib.block_size != 512) { 1195 pr_err("Failing OVERFLOW/UNDERFLOW for LBA op" 1196 " CDB on non 512-byte sector setup subsystem" 1197 " plugin: %s\n", dev->transport->name); 1198 /* Returns CHECK_CONDITION + INVALID_CDB_FIELD */ 1199 goto out_invalid_cdb_field; 1200 } 1201 /* 1202 * For the overflow case keep the existing fabric provided 1203 * ->data_length. Otherwise for the underflow case, reset 1204 * ->data_length to the smaller SCSI expected data transfer 1205 * length. 1206 */ 1207 if (size > cmd->data_length) { 1208 cmd->se_cmd_flags |= SCF_OVERFLOW_BIT; 1209 cmd->residual_count = (size - cmd->data_length); 1210 } else { 1211 cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT; 1212 cmd->residual_count = (cmd->data_length - size); 1213 cmd->data_length = size; 1214 } 1215 } 1216 1217 return 0; 1218 1219 out_invalid_cdb_field: 1220 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1221 cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD; 1222 return -EINVAL; 1223 } 1224 1225 /* 1226 * Used by fabric modules containing a local struct se_cmd within their 1227 * fabric dependent per I/O descriptor. 1228 */ 1229 void transport_init_se_cmd( 1230 struct se_cmd *cmd, 1231 struct target_core_fabric_ops *tfo, 1232 struct se_session *se_sess, 1233 u32 data_length, 1234 int data_direction, 1235 int task_attr, 1236 unsigned char *sense_buffer) 1237 { 1238 INIT_LIST_HEAD(&cmd->se_lun_node); 1239 INIT_LIST_HEAD(&cmd->se_delayed_node); 1240 INIT_LIST_HEAD(&cmd->se_qf_node); 1241 INIT_LIST_HEAD(&cmd->se_cmd_list); 1242 INIT_LIST_HEAD(&cmd->state_list); 1243 init_completion(&cmd->transport_lun_fe_stop_comp); 1244 init_completion(&cmd->transport_lun_stop_comp); 1245 init_completion(&cmd->t_transport_stop_comp); 1246 init_completion(&cmd->cmd_wait_comp); 1247 init_completion(&cmd->task_stop_comp); 1248 spin_lock_init(&cmd->t_state_lock); 1249 cmd->transport_state = CMD_T_DEV_ACTIVE; 1250 1251 cmd->se_tfo = tfo; 1252 cmd->se_sess = se_sess; 1253 cmd->data_length = data_length; 1254 cmd->data_direction = data_direction; 1255 cmd->sam_task_attr = task_attr; 1256 cmd->sense_buffer = sense_buffer; 1257 1258 cmd->state_active = false; 1259 } 1260 EXPORT_SYMBOL(transport_init_se_cmd); 1261 1262 static int transport_check_alloc_task_attr(struct se_cmd *cmd) 1263 { 1264 /* 1265 * Check if SAM Task Attribute emulation is enabled for this 1266 * struct se_device storage object 1267 */ 1268 if (cmd->se_dev->dev_task_attr_type != SAM_TASK_ATTR_EMULATED) 1269 return 0; 1270 1271 if (cmd->sam_task_attr == MSG_ACA_TAG) { 1272 pr_debug("SAM Task Attribute ACA" 1273 " emulation is not supported\n"); 1274 return -EINVAL; 1275 } 1276 /* 1277 * Used to determine when ORDERED commands should go from 1278 * Dormant to Active status. 1279 */ 1280 cmd->se_ordered_id = atomic_inc_return(&cmd->se_dev->dev_ordered_id); 1281 smp_mb__after_atomic_inc(); 1282 pr_debug("Allocated se_ordered_id: %u for Task Attr: 0x%02x on %s\n", 1283 cmd->se_ordered_id, cmd->sam_task_attr, 1284 cmd->se_dev->transport->name); 1285 return 0; 1286 } 1287 1288 /* target_setup_cmd_from_cdb(): 1289 * 1290 * Called from fabric RX Thread. 1291 */ 1292 int target_setup_cmd_from_cdb( 1293 struct se_cmd *cmd, 1294 unsigned char *cdb) 1295 { 1296 struct se_subsystem_dev *su_dev = cmd->se_dev->se_sub_dev; 1297 u32 pr_reg_type = 0; 1298 u8 alua_ascq = 0; 1299 unsigned long flags; 1300 int ret; 1301 1302 /* 1303 * Ensure that the received CDB is less than the max (252 + 8) bytes 1304 * for VARIABLE_LENGTH_CMD 1305 */ 1306 if (scsi_command_size(cdb) > SCSI_MAX_VARLEN_CDB_SIZE) { 1307 pr_err("Received SCSI CDB with command_size: %d that" 1308 " exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n", 1309 scsi_command_size(cdb), SCSI_MAX_VARLEN_CDB_SIZE); 1310 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1311 cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD; 1312 return -EINVAL; 1313 } 1314 /* 1315 * If the received CDB is larger than TCM_MAX_COMMAND_SIZE, 1316 * allocate the additional extended CDB buffer now.. Otherwise 1317 * setup the pointer from __t_task_cdb to t_task_cdb. 1318 */ 1319 if (scsi_command_size(cdb) > sizeof(cmd->__t_task_cdb)) { 1320 cmd->t_task_cdb = kzalloc(scsi_command_size(cdb), 1321 GFP_KERNEL); 1322 if (!cmd->t_task_cdb) { 1323 pr_err("Unable to allocate cmd->t_task_cdb" 1324 " %u > sizeof(cmd->__t_task_cdb): %lu ops\n", 1325 scsi_command_size(cdb), 1326 (unsigned long)sizeof(cmd->__t_task_cdb)); 1327 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1328 cmd->scsi_sense_reason = 1329 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1330 return -ENOMEM; 1331 } 1332 } else 1333 cmd->t_task_cdb = &cmd->__t_task_cdb[0]; 1334 /* 1335 * Copy the original CDB into cmd-> 1336 */ 1337 memcpy(cmd->t_task_cdb, cdb, scsi_command_size(cdb)); 1338 1339 /* 1340 * Check for an existing UNIT ATTENTION condition 1341 */ 1342 if (core_scsi3_ua_check(cmd, cdb) < 0) { 1343 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1344 cmd->scsi_sense_reason = TCM_CHECK_CONDITION_UNIT_ATTENTION; 1345 return -EINVAL; 1346 } 1347 1348 ret = su_dev->t10_alua.alua_state_check(cmd, cdb, &alua_ascq); 1349 if (ret != 0) { 1350 /* 1351 * Set SCSI additional sense code (ASC) to 'LUN Not Accessible'; 1352 * The ALUA additional sense code qualifier (ASCQ) is determined 1353 * by the ALUA primary or secondary access state.. 1354 */ 1355 if (ret > 0) { 1356 pr_debug("[%s]: ALUA TG Port not available, " 1357 "SenseKey: NOT_READY, ASC/ASCQ: " 1358 "0x04/0x%02x\n", 1359 cmd->se_tfo->get_fabric_name(), alua_ascq); 1360 1361 transport_set_sense_codes(cmd, 0x04, alua_ascq); 1362 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1363 cmd->scsi_sense_reason = TCM_CHECK_CONDITION_NOT_READY; 1364 return -EINVAL; 1365 } 1366 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1367 cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD; 1368 return -EINVAL; 1369 } 1370 1371 /* 1372 * Check status for SPC-3 Persistent Reservations 1373 */ 1374 if (su_dev->t10_pr.pr_ops.t10_reservation_check(cmd, &pr_reg_type)) { 1375 if (su_dev->t10_pr.pr_ops.t10_seq_non_holder( 1376 cmd, cdb, pr_reg_type) != 0) { 1377 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1378 cmd->se_cmd_flags |= SCF_SCSI_RESERVATION_CONFLICT; 1379 cmd->scsi_status = SAM_STAT_RESERVATION_CONFLICT; 1380 cmd->scsi_sense_reason = TCM_RESERVATION_CONFLICT; 1381 return -EBUSY; 1382 } 1383 /* 1384 * This means the CDB is allowed for the SCSI Initiator port 1385 * when said port is *NOT* holding the legacy SPC-2 or 1386 * SPC-3 Persistent Reservation. 1387 */ 1388 } 1389 1390 ret = cmd->se_dev->transport->parse_cdb(cmd); 1391 if (ret < 0) 1392 return ret; 1393 1394 spin_lock_irqsave(&cmd->t_state_lock, flags); 1395 cmd->se_cmd_flags |= SCF_SUPPORTED_SAM_OPCODE; 1396 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 1397 1398 /* 1399 * Check for SAM Task Attribute Emulation 1400 */ 1401 if (transport_check_alloc_task_attr(cmd) < 0) { 1402 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1403 cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD; 1404 return -EINVAL; 1405 } 1406 spin_lock(&cmd->se_lun->lun_sep_lock); 1407 if (cmd->se_lun->lun_sep) 1408 cmd->se_lun->lun_sep->sep_stats.cmd_pdus++; 1409 spin_unlock(&cmd->se_lun->lun_sep_lock); 1410 return 0; 1411 } 1412 EXPORT_SYMBOL(target_setup_cmd_from_cdb); 1413 1414 /* 1415 * Used by fabric module frontends to queue tasks directly. 1416 * Many only be used from process context only 1417 */ 1418 int transport_handle_cdb_direct( 1419 struct se_cmd *cmd) 1420 { 1421 int ret; 1422 1423 if (!cmd->se_lun) { 1424 dump_stack(); 1425 pr_err("cmd->se_lun is NULL\n"); 1426 return -EINVAL; 1427 } 1428 if (in_interrupt()) { 1429 dump_stack(); 1430 pr_err("transport_generic_handle_cdb cannot be called" 1431 " from interrupt context\n"); 1432 return -EINVAL; 1433 } 1434 /* 1435 * Set TRANSPORT_NEW_CMD state and CMD_T_ACTIVE to ensure that 1436 * outstanding descriptors are handled correctly during shutdown via 1437 * transport_wait_for_tasks() 1438 * 1439 * Also, we don't take cmd->t_state_lock here as we only expect 1440 * this to be called for initial descriptor submission. 1441 */ 1442 cmd->t_state = TRANSPORT_NEW_CMD; 1443 cmd->transport_state |= CMD_T_ACTIVE; 1444 1445 /* 1446 * transport_generic_new_cmd() is already handling QUEUE_FULL, 1447 * so follow TRANSPORT_NEW_CMD processing thread context usage 1448 * and call transport_generic_request_failure() if necessary.. 1449 */ 1450 ret = transport_generic_new_cmd(cmd); 1451 if (ret < 0) 1452 transport_generic_request_failure(cmd); 1453 1454 return 0; 1455 } 1456 EXPORT_SYMBOL(transport_handle_cdb_direct); 1457 1458 /* 1459 * target_submit_cmd_map_sgls - lookup unpacked lun and submit uninitialized 1460 * se_cmd + use pre-allocated SGL memory. 1461 * 1462 * @se_cmd: command descriptor to submit 1463 * @se_sess: associated se_sess for endpoint 1464 * @cdb: pointer to SCSI CDB 1465 * @sense: pointer to SCSI sense buffer 1466 * @unpacked_lun: unpacked LUN to reference for struct se_lun 1467 * @data_length: fabric expected data transfer length 1468 * @task_addr: SAM task attribute 1469 * @data_dir: DMA data direction 1470 * @flags: flags for command submission from target_sc_flags_tables 1471 * @sgl: struct scatterlist memory for unidirectional mapping 1472 * @sgl_count: scatterlist count for unidirectional mapping 1473 * @sgl_bidi: struct scatterlist memory for bidirectional READ mapping 1474 * @sgl_bidi_count: scatterlist count for bidirectional READ mapping 1475 * 1476 * Returns non zero to signal active I/O shutdown failure. All other 1477 * setup exceptions will be returned as a SCSI CHECK_CONDITION response, 1478 * but still return zero here. 1479 * 1480 * This may only be called from process context, and also currently 1481 * assumes internal allocation of fabric payload buffer by target-core. 1482 */ 1483 int target_submit_cmd_map_sgls(struct se_cmd *se_cmd, struct se_session *se_sess, 1484 unsigned char *cdb, unsigned char *sense, u32 unpacked_lun, 1485 u32 data_length, int task_attr, int data_dir, int flags, 1486 struct scatterlist *sgl, u32 sgl_count, 1487 struct scatterlist *sgl_bidi, u32 sgl_bidi_count) 1488 { 1489 struct se_portal_group *se_tpg; 1490 int rc; 1491 1492 se_tpg = se_sess->se_tpg; 1493 BUG_ON(!se_tpg); 1494 BUG_ON(se_cmd->se_tfo || se_cmd->se_sess); 1495 BUG_ON(in_interrupt()); 1496 /* 1497 * Initialize se_cmd for target operation. From this point 1498 * exceptions are handled by sending exception status via 1499 * target_core_fabric_ops->queue_status() callback 1500 */ 1501 transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 1502 data_length, data_dir, task_attr, sense); 1503 if (flags & TARGET_SCF_UNKNOWN_SIZE) 1504 se_cmd->unknown_data_length = 1; 1505 /* 1506 * Obtain struct se_cmd->cmd_kref reference and add new cmd to 1507 * se_sess->sess_cmd_list. A second kref_get here is necessary 1508 * for fabrics using TARGET_SCF_ACK_KREF that expect a second 1509 * kref_put() to happen during fabric packet acknowledgement. 1510 */ 1511 rc = target_get_sess_cmd(se_sess, se_cmd, (flags & TARGET_SCF_ACK_KREF)); 1512 if (rc) 1513 return rc; 1514 /* 1515 * Signal bidirectional data payloads to target-core 1516 */ 1517 if (flags & TARGET_SCF_BIDI_OP) 1518 se_cmd->se_cmd_flags |= SCF_BIDI; 1519 /* 1520 * Locate se_lun pointer and attach it to struct se_cmd 1521 */ 1522 if (transport_lookup_cmd_lun(se_cmd, unpacked_lun) < 0) { 1523 transport_send_check_condition_and_sense(se_cmd, 1524 se_cmd->scsi_sense_reason, 0); 1525 target_put_sess_cmd(se_sess, se_cmd); 1526 return 0; 1527 } 1528 1529 rc = target_setup_cmd_from_cdb(se_cmd, cdb); 1530 if (rc != 0) { 1531 transport_generic_request_failure(se_cmd); 1532 return 0; 1533 } 1534 /* 1535 * When a non zero sgl_count has been passed perform SGL passthrough 1536 * mapping for pre-allocated fabric memory instead of having target 1537 * core perform an internal SGL allocation.. 1538 */ 1539 if (sgl_count != 0) { 1540 BUG_ON(!sgl); 1541 1542 /* 1543 * A work-around for tcm_loop as some userspace code via 1544 * scsi-generic do not memset their associated read buffers, 1545 * so go ahead and do that here for type non-data CDBs. Also 1546 * note that this is currently guaranteed to be a single SGL 1547 * for this case by target core in target_setup_cmd_from_cdb() 1548 * -> transport_generic_cmd_sequencer(). 1549 */ 1550 if (!(se_cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) && 1551 se_cmd->data_direction == DMA_FROM_DEVICE) { 1552 unsigned char *buf = NULL; 1553 1554 if (sgl) 1555 buf = kmap(sg_page(sgl)) + sgl->offset; 1556 1557 if (buf) { 1558 memset(buf, 0, sgl->length); 1559 kunmap(sg_page(sgl)); 1560 } 1561 } 1562 1563 rc = transport_generic_map_mem_to_cmd(se_cmd, sgl, sgl_count, 1564 sgl_bidi, sgl_bidi_count); 1565 if (rc != 0) { 1566 transport_generic_request_failure(se_cmd); 1567 return 0; 1568 } 1569 } 1570 /* 1571 * Check if we need to delay processing because of ALUA 1572 * Active/NonOptimized primary access state.. 1573 */ 1574 core_alua_check_nonop_delay(se_cmd); 1575 1576 transport_handle_cdb_direct(se_cmd); 1577 return 0; 1578 } 1579 EXPORT_SYMBOL(target_submit_cmd_map_sgls); 1580 1581 /* 1582 * target_submit_cmd - lookup unpacked lun and submit uninitialized se_cmd 1583 * 1584 * @se_cmd: command descriptor to submit 1585 * @se_sess: associated se_sess for endpoint 1586 * @cdb: pointer to SCSI CDB 1587 * @sense: pointer to SCSI sense buffer 1588 * @unpacked_lun: unpacked LUN to reference for struct se_lun 1589 * @data_length: fabric expected data transfer length 1590 * @task_addr: SAM task attribute 1591 * @data_dir: DMA data direction 1592 * @flags: flags for command submission from target_sc_flags_tables 1593 * 1594 * Returns non zero to signal active I/O shutdown failure. All other 1595 * setup exceptions will be returned as a SCSI CHECK_CONDITION response, 1596 * but still return zero here. 1597 * 1598 * This may only be called from process context, and also currently 1599 * assumes internal allocation of fabric payload buffer by target-core. 1600 * 1601 * It also assumes interal target core SGL memory allocation. 1602 */ 1603 int target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess, 1604 unsigned char *cdb, unsigned char *sense, u32 unpacked_lun, 1605 u32 data_length, int task_attr, int data_dir, int flags) 1606 { 1607 return target_submit_cmd_map_sgls(se_cmd, se_sess, cdb, sense, 1608 unpacked_lun, data_length, task_attr, data_dir, 1609 flags, NULL, 0, NULL, 0); 1610 } 1611 EXPORT_SYMBOL(target_submit_cmd); 1612 1613 static void target_complete_tmr_failure(struct work_struct *work) 1614 { 1615 struct se_cmd *se_cmd = container_of(work, struct se_cmd, work); 1616 1617 se_cmd->se_tmr_req->response = TMR_LUN_DOES_NOT_EXIST; 1618 se_cmd->se_tfo->queue_tm_rsp(se_cmd); 1619 } 1620 1621 /** 1622 * target_submit_tmr - lookup unpacked lun and submit uninitialized se_cmd 1623 * for TMR CDBs 1624 * 1625 * @se_cmd: command descriptor to submit 1626 * @se_sess: associated se_sess for endpoint 1627 * @sense: pointer to SCSI sense buffer 1628 * @unpacked_lun: unpacked LUN to reference for struct se_lun 1629 * @fabric_context: fabric context for TMR req 1630 * @tm_type: Type of TM request 1631 * @gfp: gfp type for caller 1632 * @tag: referenced task tag for TMR_ABORT_TASK 1633 * @flags: submit cmd flags 1634 * 1635 * Callable from all contexts. 1636 **/ 1637 1638 int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess, 1639 unsigned char *sense, u32 unpacked_lun, 1640 void *fabric_tmr_ptr, unsigned char tm_type, 1641 gfp_t gfp, unsigned int tag, int flags) 1642 { 1643 struct se_portal_group *se_tpg; 1644 int ret; 1645 1646 se_tpg = se_sess->se_tpg; 1647 BUG_ON(!se_tpg); 1648 1649 transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 1650 0, DMA_NONE, MSG_SIMPLE_TAG, sense); 1651 /* 1652 * FIXME: Currently expect caller to handle se_cmd->se_tmr_req 1653 * allocation failure. 1654 */ 1655 ret = core_tmr_alloc_req(se_cmd, fabric_tmr_ptr, tm_type, gfp); 1656 if (ret < 0) 1657 return -ENOMEM; 1658 1659 if (tm_type == TMR_ABORT_TASK) 1660 se_cmd->se_tmr_req->ref_task_tag = tag; 1661 1662 /* See target_submit_cmd for commentary */ 1663 ret = target_get_sess_cmd(se_sess, se_cmd, (flags & TARGET_SCF_ACK_KREF)); 1664 if (ret) { 1665 core_tmr_release_req(se_cmd->se_tmr_req); 1666 return ret; 1667 } 1668 1669 ret = transport_lookup_tmr_lun(se_cmd, unpacked_lun); 1670 if (ret) { 1671 /* 1672 * For callback during failure handling, push this work off 1673 * to process context with TMR_LUN_DOES_NOT_EXIST status. 1674 */ 1675 INIT_WORK(&se_cmd->work, target_complete_tmr_failure); 1676 schedule_work(&se_cmd->work); 1677 return 0; 1678 } 1679 transport_generic_handle_tmr(se_cmd); 1680 return 0; 1681 } 1682 EXPORT_SYMBOL(target_submit_tmr); 1683 1684 /* 1685 * If the cmd is active, request it to be stopped and sleep until it 1686 * has completed. 1687 */ 1688 bool target_stop_cmd(struct se_cmd *cmd, unsigned long *flags) 1689 { 1690 bool was_active = false; 1691 1692 if (cmd->transport_state & CMD_T_BUSY) { 1693 cmd->transport_state |= CMD_T_REQUEST_STOP; 1694 spin_unlock_irqrestore(&cmd->t_state_lock, *flags); 1695 1696 pr_debug("cmd %p waiting to complete\n", cmd); 1697 wait_for_completion(&cmd->task_stop_comp); 1698 pr_debug("cmd %p stopped successfully\n", cmd); 1699 1700 spin_lock_irqsave(&cmd->t_state_lock, *flags); 1701 cmd->transport_state &= ~CMD_T_REQUEST_STOP; 1702 cmd->transport_state &= ~CMD_T_BUSY; 1703 was_active = true; 1704 } 1705 1706 return was_active; 1707 } 1708 1709 /* 1710 * Handle SAM-esque emulation for generic transport request failures. 1711 */ 1712 void transport_generic_request_failure(struct se_cmd *cmd) 1713 { 1714 int ret = 0; 1715 1716 pr_debug("-----[ Storage Engine Exception for cmd: %p ITT: 0x%08x" 1717 " CDB: 0x%02x\n", cmd, cmd->se_tfo->get_task_tag(cmd), 1718 cmd->t_task_cdb[0]); 1719 pr_debug("-----[ i_state: %d t_state: %d scsi_sense_reason: %d\n", 1720 cmd->se_tfo->get_cmd_state(cmd), 1721 cmd->t_state, cmd->scsi_sense_reason); 1722 pr_debug("-----[ CMD_T_ACTIVE: %d CMD_T_STOP: %d CMD_T_SENT: %d\n", 1723 (cmd->transport_state & CMD_T_ACTIVE) != 0, 1724 (cmd->transport_state & CMD_T_STOP) != 0, 1725 (cmd->transport_state & CMD_T_SENT) != 0); 1726 1727 /* 1728 * For SAM Task Attribute emulation for failed struct se_cmd 1729 */ 1730 if (cmd->se_dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED) 1731 transport_complete_task_attr(cmd); 1732 1733 switch (cmd->scsi_sense_reason) { 1734 case TCM_NON_EXISTENT_LUN: 1735 case TCM_UNSUPPORTED_SCSI_OPCODE: 1736 case TCM_INVALID_CDB_FIELD: 1737 case TCM_INVALID_PARAMETER_LIST: 1738 case TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE: 1739 case TCM_UNKNOWN_MODE_PAGE: 1740 case TCM_WRITE_PROTECTED: 1741 case TCM_ADDRESS_OUT_OF_RANGE: 1742 case TCM_CHECK_CONDITION_ABORT_CMD: 1743 case TCM_CHECK_CONDITION_UNIT_ATTENTION: 1744 case TCM_CHECK_CONDITION_NOT_READY: 1745 break; 1746 case TCM_RESERVATION_CONFLICT: 1747 /* 1748 * No SENSE Data payload for this case, set SCSI Status 1749 * and queue the response to $FABRIC_MOD. 1750 * 1751 * Uses linux/include/scsi/scsi.h SAM status codes defs 1752 */ 1753 cmd->scsi_status = SAM_STAT_RESERVATION_CONFLICT; 1754 /* 1755 * For UA Interlock Code 11b, a RESERVATION CONFLICT will 1756 * establish a UNIT ATTENTION with PREVIOUS RESERVATION 1757 * CONFLICT STATUS. 1758 * 1759 * See spc4r17, section 7.4.6 Control Mode Page, Table 349 1760 */ 1761 if (cmd->se_sess && 1762 cmd->se_dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl == 2) 1763 core_scsi3_ua_allocate(cmd->se_sess->se_node_acl, 1764 cmd->orig_fe_lun, 0x2C, 1765 ASCQ_2CH_PREVIOUS_RESERVATION_CONFLICT_STATUS); 1766 1767 ret = cmd->se_tfo->queue_status(cmd); 1768 if (ret == -EAGAIN || ret == -ENOMEM) 1769 goto queue_full; 1770 goto check_stop; 1771 default: 1772 pr_err("Unknown transport error for CDB 0x%02x: %d\n", 1773 cmd->t_task_cdb[0], cmd->scsi_sense_reason); 1774 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE; 1775 break; 1776 } 1777 1778 ret = transport_send_check_condition_and_sense(cmd, 1779 cmd->scsi_sense_reason, 0); 1780 if (ret == -EAGAIN || ret == -ENOMEM) 1781 goto queue_full; 1782 1783 check_stop: 1784 transport_lun_remove_cmd(cmd); 1785 if (!transport_cmd_check_stop_to_fabric(cmd)) 1786 ; 1787 return; 1788 1789 queue_full: 1790 cmd->t_state = TRANSPORT_COMPLETE_QF_OK; 1791 transport_handle_queue_full(cmd, cmd->se_dev); 1792 } 1793 EXPORT_SYMBOL(transport_generic_request_failure); 1794 1795 static void __target_execute_cmd(struct se_cmd *cmd) 1796 { 1797 int error = 0; 1798 1799 spin_lock_irq(&cmd->t_state_lock); 1800 cmd->transport_state |= (CMD_T_BUSY|CMD_T_SENT); 1801 spin_unlock_irq(&cmd->t_state_lock); 1802 1803 if (cmd->execute_cmd) 1804 error = cmd->execute_cmd(cmd); 1805 1806 if (error) { 1807 spin_lock_irq(&cmd->t_state_lock); 1808 cmd->transport_state &= ~(CMD_T_BUSY|CMD_T_SENT); 1809 spin_unlock_irq(&cmd->t_state_lock); 1810 1811 transport_generic_request_failure(cmd); 1812 } 1813 } 1814 1815 void target_execute_cmd(struct se_cmd *cmd) 1816 { 1817 struct se_device *dev = cmd->se_dev; 1818 1819 /* 1820 * If the received CDB has aleady been aborted stop processing it here. 1821 */ 1822 if (transport_check_aborted_status(cmd, 1)) 1823 return; 1824 1825 /* 1826 * Determine if IOCTL context caller in requesting the stopping of this 1827 * command for LUN shutdown purposes. 1828 */ 1829 spin_lock_irq(&cmd->t_state_lock); 1830 if (cmd->transport_state & CMD_T_LUN_STOP) { 1831 pr_debug("%s:%d CMD_T_LUN_STOP for ITT: 0x%08x\n", 1832 __func__, __LINE__, cmd->se_tfo->get_task_tag(cmd)); 1833 1834 cmd->transport_state &= ~CMD_T_ACTIVE; 1835 spin_unlock_irq(&cmd->t_state_lock); 1836 complete(&cmd->transport_lun_stop_comp); 1837 return; 1838 } 1839 /* 1840 * Determine if frontend context caller is requesting the stopping of 1841 * this command for frontend exceptions. 1842 */ 1843 if (cmd->transport_state & CMD_T_STOP) { 1844 pr_debug("%s:%d CMD_T_STOP for ITT: 0x%08x\n", 1845 __func__, __LINE__, 1846 cmd->se_tfo->get_task_tag(cmd)); 1847 1848 spin_unlock_irq(&cmd->t_state_lock); 1849 complete(&cmd->t_transport_stop_comp); 1850 return; 1851 } 1852 1853 cmd->t_state = TRANSPORT_PROCESSING; 1854 spin_unlock_irq(&cmd->t_state_lock); 1855 1856 if (dev->dev_task_attr_type != SAM_TASK_ATTR_EMULATED) 1857 goto execute; 1858 1859 /* 1860 * Check for the existence of HEAD_OF_QUEUE, and if true return 1 1861 * to allow the passed struct se_cmd list of tasks to the front of the list. 1862 */ 1863 switch (cmd->sam_task_attr) { 1864 case MSG_HEAD_TAG: 1865 pr_debug("Added HEAD_OF_QUEUE for CDB: 0x%02x, " 1866 "se_ordered_id: %u\n", 1867 cmd->t_task_cdb[0], cmd->se_ordered_id); 1868 goto execute; 1869 case MSG_ORDERED_TAG: 1870 atomic_inc(&dev->dev_ordered_sync); 1871 smp_mb__after_atomic_inc(); 1872 1873 pr_debug("Added ORDERED for CDB: 0x%02x to ordered list, " 1874 " se_ordered_id: %u\n", 1875 cmd->t_task_cdb[0], cmd->se_ordered_id); 1876 1877 /* 1878 * Execute an ORDERED command if no other older commands 1879 * exist that need to be completed first. 1880 */ 1881 if (!atomic_read(&dev->simple_cmds)) 1882 goto execute; 1883 break; 1884 default: 1885 /* 1886 * For SIMPLE and UNTAGGED Task Attribute commands 1887 */ 1888 atomic_inc(&dev->simple_cmds); 1889 smp_mb__after_atomic_inc(); 1890 break; 1891 } 1892 1893 if (atomic_read(&dev->dev_ordered_sync) != 0) { 1894 spin_lock(&dev->delayed_cmd_lock); 1895 list_add_tail(&cmd->se_delayed_node, &dev->delayed_cmd_list); 1896 spin_unlock(&dev->delayed_cmd_lock); 1897 1898 pr_debug("Added CDB: 0x%02x Task Attr: 0x%02x to" 1899 " delayed CMD list, se_ordered_id: %u\n", 1900 cmd->t_task_cdb[0], cmd->sam_task_attr, 1901 cmd->se_ordered_id); 1902 return; 1903 } 1904 1905 execute: 1906 /* 1907 * Otherwise, no ORDERED task attributes exist.. 1908 */ 1909 __target_execute_cmd(cmd); 1910 } 1911 EXPORT_SYMBOL(target_execute_cmd); 1912 1913 /* 1914 * Process all commands up to the last received ORDERED task attribute which 1915 * requires another blocking boundary 1916 */ 1917 static void target_restart_delayed_cmds(struct se_device *dev) 1918 { 1919 for (;;) { 1920 struct se_cmd *cmd; 1921 1922 spin_lock(&dev->delayed_cmd_lock); 1923 if (list_empty(&dev->delayed_cmd_list)) { 1924 spin_unlock(&dev->delayed_cmd_lock); 1925 break; 1926 } 1927 1928 cmd = list_entry(dev->delayed_cmd_list.next, 1929 struct se_cmd, se_delayed_node); 1930 list_del(&cmd->se_delayed_node); 1931 spin_unlock(&dev->delayed_cmd_lock); 1932 1933 __target_execute_cmd(cmd); 1934 1935 if (cmd->sam_task_attr == MSG_ORDERED_TAG) 1936 break; 1937 } 1938 } 1939 1940 /* 1941 * Called from I/O completion to determine which dormant/delayed 1942 * and ordered cmds need to have their tasks added to the execution queue. 1943 */ 1944 static void transport_complete_task_attr(struct se_cmd *cmd) 1945 { 1946 struct se_device *dev = cmd->se_dev; 1947 1948 if (cmd->sam_task_attr == MSG_SIMPLE_TAG) { 1949 atomic_dec(&dev->simple_cmds); 1950 smp_mb__after_atomic_dec(); 1951 dev->dev_cur_ordered_id++; 1952 pr_debug("Incremented dev->dev_cur_ordered_id: %u for" 1953 " SIMPLE: %u\n", dev->dev_cur_ordered_id, 1954 cmd->se_ordered_id); 1955 } else if (cmd->sam_task_attr == MSG_HEAD_TAG) { 1956 dev->dev_cur_ordered_id++; 1957 pr_debug("Incremented dev_cur_ordered_id: %u for" 1958 " HEAD_OF_QUEUE: %u\n", dev->dev_cur_ordered_id, 1959 cmd->se_ordered_id); 1960 } else if (cmd->sam_task_attr == MSG_ORDERED_TAG) { 1961 atomic_dec(&dev->dev_ordered_sync); 1962 smp_mb__after_atomic_dec(); 1963 1964 dev->dev_cur_ordered_id++; 1965 pr_debug("Incremented dev_cur_ordered_id: %u for ORDERED:" 1966 " %u\n", dev->dev_cur_ordered_id, cmd->se_ordered_id); 1967 } 1968 1969 target_restart_delayed_cmds(dev); 1970 } 1971 1972 static void transport_complete_qf(struct se_cmd *cmd) 1973 { 1974 int ret = 0; 1975 1976 if (cmd->se_dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED) 1977 transport_complete_task_attr(cmd); 1978 1979 if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) { 1980 ret = cmd->se_tfo->queue_status(cmd); 1981 if (ret) 1982 goto out; 1983 } 1984 1985 switch (cmd->data_direction) { 1986 case DMA_FROM_DEVICE: 1987 ret = cmd->se_tfo->queue_data_in(cmd); 1988 break; 1989 case DMA_TO_DEVICE: 1990 if (cmd->t_bidi_data_sg) { 1991 ret = cmd->se_tfo->queue_data_in(cmd); 1992 if (ret < 0) 1993 break; 1994 } 1995 /* Fall through for DMA_TO_DEVICE */ 1996 case DMA_NONE: 1997 ret = cmd->se_tfo->queue_status(cmd); 1998 break; 1999 default: 2000 break; 2001 } 2002 2003 out: 2004 if (ret < 0) { 2005 transport_handle_queue_full(cmd, cmd->se_dev); 2006 return; 2007 } 2008 transport_lun_remove_cmd(cmd); 2009 transport_cmd_check_stop_to_fabric(cmd); 2010 } 2011 2012 static void transport_handle_queue_full( 2013 struct se_cmd *cmd, 2014 struct se_device *dev) 2015 { 2016 spin_lock_irq(&dev->qf_cmd_lock); 2017 list_add_tail(&cmd->se_qf_node, &cmd->se_dev->qf_cmd_list); 2018 atomic_inc(&dev->dev_qf_count); 2019 smp_mb__after_atomic_inc(); 2020 spin_unlock_irq(&cmd->se_dev->qf_cmd_lock); 2021 2022 schedule_work(&cmd->se_dev->qf_work_queue); 2023 } 2024 2025 static void target_complete_ok_work(struct work_struct *work) 2026 { 2027 struct se_cmd *cmd = container_of(work, struct se_cmd, work); 2028 int ret; 2029 2030 /* 2031 * Check if we need to move delayed/dormant tasks from cmds on the 2032 * delayed execution list after a HEAD_OF_QUEUE or ORDERED Task 2033 * Attribute. 2034 */ 2035 if (cmd->se_dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED) 2036 transport_complete_task_attr(cmd); 2037 /* 2038 * Check to schedule QUEUE_FULL work, or execute an existing 2039 * cmd->transport_qf_callback() 2040 */ 2041 if (atomic_read(&cmd->se_dev->dev_qf_count) != 0) 2042 schedule_work(&cmd->se_dev->qf_work_queue); 2043 2044 /* 2045 * Check if we need to send a sense buffer from 2046 * the struct se_cmd in question. 2047 */ 2048 if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) { 2049 WARN_ON(!cmd->scsi_status); 2050 ret = transport_send_check_condition_and_sense( 2051 cmd, 0, 1); 2052 if (ret == -EAGAIN || ret == -ENOMEM) 2053 goto queue_full; 2054 2055 transport_lun_remove_cmd(cmd); 2056 transport_cmd_check_stop_to_fabric(cmd); 2057 return; 2058 } 2059 /* 2060 * Check for a callback, used by amongst other things 2061 * XDWRITE_READ_10 emulation. 2062 */ 2063 if (cmd->transport_complete_callback) 2064 cmd->transport_complete_callback(cmd); 2065 2066 switch (cmd->data_direction) { 2067 case DMA_FROM_DEVICE: 2068 spin_lock(&cmd->se_lun->lun_sep_lock); 2069 if (cmd->se_lun->lun_sep) { 2070 cmd->se_lun->lun_sep->sep_stats.tx_data_octets += 2071 cmd->data_length; 2072 } 2073 spin_unlock(&cmd->se_lun->lun_sep_lock); 2074 2075 ret = cmd->se_tfo->queue_data_in(cmd); 2076 if (ret == -EAGAIN || ret == -ENOMEM) 2077 goto queue_full; 2078 break; 2079 case DMA_TO_DEVICE: 2080 spin_lock(&cmd->se_lun->lun_sep_lock); 2081 if (cmd->se_lun->lun_sep) { 2082 cmd->se_lun->lun_sep->sep_stats.rx_data_octets += 2083 cmd->data_length; 2084 } 2085 spin_unlock(&cmd->se_lun->lun_sep_lock); 2086 /* 2087 * Check if we need to send READ payload for BIDI-COMMAND 2088 */ 2089 if (cmd->t_bidi_data_sg) { 2090 spin_lock(&cmd->se_lun->lun_sep_lock); 2091 if (cmd->se_lun->lun_sep) { 2092 cmd->se_lun->lun_sep->sep_stats.tx_data_octets += 2093 cmd->data_length; 2094 } 2095 spin_unlock(&cmd->se_lun->lun_sep_lock); 2096 ret = cmd->se_tfo->queue_data_in(cmd); 2097 if (ret == -EAGAIN || ret == -ENOMEM) 2098 goto queue_full; 2099 break; 2100 } 2101 /* Fall through for DMA_TO_DEVICE */ 2102 case DMA_NONE: 2103 ret = cmd->se_tfo->queue_status(cmd); 2104 if (ret == -EAGAIN || ret == -ENOMEM) 2105 goto queue_full; 2106 break; 2107 default: 2108 break; 2109 } 2110 2111 transport_lun_remove_cmd(cmd); 2112 transport_cmd_check_stop_to_fabric(cmd); 2113 return; 2114 2115 queue_full: 2116 pr_debug("Handling complete_ok QUEUE_FULL: se_cmd: %p," 2117 " data_direction: %d\n", cmd, cmd->data_direction); 2118 cmd->t_state = TRANSPORT_COMPLETE_QF_OK; 2119 transport_handle_queue_full(cmd, cmd->se_dev); 2120 } 2121 2122 static inline void transport_free_sgl(struct scatterlist *sgl, int nents) 2123 { 2124 struct scatterlist *sg; 2125 int count; 2126 2127 for_each_sg(sgl, sg, nents, count) 2128 __free_page(sg_page(sg)); 2129 2130 kfree(sgl); 2131 } 2132 2133 static inline void transport_free_pages(struct se_cmd *cmd) 2134 { 2135 if (cmd->se_cmd_flags & SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC) 2136 return; 2137 2138 transport_free_sgl(cmd->t_data_sg, cmd->t_data_nents); 2139 cmd->t_data_sg = NULL; 2140 cmd->t_data_nents = 0; 2141 2142 transport_free_sgl(cmd->t_bidi_data_sg, cmd->t_bidi_data_nents); 2143 cmd->t_bidi_data_sg = NULL; 2144 cmd->t_bidi_data_nents = 0; 2145 } 2146 2147 /** 2148 * transport_release_cmd - free a command 2149 * @cmd: command to free 2150 * 2151 * This routine unconditionally frees a command, and reference counting 2152 * or list removal must be done in the caller. 2153 */ 2154 static void transport_release_cmd(struct se_cmd *cmd) 2155 { 2156 BUG_ON(!cmd->se_tfo); 2157 2158 if (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) 2159 core_tmr_release_req(cmd->se_tmr_req); 2160 if (cmd->t_task_cdb != cmd->__t_task_cdb) 2161 kfree(cmd->t_task_cdb); 2162 /* 2163 * If this cmd has been setup with target_get_sess_cmd(), drop 2164 * the kref and call ->release_cmd() in kref callback. 2165 */ 2166 if (cmd->check_release != 0) { 2167 target_put_sess_cmd(cmd->se_sess, cmd); 2168 return; 2169 } 2170 cmd->se_tfo->release_cmd(cmd); 2171 } 2172 2173 /** 2174 * transport_put_cmd - release a reference to a command 2175 * @cmd: command to release 2176 * 2177 * This routine releases our reference to the command and frees it if possible. 2178 */ 2179 static void transport_put_cmd(struct se_cmd *cmd) 2180 { 2181 unsigned long flags; 2182 2183 spin_lock_irqsave(&cmd->t_state_lock, flags); 2184 if (atomic_read(&cmd->t_fe_count)) { 2185 if (!atomic_dec_and_test(&cmd->t_fe_count)) 2186 goto out_busy; 2187 } 2188 2189 if (cmd->transport_state & CMD_T_DEV_ACTIVE) { 2190 cmd->transport_state &= ~CMD_T_DEV_ACTIVE; 2191 target_remove_from_state_list(cmd); 2192 } 2193 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2194 2195 transport_free_pages(cmd); 2196 transport_release_cmd(cmd); 2197 return; 2198 out_busy: 2199 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2200 } 2201 2202 /* 2203 * transport_generic_map_mem_to_cmd - Use fabric-alloced pages instead of 2204 * allocating in the core. 2205 * @cmd: Associated se_cmd descriptor 2206 * @mem: SGL style memory for TCM WRITE / READ 2207 * @sg_mem_num: Number of SGL elements 2208 * @mem_bidi_in: SGL style memory for TCM BIDI READ 2209 * @sg_mem_bidi_num: Number of BIDI READ SGL elements 2210 * 2211 * Return: nonzero return cmd was rejected for -ENOMEM or inproper usage 2212 * of parameters. 2213 */ 2214 int transport_generic_map_mem_to_cmd( 2215 struct se_cmd *cmd, 2216 struct scatterlist *sgl, 2217 u32 sgl_count, 2218 struct scatterlist *sgl_bidi, 2219 u32 sgl_bidi_count) 2220 { 2221 if (!sgl || !sgl_count) 2222 return 0; 2223 2224 /* 2225 * Reject SCSI data overflow with map_mem_to_cmd() as incoming 2226 * scatterlists already have been set to follow what the fabric 2227 * passes for the original expected data transfer length. 2228 */ 2229 if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT) { 2230 pr_warn("Rejecting SCSI DATA overflow for fabric using" 2231 " SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC\n"); 2232 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 2233 cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD; 2234 return -EINVAL; 2235 } 2236 2237 cmd->t_data_sg = sgl; 2238 cmd->t_data_nents = sgl_count; 2239 2240 if (sgl_bidi && sgl_bidi_count) { 2241 cmd->t_bidi_data_sg = sgl_bidi; 2242 cmd->t_bidi_data_nents = sgl_bidi_count; 2243 } 2244 cmd->se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC; 2245 return 0; 2246 } 2247 EXPORT_SYMBOL(transport_generic_map_mem_to_cmd); 2248 2249 void *transport_kmap_data_sg(struct se_cmd *cmd) 2250 { 2251 struct scatterlist *sg = cmd->t_data_sg; 2252 struct page **pages; 2253 int i; 2254 2255 /* 2256 * We need to take into account a possible offset here for fabrics like 2257 * tcm_loop who may be using a contig buffer from the SCSI midlayer for 2258 * control CDBs passed as SGLs via transport_generic_map_mem_to_cmd() 2259 */ 2260 if (!cmd->t_data_nents) 2261 return NULL; 2262 2263 BUG_ON(!sg); 2264 if (cmd->t_data_nents == 1) 2265 return kmap(sg_page(sg)) + sg->offset; 2266 2267 /* >1 page. use vmap */ 2268 pages = kmalloc(sizeof(*pages) * cmd->t_data_nents, GFP_KERNEL); 2269 if (!pages) { 2270 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2271 return NULL; 2272 } 2273 2274 /* convert sg[] to pages[] */ 2275 for_each_sg(cmd->t_data_sg, sg, cmd->t_data_nents, i) { 2276 pages[i] = sg_page(sg); 2277 } 2278 2279 cmd->t_data_vmap = vmap(pages, cmd->t_data_nents, VM_MAP, PAGE_KERNEL); 2280 kfree(pages); 2281 if (!cmd->t_data_vmap) { 2282 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2283 return NULL; 2284 } 2285 2286 return cmd->t_data_vmap + cmd->t_data_sg[0].offset; 2287 } 2288 EXPORT_SYMBOL(transport_kmap_data_sg); 2289 2290 void transport_kunmap_data_sg(struct se_cmd *cmd) 2291 { 2292 if (!cmd->t_data_nents) { 2293 return; 2294 } else if (cmd->t_data_nents == 1) { 2295 kunmap(sg_page(cmd->t_data_sg)); 2296 return; 2297 } 2298 2299 vunmap(cmd->t_data_vmap); 2300 cmd->t_data_vmap = NULL; 2301 } 2302 EXPORT_SYMBOL(transport_kunmap_data_sg); 2303 2304 static int 2305 transport_generic_get_mem(struct se_cmd *cmd) 2306 { 2307 u32 length = cmd->data_length; 2308 unsigned int nents; 2309 struct page *page; 2310 gfp_t zero_flag; 2311 int i = 0; 2312 2313 nents = DIV_ROUND_UP(length, PAGE_SIZE); 2314 cmd->t_data_sg = kmalloc(sizeof(struct scatterlist) * nents, GFP_KERNEL); 2315 if (!cmd->t_data_sg) 2316 return -ENOMEM; 2317 2318 cmd->t_data_nents = nents; 2319 sg_init_table(cmd->t_data_sg, nents); 2320 2321 zero_flag = cmd->se_cmd_flags & SCF_SCSI_DATA_CDB ? 0 : __GFP_ZERO; 2322 2323 while (length) { 2324 u32 page_len = min_t(u32, length, PAGE_SIZE); 2325 page = alloc_page(GFP_KERNEL | zero_flag); 2326 if (!page) 2327 goto out; 2328 2329 sg_set_page(&cmd->t_data_sg[i], page, page_len, 0); 2330 length -= page_len; 2331 i++; 2332 } 2333 return 0; 2334 2335 out: 2336 while (i > 0) { 2337 i--; 2338 __free_page(sg_page(&cmd->t_data_sg[i])); 2339 } 2340 kfree(cmd->t_data_sg); 2341 cmd->t_data_sg = NULL; 2342 return -ENOMEM; 2343 } 2344 2345 /* 2346 * Allocate any required resources to execute the command. For writes we 2347 * might not have the payload yet, so notify the fabric via a call to 2348 * ->write_pending instead. Otherwise place it on the execution queue. 2349 */ 2350 int transport_generic_new_cmd(struct se_cmd *cmd) 2351 { 2352 int ret = 0; 2353 2354 /* 2355 * Determine is the TCM fabric module has already allocated physical 2356 * memory, and is directly calling transport_generic_map_mem_to_cmd() 2357 * beforehand. 2358 */ 2359 if (!(cmd->se_cmd_flags & SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC) && 2360 cmd->data_length) { 2361 ret = transport_generic_get_mem(cmd); 2362 if (ret < 0) 2363 goto out_fail; 2364 } 2365 2366 atomic_inc(&cmd->t_fe_count); 2367 2368 /* 2369 * If this command is not a write we can execute it right here, 2370 * for write buffers we need to notify the fabric driver first 2371 * and let it call back once the write buffers are ready. 2372 */ 2373 target_add_to_state_list(cmd); 2374 if (cmd->data_direction != DMA_TO_DEVICE) { 2375 target_execute_cmd(cmd); 2376 return 0; 2377 } 2378 2379 spin_lock_irq(&cmd->t_state_lock); 2380 cmd->t_state = TRANSPORT_WRITE_PENDING; 2381 spin_unlock_irq(&cmd->t_state_lock); 2382 2383 transport_cmd_check_stop(cmd, false); 2384 2385 ret = cmd->se_tfo->write_pending(cmd); 2386 if (ret == -EAGAIN || ret == -ENOMEM) 2387 goto queue_full; 2388 2389 if (ret < 0) 2390 return ret; 2391 return 1; 2392 2393 out_fail: 2394 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 2395 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2396 return -EINVAL; 2397 queue_full: 2398 pr_debug("Handling write_pending QUEUE__FULL: se_cmd: %p\n", cmd); 2399 cmd->t_state = TRANSPORT_COMPLETE_QF_WP; 2400 transport_handle_queue_full(cmd, cmd->se_dev); 2401 return 0; 2402 } 2403 EXPORT_SYMBOL(transport_generic_new_cmd); 2404 2405 static void transport_write_pending_qf(struct se_cmd *cmd) 2406 { 2407 int ret; 2408 2409 ret = cmd->se_tfo->write_pending(cmd); 2410 if (ret == -EAGAIN || ret == -ENOMEM) { 2411 pr_debug("Handling write_pending QUEUE__FULL: se_cmd: %p\n", 2412 cmd); 2413 transport_handle_queue_full(cmd, cmd->se_dev); 2414 } 2415 } 2416 2417 void transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks) 2418 { 2419 if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD)) { 2420 if (wait_for_tasks && (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) 2421 transport_wait_for_tasks(cmd); 2422 2423 transport_release_cmd(cmd); 2424 } else { 2425 if (wait_for_tasks) 2426 transport_wait_for_tasks(cmd); 2427 2428 core_dec_lacl_count(cmd->se_sess->se_node_acl, cmd); 2429 2430 if (cmd->se_lun) 2431 transport_lun_remove_cmd(cmd); 2432 2433 transport_put_cmd(cmd); 2434 } 2435 } 2436 EXPORT_SYMBOL(transport_generic_free_cmd); 2437 2438 /* target_get_sess_cmd - Add command to active ->sess_cmd_list 2439 * @se_sess: session to reference 2440 * @se_cmd: command descriptor to add 2441 * @ack_kref: Signal that fabric will perform an ack target_put_sess_cmd() 2442 */ 2443 static int target_get_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd, 2444 bool ack_kref) 2445 { 2446 unsigned long flags; 2447 int ret = 0; 2448 2449 kref_init(&se_cmd->cmd_kref); 2450 /* 2451 * Add a second kref if the fabric caller is expecting to handle 2452 * fabric acknowledgement that requires two target_put_sess_cmd() 2453 * invocations before se_cmd descriptor release. 2454 */ 2455 if (ack_kref == true) { 2456 kref_get(&se_cmd->cmd_kref); 2457 se_cmd->se_cmd_flags |= SCF_ACK_KREF; 2458 } 2459 2460 spin_lock_irqsave(&se_sess->sess_cmd_lock, flags); 2461 if (se_sess->sess_tearing_down) { 2462 ret = -ESHUTDOWN; 2463 goto out; 2464 } 2465 list_add_tail(&se_cmd->se_cmd_list, &se_sess->sess_cmd_list); 2466 se_cmd->check_release = 1; 2467 2468 out: 2469 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2470 return ret; 2471 } 2472 2473 static void target_release_cmd_kref(struct kref *kref) 2474 { 2475 struct se_cmd *se_cmd = container_of(kref, struct se_cmd, cmd_kref); 2476 struct se_session *se_sess = se_cmd->se_sess; 2477 unsigned long flags; 2478 2479 spin_lock_irqsave(&se_sess->sess_cmd_lock, flags); 2480 if (list_empty(&se_cmd->se_cmd_list)) { 2481 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2482 se_cmd->se_tfo->release_cmd(se_cmd); 2483 return; 2484 } 2485 if (se_sess->sess_tearing_down && se_cmd->cmd_wait_set) { 2486 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2487 complete(&se_cmd->cmd_wait_comp); 2488 return; 2489 } 2490 list_del(&se_cmd->se_cmd_list); 2491 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2492 2493 se_cmd->se_tfo->release_cmd(se_cmd); 2494 } 2495 2496 /* target_put_sess_cmd - Check for active I/O shutdown via kref_put 2497 * @se_sess: session to reference 2498 * @se_cmd: command descriptor to drop 2499 */ 2500 int target_put_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd) 2501 { 2502 return kref_put(&se_cmd->cmd_kref, target_release_cmd_kref); 2503 } 2504 EXPORT_SYMBOL(target_put_sess_cmd); 2505 2506 /* target_sess_cmd_list_set_waiting - Flag all commands in 2507 * sess_cmd_list to complete cmd_wait_comp. Set 2508 * sess_tearing_down so no more commands are queued. 2509 * @se_sess: session to flag 2510 */ 2511 void target_sess_cmd_list_set_waiting(struct se_session *se_sess) 2512 { 2513 struct se_cmd *se_cmd; 2514 unsigned long flags; 2515 2516 spin_lock_irqsave(&se_sess->sess_cmd_lock, flags); 2517 2518 WARN_ON(se_sess->sess_tearing_down); 2519 se_sess->sess_tearing_down = 1; 2520 2521 list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) 2522 se_cmd->cmd_wait_set = 1; 2523 2524 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2525 } 2526 EXPORT_SYMBOL(target_sess_cmd_list_set_waiting); 2527 2528 /* target_wait_for_sess_cmds - Wait for outstanding descriptors 2529 * @se_sess: session to wait for active I/O 2530 * @wait_for_tasks: Make extra transport_wait_for_tasks call 2531 */ 2532 void target_wait_for_sess_cmds( 2533 struct se_session *se_sess, 2534 int wait_for_tasks) 2535 { 2536 struct se_cmd *se_cmd, *tmp_cmd; 2537 bool rc = false; 2538 2539 list_for_each_entry_safe(se_cmd, tmp_cmd, 2540 &se_sess->sess_cmd_list, se_cmd_list) { 2541 list_del(&se_cmd->se_cmd_list); 2542 2543 pr_debug("Waiting for se_cmd: %p t_state: %d, fabric state:" 2544 " %d\n", se_cmd, se_cmd->t_state, 2545 se_cmd->se_tfo->get_cmd_state(se_cmd)); 2546 2547 if (wait_for_tasks) { 2548 pr_debug("Calling transport_wait_for_tasks se_cmd: %p t_state: %d," 2549 " fabric state: %d\n", se_cmd, se_cmd->t_state, 2550 se_cmd->se_tfo->get_cmd_state(se_cmd)); 2551 2552 rc = transport_wait_for_tasks(se_cmd); 2553 2554 pr_debug("After transport_wait_for_tasks se_cmd: %p t_state: %d," 2555 " fabric state: %d\n", se_cmd, se_cmd->t_state, 2556 se_cmd->se_tfo->get_cmd_state(se_cmd)); 2557 } 2558 2559 if (!rc) { 2560 wait_for_completion(&se_cmd->cmd_wait_comp); 2561 pr_debug("After cmd_wait_comp: se_cmd: %p t_state: %d" 2562 " fabric state: %d\n", se_cmd, se_cmd->t_state, 2563 se_cmd->se_tfo->get_cmd_state(se_cmd)); 2564 } 2565 2566 se_cmd->se_tfo->release_cmd(se_cmd); 2567 } 2568 } 2569 EXPORT_SYMBOL(target_wait_for_sess_cmds); 2570 2571 /* transport_lun_wait_for_tasks(): 2572 * 2573 * Called from ConfigFS context to stop the passed struct se_cmd to allow 2574 * an struct se_lun to be successfully shutdown. 2575 */ 2576 static int transport_lun_wait_for_tasks(struct se_cmd *cmd, struct se_lun *lun) 2577 { 2578 unsigned long flags; 2579 int ret = 0; 2580 2581 /* 2582 * If the frontend has already requested this struct se_cmd to 2583 * be stopped, we can safely ignore this struct se_cmd. 2584 */ 2585 spin_lock_irqsave(&cmd->t_state_lock, flags); 2586 if (cmd->transport_state & CMD_T_STOP) { 2587 cmd->transport_state &= ~CMD_T_LUN_STOP; 2588 2589 pr_debug("ConfigFS ITT[0x%08x] - CMD_T_STOP, skipping\n", 2590 cmd->se_tfo->get_task_tag(cmd)); 2591 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2592 transport_cmd_check_stop(cmd, false); 2593 return -EPERM; 2594 } 2595 cmd->transport_state |= CMD_T_LUN_FE_STOP; 2596 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2597 2598 // XXX: audit task_flags checks. 2599 spin_lock_irqsave(&cmd->t_state_lock, flags); 2600 if ((cmd->transport_state & CMD_T_BUSY) && 2601 (cmd->transport_state & CMD_T_SENT)) { 2602 if (!target_stop_cmd(cmd, &flags)) 2603 ret++; 2604 } 2605 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2606 2607 pr_debug("ConfigFS: cmd: %p stop tasks ret:" 2608 " %d\n", cmd, ret); 2609 if (!ret) { 2610 pr_debug("ConfigFS: ITT[0x%08x] - stopping cmd....\n", 2611 cmd->se_tfo->get_task_tag(cmd)); 2612 wait_for_completion(&cmd->transport_lun_stop_comp); 2613 pr_debug("ConfigFS: ITT[0x%08x] - stopped cmd....\n", 2614 cmd->se_tfo->get_task_tag(cmd)); 2615 } 2616 2617 return 0; 2618 } 2619 2620 static void __transport_clear_lun_from_sessions(struct se_lun *lun) 2621 { 2622 struct se_cmd *cmd = NULL; 2623 unsigned long lun_flags, cmd_flags; 2624 /* 2625 * Do exception processing and return CHECK_CONDITION status to the 2626 * Initiator Port. 2627 */ 2628 spin_lock_irqsave(&lun->lun_cmd_lock, lun_flags); 2629 while (!list_empty(&lun->lun_cmd_list)) { 2630 cmd = list_first_entry(&lun->lun_cmd_list, 2631 struct se_cmd, se_lun_node); 2632 list_del_init(&cmd->se_lun_node); 2633 2634 spin_lock(&cmd->t_state_lock); 2635 pr_debug("SE_LUN[%d] - Setting cmd->transport" 2636 "_lun_stop for ITT: 0x%08x\n", 2637 cmd->se_lun->unpacked_lun, 2638 cmd->se_tfo->get_task_tag(cmd)); 2639 cmd->transport_state |= CMD_T_LUN_STOP; 2640 spin_unlock(&cmd->t_state_lock); 2641 2642 spin_unlock_irqrestore(&lun->lun_cmd_lock, lun_flags); 2643 2644 if (!cmd->se_lun) { 2645 pr_err("ITT: 0x%08x, [i,t]_state: %u/%u\n", 2646 cmd->se_tfo->get_task_tag(cmd), 2647 cmd->se_tfo->get_cmd_state(cmd), cmd->t_state); 2648 BUG(); 2649 } 2650 /* 2651 * If the Storage engine still owns the iscsi_cmd_t, determine 2652 * and/or stop its context. 2653 */ 2654 pr_debug("SE_LUN[%d] - ITT: 0x%08x before transport" 2655 "_lun_wait_for_tasks()\n", cmd->se_lun->unpacked_lun, 2656 cmd->se_tfo->get_task_tag(cmd)); 2657 2658 if (transport_lun_wait_for_tasks(cmd, cmd->se_lun) < 0) { 2659 spin_lock_irqsave(&lun->lun_cmd_lock, lun_flags); 2660 continue; 2661 } 2662 2663 pr_debug("SE_LUN[%d] - ITT: 0x%08x after transport_lun" 2664 "_wait_for_tasks(): SUCCESS\n", 2665 cmd->se_lun->unpacked_lun, 2666 cmd->se_tfo->get_task_tag(cmd)); 2667 2668 spin_lock_irqsave(&cmd->t_state_lock, cmd_flags); 2669 if (!(cmd->transport_state & CMD_T_DEV_ACTIVE)) { 2670 spin_unlock_irqrestore(&cmd->t_state_lock, cmd_flags); 2671 goto check_cond; 2672 } 2673 cmd->transport_state &= ~CMD_T_DEV_ACTIVE; 2674 target_remove_from_state_list(cmd); 2675 spin_unlock_irqrestore(&cmd->t_state_lock, cmd_flags); 2676 2677 /* 2678 * The Storage engine stopped this struct se_cmd before it was 2679 * send to the fabric frontend for delivery back to the 2680 * Initiator Node. Return this SCSI CDB back with an 2681 * CHECK_CONDITION status. 2682 */ 2683 check_cond: 2684 transport_send_check_condition_and_sense(cmd, 2685 TCM_NON_EXISTENT_LUN, 0); 2686 /* 2687 * If the fabric frontend is waiting for this iscsi_cmd_t to 2688 * be released, notify the waiting thread now that LU has 2689 * finished accessing it. 2690 */ 2691 spin_lock_irqsave(&cmd->t_state_lock, cmd_flags); 2692 if (cmd->transport_state & CMD_T_LUN_FE_STOP) { 2693 pr_debug("SE_LUN[%d] - Detected FE stop for" 2694 " struct se_cmd: %p ITT: 0x%08x\n", 2695 lun->unpacked_lun, 2696 cmd, cmd->se_tfo->get_task_tag(cmd)); 2697 2698 spin_unlock_irqrestore(&cmd->t_state_lock, 2699 cmd_flags); 2700 transport_cmd_check_stop(cmd, false); 2701 complete(&cmd->transport_lun_fe_stop_comp); 2702 spin_lock_irqsave(&lun->lun_cmd_lock, lun_flags); 2703 continue; 2704 } 2705 pr_debug("SE_LUN[%d] - ITT: 0x%08x finished processing\n", 2706 lun->unpacked_lun, cmd->se_tfo->get_task_tag(cmd)); 2707 2708 spin_unlock_irqrestore(&cmd->t_state_lock, cmd_flags); 2709 spin_lock_irqsave(&lun->lun_cmd_lock, lun_flags); 2710 } 2711 spin_unlock_irqrestore(&lun->lun_cmd_lock, lun_flags); 2712 } 2713 2714 static int transport_clear_lun_thread(void *p) 2715 { 2716 struct se_lun *lun = p; 2717 2718 __transport_clear_lun_from_sessions(lun); 2719 complete(&lun->lun_shutdown_comp); 2720 2721 return 0; 2722 } 2723 2724 int transport_clear_lun_from_sessions(struct se_lun *lun) 2725 { 2726 struct task_struct *kt; 2727 2728 kt = kthread_run(transport_clear_lun_thread, lun, 2729 "tcm_cl_%u", lun->unpacked_lun); 2730 if (IS_ERR(kt)) { 2731 pr_err("Unable to start clear_lun thread\n"); 2732 return PTR_ERR(kt); 2733 } 2734 wait_for_completion(&lun->lun_shutdown_comp); 2735 2736 return 0; 2737 } 2738 2739 /** 2740 * transport_wait_for_tasks - wait for completion to occur 2741 * @cmd: command to wait 2742 * 2743 * Called from frontend fabric context to wait for storage engine 2744 * to pause and/or release frontend generated struct se_cmd. 2745 */ 2746 bool transport_wait_for_tasks(struct se_cmd *cmd) 2747 { 2748 unsigned long flags; 2749 2750 spin_lock_irqsave(&cmd->t_state_lock, flags); 2751 if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD) && 2752 !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) { 2753 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2754 return false; 2755 } 2756 2757 if (!(cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE) && 2758 !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) { 2759 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2760 return false; 2761 } 2762 /* 2763 * If we are already stopped due to an external event (ie: LUN shutdown) 2764 * sleep until the connection can have the passed struct se_cmd back. 2765 * The cmd->transport_lun_stopped_sem will be upped by 2766 * transport_clear_lun_from_sessions() once the ConfigFS context caller 2767 * has completed its operation on the struct se_cmd. 2768 */ 2769 if (cmd->transport_state & CMD_T_LUN_STOP) { 2770 pr_debug("wait_for_tasks: Stopping" 2771 " wait_for_completion(&cmd->t_tasktransport_lun_fe" 2772 "_stop_comp); for ITT: 0x%08x\n", 2773 cmd->se_tfo->get_task_tag(cmd)); 2774 /* 2775 * There is a special case for WRITES where a FE exception + 2776 * LUN shutdown means ConfigFS context is still sleeping on 2777 * transport_lun_stop_comp in transport_lun_wait_for_tasks(). 2778 * We go ahead and up transport_lun_stop_comp just to be sure 2779 * here. 2780 */ 2781 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2782 complete(&cmd->transport_lun_stop_comp); 2783 wait_for_completion(&cmd->transport_lun_fe_stop_comp); 2784 spin_lock_irqsave(&cmd->t_state_lock, flags); 2785 2786 target_remove_from_state_list(cmd); 2787 /* 2788 * At this point, the frontend who was the originator of this 2789 * struct se_cmd, now owns the structure and can be released through 2790 * normal means below. 2791 */ 2792 pr_debug("wait_for_tasks: Stopped" 2793 " wait_for_completion(&cmd->t_tasktransport_lun_fe_" 2794 "stop_comp); for ITT: 0x%08x\n", 2795 cmd->se_tfo->get_task_tag(cmd)); 2796 2797 cmd->transport_state &= ~CMD_T_LUN_STOP; 2798 } 2799 2800 if (!(cmd->transport_state & CMD_T_ACTIVE)) { 2801 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2802 return false; 2803 } 2804 2805 cmd->transport_state |= CMD_T_STOP; 2806 2807 pr_debug("wait_for_tasks: Stopping %p ITT: 0x%08x" 2808 " i_state: %d, t_state: %d, CMD_T_STOP\n", 2809 cmd, cmd->se_tfo->get_task_tag(cmd), 2810 cmd->se_tfo->get_cmd_state(cmd), cmd->t_state); 2811 2812 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2813 2814 wait_for_completion(&cmd->t_transport_stop_comp); 2815 2816 spin_lock_irqsave(&cmd->t_state_lock, flags); 2817 cmd->transport_state &= ~(CMD_T_ACTIVE | CMD_T_STOP); 2818 2819 pr_debug("wait_for_tasks: Stopped wait_for_completion(" 2820 "&cmd->t_transport_stop_comp) for ITT: 0x%08x\n", 2821 cmd->se_tfo->get_task_tag(cmd)); 2822 2823 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2824 2825 return true; 2826 } 2827 EXPORT_SYMBOL(transport_wait_for_tasks); 2828 2829 static int transport_get_sense_codes( 2830 struct se_cmd *cmd, 2831 u8 *asc, 2832 u8 *ascq) 2833 { 2834 *asc = cmd->scsi_asc; 2835 *ascq = cmd->scsi_ascq; 2836 2837 return 0; 2838 } 2839 2840 static int transport_set_sense_codes( 2841 struct se_cmd *cmd, 2842 u8 asc, 2843 u8 ascq) 2844 { 2845 cmd->scsi_asc = asc; 2846 cmd->scsi_ascq = ascq; 2847 2848 return 0; 2849 } 2850 2851 int transport_send_check_condition_and_sense( 2852 struct se_cmd *cmd, 2853 u8 reason, 2854 int from_transport) 2855 { 2856 unsigned char *buffer = cmd->sense_buffer; 2857 unsigned long flags; 2858 u8 asc = 0, ascq = 0; 2859 2860 spin_lock_irqsave(&cmd->t_state_lock, flags); 2861 if (cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) { 2862 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2863 return 0; 2864 } 2865 cmd->se_cmd_flags |= SCF_SENT_CHECK_CONDITION; 2866 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2867 2868 if (!reason && from_transport) 2869 goto after_reason; 2870 2871 if (!from_transport) 2872 cmd->se_cmd_flags |= SCF_EMULATED_TASK_SENSE; 2873 2874 /* 2875 * Actual SENSE DATA, see SPC-3 7.23.2 SPC_SENSE_KEY_OFFSET uses 2876 * SENSE KEY values from include/scsi/scsi.h 2877 */ 2878 switch (reason) { 2879 case TCM_NON_EXISTENT_LUN: 2880 /* CURRENT ERROR */ 2881 buffer[0] = 0x70; 2882 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2883 /* ILLEGAL REQUEST */ 2884 buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2885 /* LOGICAL UNIT NOT SUPPORTED */ 2886 buffer[SPC_ASC_KEY_OFFSET] = 0x25; 2887 break; 2888 case TCM_UNSUPPORTED_SCSI_OPCODE: 2889 case TCM_SECTOR_COUNT_TOO_MANY: 2890 /* CURRENT ERROR */ 2891 buffer[0] = 0x70; 2892 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2893 /* ILLEGAL REQUEST */ 2894 buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2895 /* INVALID COMMAND OPERATION CODE */ 2896 buffer[SPC_ASC_KEY_OFFSET] = 0x20; 2897 break; 2898 case TCM_UNKNOWN_MODE_PAGE: 2899 /* CURRENT ERROR */ 2900 buffer[0] = 0x70; 2901 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2902 /* ILLEGAL REQUEST */ 2903 buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2904 /* INVALID FIELD IN CDB */ 2905 buffer[SPC_ASC_KEY_OFFSET] = 0x24; 2906 break; 2907 case TCM_CHECK_CONDITION_ABORT_CMD: 2908 /* CURRENT ERROR */ 2909 buffer[0] = 0x70; 2910 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2911 /* ABORTED COMMAND */ 2912 buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2913 /* BUS DEVICE RESET FUNCTION OCCURRED */ 2914 buffer[SPC_ASC_KEY_OFFSET] = 0x29; 2915 buffer[SPC_ASCQ_KEY_OFFSET] = 0x03; 2916 break; 2917 case TCM_INCORRECT_AMOUNT_OF_DATA: 2918 /* CURRENT ERROR */ 2919 buffer[0] = 0x70; 2920 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2921 /* ABORTED COMMAND */ 2922 buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2923 /* WRITE ERROR */ 2924 buffer[SPC_ASC_KEY_OFFSET] = 0x0c; 2925 /* NOT ENOUGH UNSOLICITED DATA */ 2926 buffer[SPC_ASCQ_KEY_OFFSET] = 0x0d; 2927 break; 2928 case TCM_INVALID_CDB_FIELD: 2929 /* CURRENT ERROR */ 2930 buffer[0] = 0x70; 2931 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2932 /* ILLEGAL REQUEST */ 2933 buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2934 /* INVALID FIELD IN CDB */ 2935 buffer[SPC_ASC_KEY_OFFSET] = 0x24; 2936 break; 2937 case TCM_INVALID_PARAMETER_LIST: 2938 /* CURRENT ERROR */ 2939 buffer[0] = 0x70; 2940 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2941 /* ILLEGAL REQUEST */ 2942 buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2943 /* INVALID FIELD IN PARAMETER LIST */ 2944 buffer[SPC_ASC_KEY_OFFSET] = 0x26; 2945 break; 2946 case TCM_UNEXPECTED_UNSOLICITED_DATA: 2947 /* CURRENT ERROR */ 2948 buffer[0] = 0x70; 2949 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2950 /* ABORTED COMMAND */ 2951 buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2952 /* WRITE ERROR */ 2953 buffer[SPC_ASC_KEY_OFFSET] = 0x0c; 2954 /* UNEXPECTED_UNSOLICITED_DATA */ 2955 buffer[SPC_ASCQ_KEY_OFFSET] = 0x0c; 2956 break; 2957 case TCM_SERVICE_CRC_ERROR: 2958 /* CURRENT ERROR */ 2959 buffer[0] = 0x70; 2960 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2961 /* ABORTED COMMAND */ 2962 buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2963 /* PROTOCOL SERVICE CRC ERROR */ 2964 buffer[SPC_ASC_KEY_OFFSET] = 0x47; 2965 /* N/A */ 2966 buffer[SPC_ASCQ_KEY_OFFSET] = 0x05; 2967 break; 2968 case TCM_SNACK_REJECTED: 2969 /* CURRENT ERROR */ 2970 buffer[0] = 0x70; 2971 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2972 /* ABORTED COMMAND */ 2973 buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2974 /* READ ERROR */ 2975 buffer[SPC_ASC_KEY_OFFSET] = 0x11; 2976 /* FAILED RETRANSMISSION REQUEST */ 2977 buffer[SPC_ASCQ_KEY_OFFSET] = 0x13; 2978 break; 2979 case TCM_WRITE_PROTECTED: 2980 /* CURRENT ERROR */ 2981 buffer[0] = 0x70; 2982 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2983 /* DATA PROTECT */ 2984 buffer[SPC_SENSE_KEY_OFFSET] = DATA_PROTECT; 2985 /* WRITE PROTECTED */ 2986 buffer[SPC_ASC_KEY_OFFSET] = 0x27; 2987 break; 2988 case TCM_ADDRESS_OUT_OF_RANGE: 2989 /* CURRENT ERROR */ 2990 buffer[0] = 0x70; 2991 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2992 /* ILLEGAL REQUEST */ 2993 buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2994 /* LOGICAL BLOCK ADDRESS OUT OF RANGE */ 2995 buffer[SPC_ASC_KEY_OFFSET] = 0x21; 2996 break; 2997 case TCM_CHECK_CONDITION_UNIT_ATTENTION: 2998 /* CURRENT ERROR */ 2999 buffer[0] = 0x70; 3000 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 3001 /* UNIT ATTENTION */ 3002 buffer[SPC_SENSE_KEY_OFFSET] = UNIT_ATTENTION; 3003 core_scsi3_ua_for_check_condition(cmd, &asc, &ascq); 3004 buffer[SPC_ASC_KEY_OFFSET] = asc; 3005 buffer[SPC_ASCQ_KEY_OFFSET] = ascq; 3006 break; 3007 case TCM_CHECK_CONDITION_NOT_READY: 3008 /* CURRENT ERROR */ 3009 buffer[0] = 0x70; 3010 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 3011 /* Not Ready */ 3012 buffer[SPC_SENSE_KEY_OFFSET] = NOT_READY; 3013 transport_get_sense_codes(cmd, &asc, &ascq); 3014 buffer[SPC_ASC_KEY_OFFSET] = asc; 3015 buffer[SPC_ASCQ_KEY_OFFSET] = ascq; 3016 break; 3017 case TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE: 3018 default: 3019 /* CURRENT ERROR */ 3020 buffer[0] = 0x70; 3021 buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 3022 /* ILLEGAL REQUEST */ 3023 buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 3024 /* LOGICAL UNIT COMMUNICATION FAILURE */ 3025 buffer[SPC_ASC_KEY_OFFSET] = 0x80; 3026 break; 3027 } 3028 /* 3029 * This code uses linux/include/scsi/scsi.h SAM status codes! 3030 */ 3031 cmd->scsi_status = SAM_STAT_CHECK_CONDITION; 3032 /* 3033 * Automatically padded, this value is encoded in the fabric's 3034 * data_length response PDU containing the SCSI defined sense data. 3035 */ 3036 cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER; 3037 3038 after_reason: 3039 return cmd->se_tfo->queue_status(cmd); 3040 } 3041 EXPORT_SYMBOL(transport_send_check_condition_and_sense); 3042 3043 int transport_check_aborted_status(struct se_cmd *cmd, int send_status) 3044 { 3045 int ret = 0; 3046 3047 if (cmd->transport_state & CMD_T_ABORTED) { 3048 if (!send_status || 3049 (cmd->se_cmd_flags & SCF_SENT_DELAYED_TAS)) 3050 return 1; 3051 3052 pr_debug("Sending delayed SAM_STAT_TASK_ABORTED" 3053 " status for CDB: 0x%02x ITT: 0x%08x\n", 3054 cmd->t_task_cdb[0], 3055 cmd->se_tfo->get_task_tag(cmd)); 3056 3057 cmd->se_cmd_flags |= SCF_SENT_DELAYED_TAS; 3058 cmd->se_tfo->queue_status(cmd); 3059 ret = 1; 3060 } 3061 return ret; 3062 } 3063 EXPORT_SYMBOL(transport_check_aborted_status); 3064 3065 void transport_send_task_abort(struct se_cmd *cmd) 3066 { 3067 unsigned long flags; 3068 3069 spin_lock_irqsave(&cmd->t_state_lock, flags); 3070 if (cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) { 3071 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 3072 return; 3073 } 3074 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 3075 3076 /* 3077 * If there are still expected incoming fabric WRITEs, we wait 3078 * until until they have completed before sending a TASK_ABORTED 3079 * response. This response with TASK_ABORTED status will be 3080 * queued back to fabric module by transport_check_aborted_status(). 3081 */ 3082 if (cmd->data_direction == DMA_TO_DEVICE) { 3083 if (cmd->se_tfo->write_pending_status(cmd) != 0) { 3084 cmd->transport_state |= CMD_T_ABORTED; 3085 smp_mb__after_atomic_inc(); 3086 } 3087 } 3088 cmd->scsi_status = SAM_STAT_TASK_ABORTED; 3089 3090 pr_debug("Setting SAM_STAT_TASK_ABORTED status for CDB: 0x%02x," 3091 " ITT: 0x%08x\n", cmd->t_task_cdb[0], 3092 cmd->se_tfo->get_task_tag(cmd)); 3093 3094 cmd->se_tfo->queue_status(cmd); 3095 } 3096 3097 static void target_tmr_work(struct work_struct *work) 3098 { 3099 struct se_cmd *cmd = container_of(work, struct se_cmd, work); 3100 struct se_device *dev = cmd->se_dev; 3101 struct se_tmr_req *tmr = cmd->se_tmr_req; 3102 int ret; 3103 3104 switch (tmr->function) { 3105 case TMR_ABORT_TASK: 3106 core_tmr_abort_task(dev, tmr, cmd->se_sess); 3107 break; 3108 case TMR_ABORT_TASK_SET: 3109 case TMR_CLEAR_ACA: 3110 case TMR_CLEAR_TASK_SET: 3111 tmr->response = TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED; 3112 break; 3113 case TMR_LUN_RESET: 3114 ret = core_tmr_lun_reset(dev, tmr, NULL, NULL); 3115 tmr->response = (!ret) ? TMR_FUNCTION_COMPLETE : 3116 TMR_FUNCTION_REJECTED; 3117 break; 3118 case TMR_TARGET_WARM_RESET: 3119 tmr->response = TMR_FUNCTION_REJECTED; 3120 break; 3121 case TMR_TARGET_COLD_RESET: 3122 tmr->response = TMR_FUNCTION_REJECTED; 3123 break; 3124 default: 3125 pr_err("Uknown TMR function: 0x%02x.\n", 3126 tmr->function); 3127 tmr->response = TMR_FUNCTION_REJECTED; 3128 break; 3129 } 3130 3131 cmd->t_state = TRANSPORT_ISTATE_PROCESSING; 3132 cmd->se_tfo->queue_tm_rsp(cmd); 3133 3134 transport_cmd_check_stop_to_fabric(cmd); 3135 } 3136 3137 int transport_generic_handle_tmr( 3138 struct se_cmd *cmd) 3139 { 3140 INIT_WORK(&cmd->work, target_tmr_work); 3141 queue_work(cmd->se_dev->tmr_wq, &cmd->work); 3142 return 0; 3143 } 3144 EXPORT_SYMBOL(transport_generic_handle_tmr); 3145