1 /******************************************************************************* 2 * 3 * This file contains the Linux/SCSI LLD virtual SCSI initiator driver 4 * for emulated SAS initiator ports 5 * 6 * © Copyright 2011 RisingTide Systems LLC. 7 * 8 * Licensed to the Linux Foundation under the General Public License (GPL) version 2. 9 * 10 * Author: Nicholas A. Bellinger <nab@risingtidesystems.com> 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 ****************************************************************************/ 22 23 #include <linux/module.h> 24 #include <linux/moduleparam.h> 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <linux/types.h> 28 #include <linux/configfs.h> 29 #include <scsi/scsi.h> 30 #include <scsi/scsi_tcq.h> 31 #include <scsi/scsi_host.h> 32 #include <scsi/scsi_device.h> 33 #include <scsi/scsi_cmnd.h> 34 35 #include <target/target_core_base.h> 36 #include <target/target_core_transport.h> 37 #include <target/target_core_fabric_ops.h> 38 #include <target/target_core_fabric_configfs.h> 39 #include <target/target_core_fabric_lib.h> 40 #include <target/target_core_configfs.h> 41 #include <target/target_core_device.h> 42 #include <target/target_core_tpg.h> 43 #include <target/target_core_tmr.h> 44 45 #include "tcm_loop.h" 46 47 #define to_tcm_loop_hba(hba) container_of(hba, struct tcm_loop_hba, dev) 48 49 /* Local pointer to allocated TCM configfs fabric module */ 50 static struct target_fabric_configfs *tcm_loop_fabric_configfs; 51 52 static struct kmem_cache *tcm_loop_cmd_cache; 53 54 static int tcm_loop_hba_no_cnt; 55 56 /* 57 * Allocate a tcm_loop cmd descriptor from target_core_mod code 58 * 59 * Can be called from interrupt context in tcm_loop_queuecommand() below 60 */ 61 static struct se_cmd *tcm_loop_allocate_core_cmd( 62 struct tcm_loop_hba *tl_hba, 63 struct se_portal_group *se_tpg, 64 struct scsi_cmnd *sc) 65 { 66 struct se_cmd *se_cmd; 67 struct se_session *se_sess; 68 struct tcm_loop_nexus *tl_nexus = tl_hba->tl_nexus; 69 struct tcm_loop_cmd *tl_cmd; 70 int sam_task_attr; 71 72 if (!tl_nexus) { 73 scmd_printk(KERN_ERR, sc, "TCM_Loop I_T Nexus" 74 " does not exist\n"); 75 set_host_byte(sc, DID_ERROR); 76 return NULL; 77 } 78 se_sess = tl_nexus->se_sess; 79 80 tl_cmd = kmem_cache_zalloc(tcm_loop_cmd_cache, GFP_ATOMIC); 81 if (!tl_cmd) { 82 pr_err("Unable to allocate struct tcm_loop_cmd\n"); 83 set_host_byte(sc, DID_ERROR); 84 return NULL; 85 } 86 se_cmd = &tl_cmd->tl_se_cmd; 87 /* 88 * Save the pointer to struct scsi_cmnd *sc 89 */ 90 tl_cmd->sc = sc; 91 /* 92 * Locate the SAM Task Attr from struct scsi_cmnd * 93 */ 94 if (sc->device->tagged_supported) { 95 switch (sc->tag) { 96 case HEAD_OF_QUEUE_TAG: 97 sam_task_attr = MSG_HEAD_TAG; 98 break; 99 case ORDERED_QUEUE_TAG: 100 sam_task_attr = MSG_ORDERED_TAG; 101 break; 102 default: 103 sam_task_attr = MSG_SIMPLE_TAG; 104 break; 105 } 106 } else 107 sam_task_attr = MSG_SIMPLE_TAG; 108 109 /* 110 * Initialize struct se_cmd descriptor from target_core_mod infrastructure 111 */ 112 transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 113 scsi_bufflen(sc), sc->sc_data_direction, sam_task_attr, 114 &tl_cmd->tl_sense_buf[0]); 115 116 /* 117 * Signal BIDI usage with T_TASK(cmd)->t_tasks_bidi 118 */ 119 if (scsi_bidi_cmnd(sc)) 120 se_cmd->t_tasks_bidi = 1; 121 /* 122 * Locate the struct se_lun pointer and attach it to struct se_cmd 123 */ 124 if (transport_lookup_cmd_lun(se_cmd, tl_cmd->sc->device->lun) < 0) { 125 kmem_cache_free(tcm_loop_cmd_cache, tl_cmd); 126 set_host_byte(sc, DID_NO_CONNECT); 127 return NULL; 128 } 129 130 return se_cmd; 131 } 132 133 /* 134 * Called by struct target_core_fabric_ops->new_cmd_map() 135 * 136 * Always called in process context. A non zero return value 137 * here will signal to handle an exception based on the return code. 138 */ 139 static int tcm_loop_new_cmd_map(struct se_cmd *se_cmd) 140 { 141 struct tcm_loop_cmd *tl_cmd = container_of(se_cmd, 142 struct tcm_loop_cmd, tl_se_cmd); 143 struct scsi_cmnd *sc = tl_cmd->sc; 144 struct scatterlist *sgl_bidi = NULL; 145 u32 sgl_bidi_count = 0; 146 int ret; 147 /* 148 * Allocate the necessary tasks to complete the received CDB+data 149 */ 150 ret = transport_generic_allocate_tasks(se_cmd, sc->cmnd); 151 if (ret == -ENOMEM) { 152 /* Out of Resources */ 153 return PYX_TRANSPORT_LU_COMM_FAILURE; 154 } else if (ret == -EINVAL) { 155 /* 156 * Handle case for SAM_STAT_RESERVATION_CONFLICT 157 */ 158 if (se_cmd->se_cmd_flags & SCF_SCSI_RESERVATION_CONFLICT) 159 return PYX_TRANSPORT_RESERVATION_CONFLICT; 160 /* 161 * Otherwise, return SAM_STAT_CHECK_CONDITION and return 162 * sense data. 163 */ 164 return PYX_TRANSPORT_USE_SENSE_REASON; 165 } 166 167 /* 168 * For BIDI commands, pass in the extra READ buffer 169 * to transport_generic_map_mem_to_cmd() below.. 170 */ 171 if (se_cmd->t_tasks_bidi) { 172 struct scsi_data_buffer *sdb = scsi_in(sc); 173 174 sgl_bidi = sdb->table.sgl; 175 sgl_bidi_count = sdb->table.nents; 176 } 177 178 /* Tell the core about our preallocated memory */ 179 ret = transport_generic_map_mem_to_cmd(se_cmd, scsi_sglist(sc), 180 scsi_sg_count(sc), sgl_bidi, sgl_bidi_count); 181 if (ret < 0) 182 return PYX_TRANSPORT_LU_COMM_FAILURE; 183 184 return 0; 185 } 186 187 /* 188 * Called from struct target_core_fabric_ops->check_stop_free() 189 */ 190 static void tcm_loop_check_stop_free(struct se_cmd *se_cmd) 191 { 192 /* 193 * Do not release struct se_cmd's containing a valid TMR 194 * pointer. These will be released directly in tcm_loop_device_reset() 195 * with transport_generic_free_cmd(). 196 */ 197 if (se_cmd->se_tmr_req) 198 return; 199 /* 200 * Release the struct se_cmd, which will make a callback to release 201 * struct tcm_loop_cmd * in tcm_loop_deallocate_core_cmd() 202 */ 203 transport_generic_free_cmd(se_cmd, 0, 0); 204 } 205 206 static void tcm_loop_release_cmd(struct se_cmd *se_cmd) 207 { 208 struct tcm_loop_cmd *tl_cmd = container_of(se_cmd, 209 struct tcm_loop_cmd, tl_se_cmd); 210 211 kmem_cache_free(tcm_loop_cmd_cache, tl_cmd); 212 } 213 214 static int tcm_loop_proc_info(struct Scsi_Host *host, char *buffer, 215 char **start, off_t offset, 216 int length, int inout) 217 { 218 return sprintf(buffer, "tcm_loop_proc_info()\n"); 219 } 220 221 static int tcm_loop_driver_probe(struct device *); 222 static int tcm_loop_driver_remove(struct device *); 223 224 static int pseudo_lld_bus_match(struct device *dev, 225 struct device_driver *dev_driver) 226 { 227 return 1; 228 } 229 230 static struct bus_type tcm_loop_lld_bus = { 231 .name = "tcm_loop_bus", 232 .match = pseudo_lld_bus_match, 233 .probe = tcm_loop_driver_probe, 234 .remove = tcm_loop_driver_remove, 235 }; 236 237 static struct device_driver tcm_loop_driverfs = { 238 .name = "tcm_loop", 239 .bus = &tcm_loop_lld_bus, 240 }; 241 /* 242 * Used with root_device_register() in tcm_loop_alloc_core_bus() below 243 */ 244 struct device *tcm_loop_primary; 245 246 /* 247 * Copied from drivers/scsi/libfc/fc_fcp.c:fc_change_queue_depth() and 248 * drivers/scsi/libiscsi.c:iscsi_change_queue_depth() 249 */ 250 static int tcm_loop_change_queue_depth( 251 struct scsi_device *sdev, 252 int depth, 253 int reason) 254 { 255 switch (reason) { 256 case SCSI_QDEPTH_DEFAULT: 257 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 258 break; 259 case SCSI_QDEPTH_QFULL: 260 scsi_track_queue_full(sdev, depth); 261 break; 262 case SCSI_QDEPTH_RAMP_UP: 263 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 264 break; 265 default: 266 return -EOPNOTSUPP; 267 } 268 return sdev->queue_depth; 269 } 270 271 /* 272 * Main entry point from struct scsi_host_template for incoming SCSI CDB+Data 273 * from Linux/SCSI subsystem for SCSI low level device drivers (LLDs) 274 */ 275 static int tcm_loop_queuecommand( 276 struct Scsi_Host *sh, 277 struct scsi_cmnd *sc) 278 { 279 struct se_cmd *se_cmd; 280 struct se_portal_group *se_tpg; 281 struct tcm_loop_hba *tl_hba; 282 struct tcm_loop_tpg *tl_tpg; 283 284 pr_debug("tcm_loop_queuecommand() %d:%d:%d:%d got CDB: 0x%02x" 285 " scsi_buf_len: %u\n", sc->device->host->host_no, 286 sc->device->id, sc->device->channel, sc->device->lun, 287 sc->cmnd[0], scsi_bufflen(sc)); 288 /* 289 * Locate the tcm_loop_hba_t pointer 290 */ 291 tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host); 292 tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id]; 293 se_tpg = &tl_tpg->tl_se_tpg; 294 /* 295 * Determine the SAM Task Attribute and allocate tl_cmd and 296 * tl_cmd->tl_se_cmd from TCM infrastructure 297 */ 298 se_cmd = tcm_loop_allocate_core_cmd(tl_hba, se_tpg, sc); 299 if (!se_cmd) { 300 sc->scsi_done(sc); 301 return 0; 302 } 303 /* 304 * Queue up the newly allocated to be processed in TCM thread context. 305 */ 306 transport_generic_handle_cdb_map(se_cmd); 307 return 0; 308 } 309 310 /* 311 * Called from SCSI EH process context to issue a LUN_RESET TMR 312 * to struct scsi_device 313 */ 314 static int tcm_loop_device_reset(struct scsi_cmnd *sc) 315 { 316 struct se_cmd *se_cmd = NULL; 317 struct se_portal_group *se_tpg; 318 struct se_session *se_sess; 319 struct tcm_loop_cmd *tl_cmd = NULL; 320 struct tcm_loop_hba *tl_hba; 321 struct tcm_loop_nexus *tl_nexus; 322 struct tcm_loop_tmr *tl_tmr = NULL; 323 struct tcm_loop_tpg *tl_tpg; 324 int ret = FAILED; 325 /* 326 * Locate the tcm_loop_hba_t pointer 327 */ 328 tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host); 329 /* 330 * Locate the tl_nexus and se_sess pointers 331 */ 332 tl_nexus = tl_hba->tl_nexus; 333 if (!tl_nexus) { 334 pr_err("Unable to perform device reset without" 335 " active I_T Nexus\n"); 336 return FAILED; 337 } 338 se_sess = tl_nexus->se_sess; 339 /* 340 * Locate the tl_tpg and se_tpg pointers from TargetID in sc->device->id 341 */ 342 tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id]; 343 se_tpg = &tl_tpg->tl_se_tpg; 344 345 tl_cmd = kmem_cache_zalloc(tcm_loop_cmd_cache, GFP_KERNEL); 346 if (!tl_cmd) { 347 pr_err("Unable to allocate memory for tl_cmd\n"); 348 return FAILED; 349 } 350 351 tl_tmr = kzalloc(sizeof(struct tcm_loop_tmr), GFP_KERNEL); 352 if (!tl_tmr) { 353 pr_err("Unable to allocate memory for tl_tmr\n"); 354 goto release; 355 } 356 init_waitqueue_head(&tl_tmr->tl_tmr_wait); 357 358 se_cmd = &tl_cmd->tl_se_cmd; 359 /* 360 * Initialize struct se_cmd descriptor from target_core_mod infrastructure 361 */ 362 transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 0, 363 DMA_NONE, MSG_SIMPLE_TAG, 364 &tl_cmd->tl_sense_buf[0]); 365 /* 366 * Allocate the LUN_RESET TMR 367 */ 368 se_cmd->se_tmr_req = core_tmr_alloc_req(se_cmd, tl_tmr, 369 TMR_LUN_RESET); 370 if (IS_ERR(se_cmd->se_tmr_req)) 371 goto release; 372 /* 373 * Locate the underlying TCM struct se_lun from sc->device->lun 374 */ 375 if (transport_lookup_tmr_lun(se_cmd, sc->device->lun) < 0) 376 goto release; 377 /* 378 * Queue the TMR to TCM Core and sleep waiting for tcm_loop_queue_tm_rsp() 379 * to wake us up. 380 */ 381 transport_generic_handle_tmr(se_cmd); 382 wait_event(tl_tmr->tl_tmr_wait, atomic_read(&tl_tmr->tmr_complete)); 383 /* 384 * The TMR LUN_RESET has completed, check the response status and 385 * then release allocations. 386 */ 387 ret = (se_cmd->se_tmr_req->response == TMR_FUNCTION_COMPLETE) ? 388 SUCCESS : FAILED; 389 release: 390 if (se_cmd) 391 transport_generic_free_cmd(se_cmd, 1, 0); 392 else 393 kmem_cache_free(tcm_loop_cmd_cache, tl_cmd); 394 kfree(tl_tmr); 395 return ret; 396 } 397 398 static int tcm_loop_slave_alloc(struct scsi_device *sd) 399 { 400 set_bit(QUEUE_FLAG_BIDI, &sd->request_queue->queue_flags); 401 return 0; 402 } 403 404 static int tcm_loop_slave_configure(struct scsi_device *sd) 405 { 406 return 0; 407 } 408 409 static struct scsi_host_template tcm_loop_driver_template = { 410 .proc_info = tcm_loop_proc_info, 411 .proc_name = "tcm_loopback", 412 .name = "TCM_Loopback", 413 .queuecommand = tcm_loop_queuecommand, 414 .change_queue_depth = tcm_loop_change_queue_depth, 415 .eh_device_reset_handler = tcm_loop_device_reset, 416 .can_queue = TL_SCSI_CAN_QUEUE, 417 .this_id = -1, 418 .sg_tablesize = TL_SCSI_SG_TABLESIZE, 419 .cmd_per_lun = TL_SCSI_CMD_PER_LUN, 420 .max_sectors = TL_SCSI_MAX_SECTORS, 421 .use_clustering = DISABLE_CLUSTERING, 422 .slave_alloc = tcm_loop_slave_alloc, 423 .slave_configure = tcm_loop_slave_configure, 424 .module = THIS_MODULE, 425 }; 426 427 static int tcm_loop_driver_probe(struct device *dev) 428 { 429 struct tcm_loop_hba *tl_hba; 430 struct Scsi_Host *sh; 431 int error; 432 433 tl_hba = to_tcm_loop_hba(dev); 434 435 sh = scsi_host_alloc(&tcm_loop_driver_template, 436 sizeof(struct tcm_loop_hba)); 437 if (!sh) { 438 pr_err("Unable to allocate struct scsi_host\n"); 439 return -ENODEV; 440 } 441 tl_hba->sh = sh; 442 443 /* 444 * Assign the struct tcm_loop_hba pointer to struct Scsi_Host->hostdata 445 */ 446 *((struct tcm_loop_hba **)sh->hostdata) = tl_hba; 447 /* 448 * Setup single ID, Channel and LUN for now.. 449 */ 450 sh->max_id = 2; 451 sh->max_lun = 0; 452 sh->max_channel = 0; 453 sh->max_cmd_len = TL_SCSI_MAX_CMD_LEN; 454 455 error = scsi_add_host(sh, &tl_hba->dev); 456 if (error) { 457 pr_err("%s: scsi_add_host failed\n", __func__); 458 scsi_host_put(sh); 459 return -ENODEV; 460 } 461 return 0; 462 } 463 464 static int tcm_loop_driver_remove(struct device *dev) 465 { 466 struct tcm_loop_hba *tl_hba; 467 struct Scsi_Host *sh; 468 469 tl_hba = to_tcm_loop_hba(dev); 470 sh = tl_hba->sh; 471 472 scsi_remove_host(sh); 473 scsi_host_put(sh); 474 return 0; 475 } 476 477 static void tcm_loop_release_adapter(struct device *dev) 478 { 479 struct tcm_loop_hba *tl_hba = to_tcm_loop_hba(dev); 480 481 kfree(tl_hba); 482 } 483 484 /* 485 * Called from tcm_loop_make_scsi_hba() in tcm_loop_configfs.c 486 */ 487 static int tcm_loop_setup_hba_bus(struct tcm_loop_hba *tl_hba, int tcm_loop_host_id) 488 { 489 int ret; 490 491 tl_hba->dev.bus = &tcm_loop_lld_bus; 492 tl_hba->dev.parent = tcm_loop_primary; 493 tl_hba->dev.release = &tcm_loop_release_adapter; 494 dev_set_name(&tl_hba->dev, "tcm_loop_adapter_%d", tcm_loop_host_id); 495 496 ret = device_register(&tl_hba->dev); 497 if (ret) { 498 pr_err("device_register() failed for" 499 " tl_hba->dev: %d\n", ret); 500 return -ENODEV; 501 } 502 503 return 0; 504 } 505 506 /* 507 * Called from tcm_loop_fabric_init() in tcl_loop_fabric.c to load the emulated 508 * tcm_loop SCSI bus. 509 */ 510 static int tcm_loop_alloc_core_bus(void) 511 { 512 int ret; 513 514 tcm_loop_primary = root_device_register("tcm_loop_0"); 515 if (IS_ERR(tcm_loop_primary)) { 516 pr_err("Unable to allocate tcm_loop_primary\n"); 517 return PTR_ERR(tcm_loop_primary); 518 } 519 520 ret = bus_register(&tcm_loop_lld_bus); 521 if (ret) { 522 pr_err("bus_register() failed for tcm_loop_lld_bus\n"); 523 goto dev_unreg; 524 } 525 526 ret = driver_register(&tcm_loop_driverfs); 527 if (ret) { 528 pr_err("driver_register() failed for" 529 "tcm_loop_driverfs\n"); 530 goto bus_unreg; 531 } 532 533 pr_debug("Initialized TCM Loop Core Bus\n"); 534 return ret; 535 536 bus_unreg: 537 bus_unregister(&tcm_loop_lld_bus); 538 dev_unreg: 539 root_device_unregister(tcm_loop_primary); 540 return ret; 541 } 542 543 static void tcm_loop_release_core_bus(void) 544 { 545 driver_unregister(&tcm_loop_driverfs); 546 bus_unregister(&tcm_loop_lld_bus); 547 root_device_unregister(tcm_loop_primary); 548 549 pr_debug("Releasing TCM Loop Core BUS\n"); 550 } 551 552 static char *tcm_loop_get_fabric_name(void) 553 { 554 return "loopback"; 555 } 556 557 static u8 tcm_loop_get_fabric_proto_ident(struct se_portal_group *se_tpg) 558 { 559 struct tcm_loop_tpg *tl_tpg = 560 (struct tcm_loop_tpg *)se_tpg->se_tpg_fabric_ptr; 561 struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba; 562 /* 563 * tl_proto_id is set at tcm_loop_configfs.c:tcm_loop_make_scsi_hba() 564 * time based on the protocol dependent prefix of the passed configfs group. 565 * 566 * Based upon tl_proto_id, TCM_Loop emulates the requested fabric 567 * ProtocolID using target_core_fabric_lib.c symbols. 568 */ 569 switch (tl_hba->tl_proto_id) { 570 case SCSI_PROTOCOL_SAS: 571 return sas_get_fabric_proto_ident(se_tpg); 572 case SCSI_PROTOCOL_FCP: 573 return fc_get_fabric_proto_ident(se_tpg); 574 case SCSI_PROTOCOL_ISCSI: 575 return iscsi_get_fabric_proto_ident(se_tpg); 576 default: 577 pr_err("Unknown tl_proto_id: 0x%02x, using" 578 " SAS emulation\n", tl_hba->tl_proto_id); 579 break; 580 } 581 582 return sas_get_fabric_proto_ident(se_tpg); 583 } 584 585 static char *tcm_loop_get_endpoint_wwn(struct se_portal_group *se_tpg) 586 { 587 struct tcm_loop_tpg *tl_tpg = 588 (struct tcm_loop_tpg *)se_tpg->se_tpg_fabric_ptr; 589 /* 590 * Return the passed NAA identifier for the SAS Target Port 591 */ 592 return &tl_tpg->tl_hba->tl_wwn_address[0]; 593 } 594 595 static u16 tcm_loop_get_tag(struct se_portal_group *se_tpg) 596 { 597 struct tcm_loop_tpg *tl_tpg = 598 (struct tcm_loop_tpg *)se_tpg->se_tpg_fabric_ptr; 599 /* 600 * This Tag is used when forming SCSI Name identifier in EVPD=1 0x83 601 * to represent the SCSI Target Port. 602 */ 603 return tl_tpg->tl_tpgt; 604 } 605 606 static u32 tcm_loop_get_default_depth(struct se_portal_group *se_tpg) 607 { 608 return 1; 609 } 610 611 static u32 tcm_loop_get_pr_transport_id( 612 struct se_portal_group *se_tpg, 613 struct se_node_acl *se_nacl, 614 struct t10_pr_registration *pr_reg, 615 int *format_code, 616 unsigned char *buf) 617 { 618 struct tcm_loop_tpg *tl_tpg = 619 (struct tcm_loop_tpg *)se_tpg->se_tpg_fabric_ptr; 620 struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba; 621 622 switch (tl_hba->tl_proto_id) { 623 case SCSI_PROTOCOL_SAS: 624 return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg, 625 format_code, buf); 626 case SCSI_PROTOCOL_FCP: 627 return fc_get_pr_transport_id(se_tpg, se_nacl, pr_reg, 628 format_code, buf); 629 case SCSI_PROTOCOL_ISCSI: 630 return iscsi_get_pr_transport_id(se_tpg, se_nacl, pr_reg, 631 format_code, buf); 632 default: 633 pr_err("Unknown tl_proto_id: 0x%02x, using" 634 " SAS emulation\n", tl_hba->tl_proto_id); 635 break; 636 } 637 638 return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg, 639 format_code, buf); 640 } 641 642 static u32 tcm_loop_get_pr_transport_id_len( 643 struct se_portal_group *se_tpg, 644 struct se_node_acl *se_nacl, 645 struct t10_pr_registration *pr_reg, 646 int *format_code) 647 { 648 struct tcm_loop_tpg *tl_tpg = 649 (struct tcm_loop_tpg *)se_tpg->se_tpg_fabric_ptr; 650 struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba; 651 652 switch (tl_hba->tl_proto_id) { 653 case SCSI_PROTOCOL_SAS: 654 return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg, 655 format_code); 656 case SCSI_PROTOCOL_FCP: 657 return fc_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg, 658 format_code); 659 case SCSI_PROTOCOL_ISCSI: 660 return iscsi_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg, 661 format_code); 662 default: 663 pr_err("Unknown tl_proto_id: 0x%02x, using" 664 " SAS emulation\n", tl_hba->tl_proto_id); 665 break; 666 } 667 668 return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg, 669 format_code); 670 } 671 672 /* 673 * Used for handling SCSI fabric dependent TransportIDs in SPC-3 and above 674 * Persistent Reservation SPEC_I_PT=1 and PROUT REGISTER_AND_MOVE operations. 675 */ 676 static char *tcm_loop_parse_pr_out_transport_id( 677 struct se_portal_group *se_tpg, 678 const char *buf, 679 u32 *out_tid_len, 680 char **port_nexus_ptr) 681 { 682 struct tcm_loop_tpg *tl_tpg = 683 (struct tcm_loop_tpg *)se_tpg->se_tpg_fabric_ptr; 684 struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba; 685 686 switch (tl_hba->tl_proto_id) { 687 case SCSI_PROTOCOL_SAS: 688 return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len, 689 port_nexus_ptr); 690 case SCSI_PROTOCOL_FCP: 691 return fc_parse_pr_out_transport_id(se_tpg, buf, out_tid_len, 692 port_nexus_ptr); 693 case SCSI_PROTOCOL_ISCSI: 694 return iscsi_parse_pr_out_transport_id(se_tpg, buf, out_tid_len, 695 port_nexus_ptr); 696 default: 697 pr_err("Unknown tl_proto_id: 0x%02x, using" 698 " SAS emulation\n", tl_hba->tl_proto_id); 699 break; 700 } 701 702 return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len, 703 port_nexus_ptr); 704 } 705 706 /* 707 * Returning (1) here allows for target_core_mod struct se_node_acl to be generated 708 * based upon the incoming fabric dependent SCSI Initiator Port 709 */ 710 static int tcm_loop_check_demo_mode(struct se_portal_group *se_tpg) 711 { 712 return 1; 713 } 714 715 static int tcm_loop_check_demo_mode_cache(struct se_portal_group *se_tpg) 716 { 717 return 0; 718 } 719 720 /* 721 * Allow I_T Nexus full READ-WRITE access without explict Initiator Node ACLs for 722 * local virtual Linux/SCSI LLD passthrough into VM hypervisor guest 723 */ 724 static int tcm_loop_check_demo_mode_write_protect(struct se_portal_group *se_tpg) 725 { 726 return 0; 727 } 728 729 /* 730 * Because TCM_Loop does not use explict ACLs and MappedLUNs, this will 731 * never be called for TCM_Loop by target_core_fabric_configfs.c code. 732 * It has been added here as a nop for target_fabric_tf_ops_check() 733 */ 734 static int tcm_loop_check_prod_mode_write_protect(struct se_portal_group *se_tpg) 735 { 736 return 0; 737 } 738 739 static struct se_node_acl *tcm_loop_tpg_alloc_fabric_acl( 740 struct se_portal_group *se_tpg) 741 { 742 struct tcm_loop_nacl *tl_nacl; 743 744 tl_nacl = kzalloc(sizeof(struct tcm_loop_nacl), GFP_KERNEL); 745 if (!tl_nacl) { 746 pr_err("Unable to allocate struct tcm_loop_nacl\n"); 747 return NULL; 748 } 749 750 return &tl_nacl->se_node_acl; 751 } 752 753 static void tcm_loop_tpg_release_fabric_acl( 754 struct se_portal_group *se_tpg, 755 struct se_node_acl *se_nacl) 756 { 757 struct tcm_loop_nacl *tl_nacl = container_of(se_nacl, 758 struct tcm_loop_nacl, se_node_acl); 759 760 kfree(tl_nacl); 761 } 762 763 static u32 tcm_loop_get_inst_index(struct se_portal_group *se_tpg) 764 { 765 return 1; 766 } 767 768 static int tcm_loop_is_state_remove(struct se_cmd *se_cmd) 769 { 770 /* 771 * Assume struct scsi_cmnd is not in remove state.. 772 */ 773 return 0; 774 } 775 776 static int tcm_loop_sess_logged_in(struct se_session *se_sess) 777 { 778 /* 779 * Assume that TL Nexus is always active 780 */ 781 return 1; 782 } 783 784 static u32 tcm_loop_sess_get_index(struct se_session *se_sess) 785 { 786 return 1; 787 } 788 789 static void tcm_loop_set_default_node_attributes(struct se_node_acl *se_acl) 790 { 791 return; 792 } 793 794 static u32 tcm_loop_get_task_tag(struct se_cmd *se_cmd) 795 { 796 return 1; 797 } 798 799 static int tcm_loop_get_cmd_state(struct se_cmd *se_cmd) 800 { 801 struct tcm_loop_cmd *tl_cmd = container_of(se_cmd, 802 struct tcm_loop_cmd, tl_se_cmd); 803 804 return tl_cmd->sc_cmd_state; 805 } 806 807 static int tcm_loop_shutdown_session(struct se_session *se_sess) 808 { 809 return 0; 810 } 811 812 static void tcm_loop_close_session(struct se_session *se_sess) 813 { 814 return; 815 }; 816 817 static void tcm_loop_stop_session( 818 struct se_session *se_sess, 819 int sess_sleep, 820 int conn_sleep) 821 { 822 return; 823 } 824 825 static void tcm_loop_fall_back_to_erl0(struct se_session *se_sess) 826 { 827 return; 828 } 829 830 static int tcm_loop_write_pending(struct se_cmd *se_cmd) 831 { 832 /* 833 * Since Linux/SCSI has already sent down a struct scsi_cmnd 834 * sc->sc_data_direction of DMA_TO_DEVICE with struct scatterlist array 835 * memory, and memory has already been mapped to struct se_cmd->t_mem_list 836 * format with transport_generic_map_mem_to_cmd(). 837 * 838 * We now tell TCM to add this WRITE CDB directly into the TCM storage 839 * object execution queue. 840 */ 841 transport_generic_process_write(se_cmd); 842 return 0; 843 } 844 845 static int tcm_loop_write_pending_status(struct se_cmd *se_cmd) 846 { 847 return 0; 848 } 849 850 static int tcm_loop_queue_data_in(struct se_cmd *se_cmd) 851 { 852 struct tcm_loop_cmd *tl_cmd = container_of(se_cmd, 853 struct tcm_loop_cmd, tl_se_cmd); 854 struct scsi_cmnd *sc = tl_cmd->sc; 855 856 pr_debug("tcm_loop_queue_data_in() called for scsi_cmnd: %p" 857 " cdb: 0x%02x\n", sc, sc->cmnd[0]); 858 859 sc->result = SAM_STAT_GOOD; 860 set_host_byte(sc, DID_OK); 861 sc->scsi_done(sc); 862 return 0; 863 } 864 865 static int tcm_loop_queue_status(struct se_cmd *se_cmd) 866 { 867 struct tcm_loop_cmd *tl_cmd = container_of(se_cmd, 868 struct tcm_loop_cmd, tl_se_cmd); 869 struct scsi_cmnd *sc = tl_cmd->sc; 870 871 pr_debug("tcm_loop_queue_status() called for scsi_cmnd: %p" 872 " cdb: 0x%02x\n", sc, sc->cmnd[0]); 873 874 if (se_cmd->sense_buffer && 875 ((se_cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) || 876 (se_cmd->se_cmd_flags & SCF_EMULATED_TASK_SENSE))) { 877 878 memcpy(sc->sense_buffer, se_cmd->sense_buffer, 879 SCSI_SENSE_BUFFERSIZE); 880 sc->result = SAM_STAT_CHECK_CONDITION; 881 set_driver_byte(sc, DRIVER_SENSE); 882 } else 883 sc->result = se_cmd->scsi_status; 884 885 set_host_byte(sc, DID_OK); 886 sc->scsi_done(sc); 887 return 0; 888 } 889 890 static int tcm_loop_queue_tm_rsp(struct se_cmd *se_cmd) 891 { 892 struct se_tmr_req *se_tmr = se_cmd->se_tmr_req; 893 struct tcm_loop_tmr *tl_tmr = se_tmr->fabric_tmr_ptr; 894 /* 895 * The SCSI EH thread will be sleeping on se_tmr->tl_tmr_wait, go ahead 896 * and wake up the wait_queue_head_t in tcm_loop_device_reset() 897 */ 898 atomic_set(&tl_tmr->tmr_complete, 1); 899 wake_up(&tl_tmr->tl_tmr_wait); 900 return 0; 901 } 902 903 static u16 tcm_loop_set_fabric_sense_len(struct se_cmd *se_cmd, u32 sense_length) 904 { 905 return 0; 906 } 907 908 static u16 tcm_loop_get_fabric_sense_len(void) 909 { 910 return 0; 911 } 912 913 static char *tcm_loop_dump_proto_id(struct tcm_loop_hba *tl_hba) 914 { 915 switch (tl_hba->tl_proto_id) { 916 case SCSI_PROTOCOL_SAS: 917 return "SAS"; 918 case SCSI_PROTOCOL_FCP: 919 return "FCP"; 920 case SCSI_PROTOCOL_ISCSI: 921 return "iSCSI"; 922 default: 923 break; 924 } 925 926 return "Unknown"; 927 } 928 929 /* Start items for tcm_loop_port_cit */ 930 931 static int tcm_loop_port_link( 932 struct se_portal_group *se_tpg, 933 struct se_lun *lun) 934 { 935 struct tcm_loop_tpg *tl_tpg = container_of(se_tpg, 936 struct tcm_loop_tpg, tl_se_tpg); 937 struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba; 938 939 atomic_inc(&tl_tpg->tl_tpg_port_count); 940 smp_mb__after_atomic_inc(); 941 /* 942 * Add Linux/SCSI struct scsi_device by HCTL 943 */ 944 scsi_add_device(tl_hba->sh, 0, tl_tpg->tl_tpgt, lun->unpacked_lun); 945 946 pr_debug("TCM_Loop_ConfigFS: Port Link Successful\n"); 947 return 0; 948 } 949 950 static void tcm_loop_port_unlink( 951 struct se_portal_group *se_tpg, 952 struct se_lun *se_lun) 953 { 954 struct scsi_device *sd; 955 struct tcm_loop_hba *tl_hba; 956 struct tcm_loop_tpg *tl_tpg; 957 958 tl_tpg = container_of(se_tpg, struct tcm_loop_tpg, tl_se_tpg); 959 tl_hba = tl_tpg->tl_hba; 960 961 sd = scsi_device_lookup(tl_hba->sh, 0, tl_tpg->tl_tpgt, 962 se_lun->unpacked_lun); 963 if (!sd) { 964 pr_err("Unable to locate struct scsi_device for %d:%d:" 965 "%d\n", 0, tl_tpg->tl_tpgt, se_lun->unpacked_lun); 966 return; 967 } 968 /* 969 * Remove Linux/SCSI struct scsi_device by HCTL 970 */ 971 scsi_remove_device(sd); 972 scsi_device_put(sd); 973 974 atomic_dec(&tl_tpg->tl_tpg_port_count); 975 smp_mb__after_atomic_dec(); 976 977 pr_debug("TCM_Loop_ConfigFS: Port Unlink Successful\n"); 978 } 979 980 /* End items for tcm_loop_port_cit */ 981 982 /* Start items for tcm_loop_nexus_cit */ 983 984 static int tcm_loop_make_nexus( 985 struct tcm_loop_tpg *tl_tpg, 986 const char *name) 987 { 988 struct se_portal_group *se_tpg; 989 struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba; 990 struct tcm_loop_nexus *tl_nexus; 991 int ret = -ENOMEM; 992 993 if (tl_tpg->tl_hba->tl_nexus) { 994 pr_debug("tl_tpg->tl_hba->tl_nexus already exists\n"); 995 return -EEXIST; 996 } 997 se_tpg = &tl_tpg->tl_se_tpg; 998 999 tl_nexus = kzalloc(sizeof(struct tcm_loop_nexus), GFP_KERNEL); 1000 if (!tl_nexus) { 1001 pr_err("Unable to allocate struct tcm_loop_nexus\n"); 1002 return -ENOMEM; 1003 } 1004 /* 1005 * Initialize the struct se_session pointer 1006 */ 1007 tl_nexus->se_sess = transport_init_session(); 1008 if (IS_ERR(tl_nexus->se_sess)) { 1009 ret = PTR_ERR(tl_nexus->se_sess); 1010 goto out; 1011 } 1012 /* 1013 * Since we are running in 'demo mode' this call with generate a 1014 * struct se_node_acl for the tcm_loop struct se_portal_group with the SCSI 1015 * Initiator port name of the passed configfs group 'name'. 1016 */ 1017 tl_nexus->se_sess->se_node_acl = core_tpg_check_initiator_node_acl( 1018 se_tpg, (unsigned char *)name); 1019 if (!tl_nexus->se_sess->se_node_acl) { 1020 transport_free_session(tl_nexus->se_sess); 1021 goto out; 1022 } 1023 /* 1024 * Now, register the SAS I_T Nexus as active with the call to 1025 * transport_register_session() 1026 */ 1027 __transport_register_session(se_tpg, tl_nexus->se_sess->se_node_acl, 1028 tl_nexus->se_sess, tl_nexus); 1029 tl_tpg->tl_hba->tl_nexus = tl_nexus; 1030 pr_debug("TCM_Loop_ConfigFS: Established I_T Nexus to emulated" 1031 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tl_hba), 1032 name); 1033 return 0; 1034 1035 out: 1036 kfree(tl_nexus); 1037 return ret; 1038 } 1039 1040 static int tcm_loop_drop_nexus( 1041 struct tcm_loop_tpg *tpg) 1042 { 1043 struct se_session *se_sess; 1044 struct tcm_loop_nexus *tl_nexus; 1045 struct tcm_loop_hba *tl_hba = tpg->tl_hba; 1046 1047 tl_nexus = tpg->tl_hba->tl_nexus; 1048 if (!tl_nexus) 1049 return -ENODEV; 1050 1051 se_sess = tl_nexus->se_sess; 1052 if (!se_sess) 1053 return -ENODEV; 1054 1055 if (atomic_read(&tpg->tl_tpg_port_count)) { 1056 pr_err("Unable to remove TCM_Loop I_T Nexus with" 1057 " active TPG port count: %d\n", 1058 atomic_read(&tpg->tl_tpg_port_count)); 1059 return -EPERM; 1060 } 1061 1062 pr_debug("TCM_Loop_ConfigFS: Removing I_T Nexus to emulated" 1063 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tl_hba), 1064 tl_nexus->se_sess->se_node_acl->initiatorname); 1065 /* 1066 * Release the SCSI I_T Nexus to the emulated SAS Target Port 1067 */ 1068 transport_deregister_session(tl_nexus->se_sess); 1069 tpg->tl_hba->tl_nexus = NULL; 1070 kfree(tl_nexus); 1071 return 0; 1072 } 1073 1074 /* End items for tcm_loop_nexus_cit */ 1075 1076 static ssize_t tcm_loop_tpg_show_nexus( 1077 struct se_portal_group *se_tpg, 1078 char *page) 1079 { 1080 struct tcm_loop_tpg *tl_tpg = container_of(se_tpg, 1081 struct tcm_loop_tpg, tl_se_tpg); 1082 struct tcm_loop_nexus *tl_nexus; 1083 ssize_t ret; 1084 1085 tl_nexus = tl_tpg->tl_hba->tl_nexus; 1086 if (!tl_nexus) 1087 return -ENODEV; 1088 1089 ret = snprintf(page, PAGE_SIZE, "%s\n", 1090 tl_nexus->se_sess->se_node_acl->initiatorname); 1091 1092 return ret; 1093 } 1094 1095 static ssize_t tcm_loop_tpg_store_nexus( 1096 struct se_portal_group *se_tpg, 1097 const char *page, 1098 size_t count) 1099 { 1100 struct tcm_loop_tpg *tl_tpg = container_of(se_tpg, 1101 struct tcm_loop_tpg, tl_se_tpg); 1102 struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba; 1103 unsigned char i_port[TL_WWN_ADDR_LEN], *ptr, *port_ptr; 1104 int ret; 1105 /* 1106 * Shutdown the active I_T nexus if 'NULL' is passed.. 1107 */ 1108 if (!strncmp(page, "NULL", 4)) { 1109 ret = tcm_loop_drop_nexus(tl_tpg); 1110 return (!ret) ? count : ret; 1111 } 1112 /* 1113 * Otherwise make sure the passed virtual Initiator port WWN matches 1114 * the fabric protocol_id set in tcm_loop_make_scsi_hba(), and call 1115 * tcm_loop_make_nexus() 1116 */ 1117 if (strlen(page) >= TL_WWN_ADDR_LEN) { 1118 pr_err("Emulated NAA Sas Address: %s, exceeds" 1119 " max: %d\n", page, TL_WWN_ADDR_LEN); 1120 return -EINVAL; 1121 } 1122 snprintf(&i_port[0], TL_WWN_ADDR_LEN, "%s", page); 1123 1124 ptr = strstr(i_port, "naa."); 1125 if (ptr) { 1126 if (tl_hba->tl_proto_id != SCSI_PROTOCOL_SAS) { 1127 pr_err("Passed SAS Initiator Port %s does not" 1128 " match target port protoid: %s\n", i_port, 1129 tcm_loop_dump_proto_id(tl_hba)); 1130 return -EINVAL; 1131 } 1132 port_ptr = &i_port[0]; 1133 goto check_newline; 1134 } 1135 ptr = strstr(i_port, "fc."); 1136 if (ptr) { 1137 if (tl_hba->tl_proto_id != SCSI_PROTOCOL_FCP) { 1138 pr_err("Passed FCP Initiator Port %s does not" 1139 " match target port protoid: %s\n", i_port, 1140 tcm_loop_dump_proto_id(tl_hba)); 1141 return -EINVAL; 1142 } 1143 port_ptr = &i_port[3]; /* Skip over "fc." */ 1144 goto check_newline; 1145 } 1146 ptr = strstr(i_port, "iqn."); 1147 if (ptr) { 1148 if (tl_hba->tl_proto_id != SCSI_PROTOCOL_ISCSI) { 1149 pr_err("Passed iSCSI Initiator Port %s does not" 1150 " match target port protoid: %s\n", i_port, 1151 tcm_loop_dump_proto_id(tl_hba)); 1152 return -EINVAL; 1153 } 1154 port_ptr = &i_port[0]; 1155 goto check_newline; 1156 } 1157 pr_err("Unable to locate prefix for emulated Initiator Port:" 1158 " %s\n", i_port); 1159 return -EINVAL; 1160 /* 1161 * Clear any trailing newline for the NAA WWN 1162 */ 1163 check_newline: 1164 if (i_port[strlen(i_port)-1] == '\n') 1165 i_port[strlen(i_port)-1] = '\0'; 1166 1167 ret = tcm_loop_make_nexus(tl_tpg, port_ptr); 1168 if (ret < 0) 1169 return ret; 1170 1171 return count; 1172 } 1173 1174 TF_TPG_BASE_ATTR(tcm_loop, nexus, S_IRUGO | S_IWUSR); 1175 1176 static struct configfs_attribute *tcm_loop_tpg_attrs[] = { 1177 &tcm_loop_tpg_nexus.attr, 1178 NULL, 1179 }; 1180 1181 /* Start items for tcm_loop_naa_cit */ 1182 1183 struct se_portal_group *tcm_loop_make_naa_tpg( 1184 struct se_wwn *wwn, 1185 struct config_group *group, 1186 const char *name) 1187 { 1188 struct tcm_loop_hba *tl_hba = container_of(wwn, 1189 struct tcm_loop_hba, tl_hba_wwn); 1190 struct tcm_loop_tpg *tl_tpg; 1191 char *tpgt_str, *end_ptr; 1192 int ret; 1193 unsigned short int tpgt; 1194 1195 tpgt_str = strstr(name, "tpgt_"); 1196 if (!tpgt_str) { 1197 pr_err("Unable to locate \"tpgt_#\" directory" 1198 " group\n"); 1199 return ERR_PTR(-EINVAL); 1200 } 1201 tpgt_str += 5; /* Skip ahead of "tpgt_" */ 1202 tpgt = (unsigned short int) simple_strtoul(tpgt_str, &end_ptr, 0); 1203 1204 if (tpgt >= TL_TPGS_PER_HBA) { 1205 pr_err("Passed tpgt: %hu exceeds TL_TPGS_PER_HBA:" 1206 " %u\n", tpgt, TL_TPGS_PER_HBA); 1207 return ERR_PTR(-EINVAL); 1208 } 1209 tl_tpg = &tl_hba->tl_hba_tpgs[tpgt]; 1210 tl_tpg->tl_hba = tl_hba; 1211 tl_tpg->tl_tpgt = tpgt; 1212 /* 1213 * Register the tl_tpg as a emulated SAS TCM Target Endpoint 1214 */ 1215 ret = core_tpg_register(&tcm_loop_fabric_configfs->tf_ops, 1216 wwn, &tl_tpg->tl_se_tpg, tl_tpg, 1217 TRANSPORT_TPG_TYPE_NORMAL); 1218 if (ret < 0) 1219 return ERR_PTR(-ENOMEM); 1220 1221 pr_debug("TCM_Loop_ConfigFS: Allocated Emulated %s" 1222 " Target Port %s,t,0x%04x\n", tcm_loop_dump_proto_id(tl_hba), 1223 config_item_name(&wwn->wwn_group.cg_item), tpgt); 1224 1225 return &tl_tpg->tl_se_tpg; 1226 } 1227 1228 void tcm_loop_drop_naa_tpg( 1229 struct se_portal_group *se_tpg) 1230 { 1231 struct se_wwn *wwn = se_tpg->se_tpg_wwn; 1232 struct tcm_loop_tpg *tl_tpg = container_of(se_tpg, 1233 struct tcm_loop_tpg, tl_se_tpg); 1234 struct tcm_loop_hba *tl_hba; 1235 unsigned short tpgt; 1236 1237 tl_hba = tl_tpg->tl_hba; 1238 tpgt = tl_tpg->tl_tpgt; 1239 /* 1240 * Release the I_T Nexus for the Virtual SAS link if present 1241 */ 1242 tcm_loop_drop_nexus(tl_tpg); 1243 /* 1244 * Deregister the tl_tpg as a emulated SAS TCM Target Endpoint 1245 */ 1246 core_tpg_deregister(se_tpg); 1247 1248 pr_debug("TCM_Loop_ConfigFS: Deallocated Emulated %s" 1249 " Target Port %s,t,0x%04x\n", tcm_loop_dump_proto_id(tl_hba), 1250 config_item_name(&wwn->wwn_group.cg_item), tpgt); 1251 } 1252 1253 /* End items for tcm_loop_naa_cit */ 1254 1255 /* Start items for tcm_loop_cit */ 1256 1257 struct se_wwn *tcm_loop_make_scsi_hba( 1258 struct target_fabric_configfs *tf, 1259 struct config_group *group, 1260 const char *name) 1261 { 1262 struct tcm_loop_hba *tl_hba; 1263 struct Scsi_Host *sh; 1264 char *ptr; 1265 int ret, off = 0; 1266 1267 tl_hba = kzalloc(sizeof(struct tcm_loop_hba), GFP_KERNEL); 1268 if (!tl_hba) { 1269 pr_err("Unable to allocate struct tcm_loop_hba\n"); 1270 return ERR_PTR(-ENOMEM); 1271 } 1272 /* 1273 * Determine the emulated Protocol Identifier and Target Port Name 1274 * based on the incoming configfs directory name. 1275 */ 1276 ptr = strstr(name, "naa."); 1277 if (ptr) { 1278 tl_hba->tl_proto_id = SCSI_PROTOCOL_SAS; 1279 goto check_len; 1280 } 1281 ptr = strstr(name, "fc."); 1282 if (ptr) { 1283 tl_hba->tl_proto_id = SCSI_PROTOCOL_FCP; 1284 off = 3; /* Skip over "fc." */ 1285 goto check_len; 1286 } 1287 ptr = strstr(name, "iqn."); 1288 if (!ptr) { 1289 pr_err("Unable to locate prefix for emulated Target " 1290 "Port: %s\n", name); 1291 ret = -EINVAL; 1292 goto out; 1293 } 1294 tl_hba->tl_proto_id = SCSI_PROTOCOL_ISCSI; 1295 1296 check_len: 1297 if (strlen(name) >= TL_WWN_ADDR_LEN) { 1298 pr_err("Emulated NAA %s Address: %s, exceeds" 1299 " max: %d\n", name, tcm_loop_dump_proto_id(tl_hba), 1300 TL_WWN_ADDR_LEN); 1301 ret = -EINVAL; 1302 goto out; 1303 } 1304 snprintf(&tl_hba->tl_wwn_address[0], TL_WWN_ADDR_LEN, "%s", &name[off]); 1305 1306 /* 1307 * Call device_register(tl_hba->dev) to register the emulated 1308 * Linux/SCSI LLD of type struct Scsi_Host at tl_hba->sh after 1309 * device_register() callbacks in tcm_loop_driver_probe() 1310 */ 1311 ret = tcm_loop_setup_hba_bus(tl_hba, tcm_loop_hba_no_cnt); 1312 if (ret) 1313 goto out; 1314 1315 sh = tl_hba->sh; 1316 tcm_loop_hba_no_cnt++; 1317 pr_debug("TCM_Loop_ConfigFS: Allocated emulated Target" 1318 " %s Address: %s at Linux/SCSI Host ID: %d\n", 1319 tcm_loop_dump_proto_id(tl_hba), name, sh->host_no); 1320 1321 return &tl_hba->tl_hba_wwn; 1322 out: 1323 kfree(tl_hba); 1324 return ERR_PTR(ret); 1325 } 1326 1327 void tcm_loop_drop_scsi_hba( 1328 struct se_wwn *wwn) 1329 { 1330 struct tcm_loop_hba *tl_hba = container_of(wwn, 1331 struct tcm_loop_hba, tl_hba_wwn); 1332 int host_no = tl_hba->sh->host_no; 1333 /* 1334 * Call device_unregister() on the original tl_hba->dev. 1335 * tcm_loop_fabric_scsi.c:tcm_loop_release_adapter() will 1336 * release *tl_hba; 1337 */ 1338 device_unregister(&tl_hba->dev); 1339 1340 pr_debug("TCM_Loop_ConfigFS: Deallocated emulated Target" 1341 " SAS Address: %s at Linux/SCSI Host ID: %d\n", 1342 config_item_name(&wwn->wwn_group.cg_item), host_no); 1343 } 1344 1345 /* Start items for tcm_loop_cit */ 1346 static ssize_t tcm_loop_wwn_show_attr_version( 1347 struct target_fabric_configfs *tf, 1348 char *page) 1349 { 1350 return sprintf(page, "TCM Loopback Fabric module %s\n", TCM_LOOP_VERSION); 1351 } 1352 1353 TF_WWN_ATTR_RO(tcm_loop, version); 1354 1355 static struct configfs_attribute *tcm_loop_wwn_attrs[] = { 1356 &tcm_loop_wwn_version.attr, 1357 NULL, 1358 }; 1359 1360 /* End items for tcm_loop_cit */ 1361 1362 static int tcm_loop_register_configfs(void) 1363 { 1364 struct target_fabric_configfs *fabric; 1365 struct config_group *tf_cg; 1366 int ret; 1367 /* 1368 * Set the TCM Loop HBA counter to zero 1369 */ 1370 tcm_loop_hba_no_cnt = 0; 1371 /* 1372 * Register the top level struct config_item_type with TCM core 1373 */ 1374 fabric = target_fabric_configfs_init(THIS_MODULE, "loopback"); 1375 if (IS_ERR(fabric)) { 1376 pr_err("tcm_loop_register_configfs() failed!\n"); 1377 return PTR_ERR(fabric); 1378 } 1379 /* 1380 * Setup the fabric API of function pointers used by target_core_mod 1381 */ 1382 fabric->tf_ops.get_fabric_name = &tcm_loop_get_fabric_name; 1383 fabric->tf_ops.get_fabric_proto_ident = &tcm_loop_get_fabric_proto_ident; 1384 fabric->tf_ops.tpg_get_wwn = &tcm_loop_get_endpoint_wwn; 1385 fabric->tf_ops.tpg_get_tag = &tcm_loop_get_tag; 1386 fabric->tf_ops.tpg_get_default_depth = &tcm_loop_get_default_depth; 1387 fabric->tf_ops.tpg_get_pr_transport_id = &tcm_loop_get_pr_transport_id; 1388 fabric->tf_ops.tpg_get_pr_transport_id_len = 1389 &tcm_loop_get_pr_transport_id_len; 1390 fabric->tf_ops.tpg_parse_pr_out_transport_id = 1391 &tcm_loop_parse_pr_out_transport_id; 1392 fabric->tf_ops.tpg_check_demo_mode = &tcm_loop_check_demo_mode; 1393 fabric->tf_ops.tpg_check_demo_mode_cache = 1394 &tcm_loop_check_demo_mode_cache; 1395 fabric->tf_ops.tpg_check_demo_mode_write_protect = 1396 &tcm_loop_check_demo_mode_write_protect; 1397 fabric->tf_ops.tpg_check_prod_mode_write_protect = 1398 &tcm_loop_check_prod_mode_write_protect; 1399 /* 1400 * The TCM loopback fabric module runs in demo-mode to a local 1401 * virtual SCSI device, so fabric dependent initator ACLs are 1402 * not required. 1403 */ 1404 fabric->tf_ops.tpg_alloc_fabric_acl = &tcm_loop_tpg_alloc_fabric_acl; 1405 fabric->tf_ops.tpg_release_fabric_acl = 1406 &tcm_loop_tpg_release_fabric_acl; 1407 fabric->tf_ops.tpg_get_inst_index = &tcm_loop_get_inst_index; 1408 /* 1409 * Used for setting up remaining TCM resources in process context 1410 */ 1411 fabric->tf_ops.new_cmd_map = &tcm_loop_new_cmd_map; 1412 fabric->tf_ops.check_stop_free = &tcm_loop_check_stop_free; 1413 fabric->tf_ops.release_cmd = &tcm_loop_release_cmd; 1414 fabric->tf_ops.shutdown_session = &tcm_loop_shutdown_session; 1415 fabric->tf_ops.close_session = &tcm_loop_close_session; 1416 fabric->tf_ops.stop_session = &tcm_loop_stop_session; 1417 fabric->tf_ops.fall_back_to_erl0 = &tcm_loop_fall_back_to_erl0; 1418 fabric->tf_ops.sess_logged_in = &tcm_loop_sess_logged_in; 1419 fabric->tf_ops.sess_get_index = &tcm_loop_sess_get_index; 1420 fabric->tf_ops.sess_get_initiator_sid = NULL; 1421 fabric->tf_ops.write_pending = &tcm_loop_write_pending; 1422 fabric->tf_ops.write_pending_status = &tcm_loop_write_pending_status; 1423 /* 1424 * Not used for TCM loopback 1425 */ 1426 fabric->tf_ops.set_default_node_attributes = 1427 &tcm_loop_set_default_node_attributes; 1428 fabric->tf_ops.get_task_tag = &tcm_loop_get_task_tag; 1429 fabric->tf_ops.get_cmd_state = &tcm_loop_get_cmd_state; 1430 fabric->tf_ops.queue_data_in = &tcm_loop_queue_data_in; 1431 fabric->tf_ops.queue_status = &tcm_loop_queue_status; 1432 fabric->tf_ops.queue_tm_rsp = &tcm_loop_queue_tm_rsp; 1433 fabric->tf_ops.set_fabric_sense_len = &tcm_loop_set_fabric_sense_len; 1434 fabric->tf_ops.get_fabric_sense_len = &tcm_loop_get_fabric_sense_len; 1435 fabric->tf_ops.is_state_remove = &tcm_loop_is_state_remove; 1436 1437 tf_cg = &fabric->tf_group; 1438 /* 1439 * Setup function pointers for generic logic in target_core_fabric_configfs.c 1440 */ 1441 fabric->tf_ops.fabric_make_wwn = &tcm_loop_make_scsi_hba; 1442 fabric->tf_ops.fabric_drop_wwn = &tcm_loop_drop_scsi_hba; 1443 fabric->tf_ops.fabric_make_tpg = &tcm_loop_make_naa_tpg; 1444 fabric->tf_ops.fabric_drop_tpg = &tcm_loop_drop_naa_tpg; 1445 /* 1446 * fabric_post_link() and fabric_pre_unlink() are used for 1447 * registration and release of TCM Loop Virtual SCSI LUNs. 1448 */ 1449 fabric->tf_ops.fabric_post_link = &tcm_loop_port_link; 1450 fabric->tf_ops.fabric_pre_unlink = &tcm_loop_port_unlink; 1451 fabric->tf_ops.fabric_make_np = NULL; 1452 fabric->tf_ops.fabric_drop_np = NULL; 1453 /* 1454 * Setup default attribute lists for various fabric->tf_cit_tmpl 1455 */ 1456 TF_CIT_TMPL(fabric)->tfc_wwn_cit.ct_attrs = tcm_loop_wwn_attrs; 1457 TF_CIT_TMPL(fabric)->tfc_tpg_base_cit.ct_attrs = tcm_loop_tpg_attrs; 1458 TF_CIT_TMPL(fabric)->tfc_tpg_attrib_cit.ct_attrs = NULL; 1459 TF_CIT_TMPL(fabric)->tfc_tpg_param_cit.ct_attrs = NULL; 1460 TF_CIT_TMPL(fabric)->tfc_tpg_np_base_cit.ct_attrs = NULL; 1461 /* 1462 * Once fabric->tf_ops has been setup, now register the fabric for 1463 * use within TCM 1464 */ 1465 ret = target_fabric_configfs_register(fabric); 1466 if (ret < 0) { 1467 pr_err("target_fabric_configfs_register() for" 1468 " TCM_Loop failed!\n"); 1469 target_fabric_configfs_free(fabric); 1470 return -1; 1471 } 1472 /* 1473 * Setup our local pointer to *fabric. 1474 */ 1475 tcm_loop_fabric_configfs = fabric; 1476 pr_debug("TCM_LOOP[0] - Set fabric ->" 1477 " tcm_loop_fabric_configfs\n"); 1478 return 0; 1479 } 1480 1481 static void tcm_loop_deregister_configfs(void) 1482 { 1483 if (!tcm_loop_fabric_configfs) 1484 return; 1485 1486 target_fabric_configfs_deregister(tcm_loop_fabric_configfs); 1487 tcm_loop_fabric_configfs = NULL; 1488 pr_debug("TCM_LOOP[0] - Cleared" 1489 " tcm_loop_fabric_configfs\n"); 1490 } 1491 1492 static int __init tcm_loop_fabric_init(void) 1493 { 1494 int ret; 1495 1496 tcm_loop_cmd_cache = kmem_cache_create("tcm_loop_cmd_cache", 1497 sizeof(struct tcm_loop_cmd), 1498 __alignof__(struct tcm_loop_cmd), 1499 0, NULL); 1500 if (!tcm_loop_cmd_cache) { 1501 pr_debug("kmem_cache_create() for" 1502 " tcm_loop_cmd_cache failed\n"); 1503 return -ENOMEM; 1504 } 1505 1506 ret = tcm_loop_alloc_core_bus(); 1507 if (ret) 1508 return ret; 1509 1510 ret = tcm_loop_register_configfs(); 1511 if (ret) { 1512 tcm_loop_release_core_bus(); 1513 return ret; 1514 } 1515 1516 return 0; 1517 } 1518 1519 static void __exit tcm_loop_fabric_exit(void) 1520 { 1521 tcm_loop_deregister_configfs(); 1522 tcm_loop_release_core_bus(); 1523 kmem_cache_destroy(tcm_loop_cmd_cache); 1524 } 1525 1526 MODULE_DESCRIPTION("TCM loopback virtual Linux/SCSI fabric module"); 1527 MODULE_AUTHOR("Nicholas A. Bellinger <nab@risingtidesystems.com>"); 1528 MODULE_LICENSE("GPL"); 1529 module_init(tcm_loop_fabric_init); 1530 module_exit(tcm_loop_fabric_exit); 1531