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