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