drivers/target/loopback/tcm_loop.c

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