drivers/target/target_core_pscsi.c

   1 /*******************************************************************************
   2  * Filename:  target_core_pscsi.c
   3  *
   4  * This file contains the generic target mode <-> Linux SCSI subsystem plugin.
   5  *
   6  * Copyright (c) 2003, 2004, 2005 PyX Technologies, Inc.
   7  * Copyright (c) 2005, 2006, 2007 SBE, Inc.
   8  * Copyright (c) 2007-2010 Rising Tide Systems
   9  * Copyright (c) 2008-2010 Linux-iSCSI.org
  10  *
  11  * Nicholas A. Bellinger <nab@kernel.org>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26  *
  27  ******************************************************************************/
  28
  29 #include <linux/string.h>
  30 #include <linux/parser.h>
  31 #include <linux/timer.h>
  32 #include <linux/blkdev.h>
  33 #include <linux/blk_types.h>
  34 #include <linux/slab.h>
  35 #include <linux/spinlock.h>
  36 #include <linux/genhd.h>
  37 #include <linux/cdrom.h>
  38 #include <linux/file.h>
  39 #include <scsi/scsi.h>
  40 #include <scsi/scsi_device.h>
  41 #include <scsi/scsi_cmnd.h>
  42 #include <scsi/scsi_host.h>
  43 #include <scsi/scsi_tcq.h>
  44
  45 #include <target/target_core_base.h>
  46 #include <target/target_core_device.h>
  47 #include <target/target_core_transport.h>
  48
  49 #include "target_core_pscsi.h"
  50
  51 #define ISPRINT(a)  ((a >= ' ') && (a <= '~'))
  52
  53 static struct se_subsystem_api pscsi_template;
  54
  55 static void pscsi_req_done(struct request *, int);
  56
  57 /*      pscsi_attach_hba():
  58  *
  59  *      pscsi_get_sh() used scsi_host_lookup() to locate struct Scsi_Host.
  60  *      from the passed SCSI Host ID.
  61  */
  62 static int pscsi_attach_hba(struct se_hba *hba, u32 host_id)
  63 {
  64         struct pscsi_hba_virt *phv;
  65
  66         phv = kzalloc(sizeof(struct pscsi_hba_virt), GFP_KERNEL);
  67         if (!phv) {
  68                 pr_err("Unable to allocate struct pscsi_hba_virt\n");
  69                 return -ENOMEM;
  70         }
  71         phv->phv_host_id = host_id;
  72         phv->phv_mode = PHV_VIRUTAL_HOST_ID;
  73
  74         hba->hba_ptr = phv;
  75
  76         pr_debug("CORE_HBA[%d] - TCM SCSI HBA Driver %s on"
  77                 " Generic Target Core Stack %s\n", hba->hba_id,
  78                 PSCSI_VERSION, TARGET_CORE_MOD_VERSION);
  79         pr_debug("CORE_HBA[%d] - Attached SCSI HBA to Generic\n",
  80                hba->hba_id);
  81
  82         return 0;
  83 }
  84
  85 static void pscsi_detach_hba(struct se_hba *hba)
  86 {
  87         struct pscsi_hba_virt *phv = hba->hba_ptr;
  88         struct Scsi_Host *scsi_host = phv->phv_lld_host;
  89
  90         if (scsi_host) {
  91                 scsi_host_put(scsi_host);
  92
  93                 pr_debug("CORE_HBA[%d] - Detached SCSI HBA: %s from"
  94                         " Generic Target Core\n", hba->hba_id,
  95                         (scsi_host->hostt->name) ? (scsi_host->hostt->name) :
  96                         "Unknown");
  97         } else
  98                 pr_debug("CORE_HBA[%d] - Detached Virtual SCSI HBA"
  99                         " from Generic Target Core\n", hba->hba_id);
 100
 101         kfree(phv);
 102         hba->hba_ptr = NULL;
 103 }
 104
 105 static int pscsi_pmode_enable_hba(struct se_hba *hba, unsigned long mode_flag)
 106 {
 107         struct pscsi_hba_virt *phv = (struct pscsi_hba_virt *)hba->hba_ptr;
 108         struct Scsi_Host *sh = phv->phv_lld_host;
 109         /*
 110          * Release the struct Scsi_Host
 111          */
 112         if (!mode_flag) {
 113                 if (!sh)
 114                         return 0;
 115
 116                 phv->phv_lld_host = NULL;
 117                 phv->phv_mode = PHV_VIRUTAL_HOST_ID;
 118
 119                 pr_debug("CORE_HBA[%d] - Disabled pSCSI HBA Passthrough"
 120                         " %s\n", hba->hba_id, (sh->hostt->name) ?
 121                         (sh->hostt->name) : "Unknown");
 122
 123                 scsi_host_put(sh);
 124                 return 0;
 125         }
 126         /*
 127          * Otherwise, locate struct Scsi_Host from the original passed
 128          * pSCSI Host ID and enable for phba mode
 129          */
 130         sh = scsi_host_lookup(phv->phv_host_id);
 131         if (IS_ERR(sh)) {
 132                 pr_err("pSCSI: Unable to locate SCSI Host for"
 133                         " phv_host_id: %d\n", phv->phv_host_id);
 134                 return PTR_ERR(sh);
 135         }
 136
 137         phv->phv_lld_host = sh;
 138         phv->phv_mode = PHV_LLD_SCSI_HOST_NO;
 139
 140         pr_debug("CORE_HBA[%d] - Enabled pSCSI HBA Passthrough %s\n",
 141                 hba->hba_id, (sh->hostt->name) ? (sh->hostt->name) : "Unknown");
 142
 143         return 1;
 144 }
 145
 146 static void pscsi_tape_read_blocksize(struct se_device *dev,
 147                 struct scsi_device *sdev)
 148 {
 149         unsigned char cdb[MAX_COMMAND_SIZE], *buf;
 150         int ret;
 151
 152         buf = kzalloc(12, GFP_KERNEL);
 153         if (!buf)
 154                 return;
 155
 156         memset(cdb, 0, MAX_COMMAND_SIZE);
 157         cdb[0] = MODE_SENSE;
 158         cdb[4] = 0x0c; /* 12 bytes */
 159
 160         ret = scsi_execute_req(sdev, cdb, DMA_FROM_DEVICE, buf, 12, NULL,
 161                         HZ, 1, NULL);
 162         if (ret)
 163                 goto out_free;
 164
 165         /*
 166          * If MODE_SENSE still returns zero, set the default value to 1024.
 167          */
 168         sdev->sector_size = (buf[9] << 16) | (buf[10] << 8) | (buf[11]);
 169         if (!sdev->sector_size)
 170                 sdev->sector_size = 1024;
 171 out_free:
 172         kfree(buf);
 173 }
 174
 175 static void
 176 pscsi_set_inquiry_info(struct scsi_device *sdev, struct t10_wwn *wwn)
 177 {
 178         unsigned char *buf;
 179
 180         if (sdev->inquiry_len < INQUIRY_LEN)
 181                 return;
 182
 183         buf = sdev->inquiry;
 184         if (!buf)
 185                 return;
 186         /*
 187          * Use sdev->inquiry from drivers/scsi/scsi_scan.c:scsi_alloc_sdev()
 188          */
 189         memcpy(&wwn->vendor[0], &buf[8], sizeof(wwn->vendor));
 190         memcpy(&wwn->model[0], &buf[16], sizeof(wwn->model));
 191         memcpy(&wwn->revision[0], &buf[32], sizeof(wwn->revision));
 192 }
 193
 194 static int
 195 pscsi_get_inquiry_vpd_serial(struct scsi_device *sdev, struct t10_wwn *wwn)
 196 {
 197         unsigned char cdb[MAX_COMMAND_SIZE], *buf;
 198         int ret;
 199
 200         buf = kzalloc(INQUIRY_VPD_SERIAL_LEN, GFP_KERNEL);
 201         if (!buf)
 202                 return -ENOMEM;
 203
 204         memset(cdb, 0, MAX_COMMAND_SIZE);
 205         cdb[0] = INQUIRY;
 206         cdb[1] = 0x01; /* Query VPD */
 207         cdb[2] = 0x80; /* Unit Serial Number */
 208         cdb[3] = (INQUIRY_VPD_SERIAL_LEN >> 8) & 0xff;
 209         cdb[4] = (INQUIRY_VPD_SERIAL_LEN & 0xff);
 210
 211         ret = scsi_execute_req(sdev, cdb, DMA_FROM_DEVICE, buf,
 212                               INQUIRY_VPD_SERIAL_LEN, NULL, HZ, 1, NULL);
 213         if (ret)
 214                 goto out_free;
 215
 216         snprintf(&wwn->unit_serial[0], INQUIRY_VPD_SERIAL_LEN, "%s", &buf[4]);
 217
 218         wwn->t10_sub_dev->su_dev_flags |= SDF_FIRMWARE_VPD_UNIT_SERIAL;
 219
 220         kfree(buf);
 221         return 0;
 222
 223 out_free:
 224         kfree(buf);
 225         return -EPERM;
 226 }
 227
 228 static void
 229 pscsi_get_inquiry_vpd_device_ident(struct scsi_device *sdev,
 230                 struct t10_wwn *wwn)
 231 {
 232         unsigned char cdb[MAX_COMMAND_SIZE], *buf, *page_83;
 233         int ident_len, page_len, off = 4, ret;
 234         struct t10_vpd *vpd;
 235
 236         buf = kzalloc(INQUIRY_VPD_SERIAL_LEN, GFP_KERNEL);
 237         if (!buf)
 238                 return;
 239
 240         memset(cdb, 0, MAX_COMMAND_SIZE);
 241         cdb[0] = INQUIRY;
 242         cdb[1] = 0x01; /* Query VPD */
 243         cdb[2] = 0x83; /* Device Identifier */
 244         cdb[3] = (INQUIRY_VPD_DEVICE_IDENTIFIER_LEN >> 8) & 0xff;
 245         cdb[4] = (INQUIRY_VPD_DEVICE_IDENTIFIER_LEN & 0xff);
 246
 247         ret = scsi_execute_req(sdev, cdb, DMA_FROM_DEVICE, buf,
 248                               INQUIRY_VPD_DEVICE_IDENTIFIER_LEN,
 249                               NULL, HZ, 1, NULL);
 250         if (ret)
 251                 goto out;
 252
 253         page_len = (buf[2] << 8) | buf[3];
 254         while (page_len > 0) {
 255                 /* Grab a pointer to the Identification descriptor */
 256                 page_83 = &buf[off];
 257                 ident_len = page_83[3];
 258                 if (!ident_len) {
 259                         pr_err("page_83[3]: identifier"
 260                                         " length zero!\n");
 261                         break;
 262                 }
 263                 pr_debug("T10 VPD Identifer Length: %d\n", ident_len);
 264
 265                 vpd = kzalloc(sizeof(struct t10_vpd), GFP_KERNEL);
 266                 if (!vpd) {
 267                         pr_err("Unable to allocate memory for"
 268                                         " struct t10_vpd\n");
 269                         goto out;
 270                 }
 271                 INIT_LIST_HEAD(&vpd->vpd_list);
 272
 273                 transport_set_vpd_proto_id(vpd, page_83);
 274                 transport_set_vpd_assoc(vpd, page_83);
 275
 276                 if (transport_set_vpd_ident_type(vpd, page_83) < 0) {
 277                         off += (ident_len + 4);
 278                         page_len -= (ident_len + 4);
 279                         kfree(vpd);
 280                         continue;
 281                 }
 282                 if (transport_set_vpd_ident(vpd, page_83) < 0) {
 283                         off += (ident_len + 4);
 284                         page_len -= (ident_len + 4);
 285                         kfree(vpd);
 286                         continue;
 287                 }
 288
 289                 list_add_tail(&vpd->vpd_list, &wwn->t10_vpd_list);
 290                 off += (ident_len + 4);
 291                 page_len -= (ident_len + 4);
 292         }
 293
 294 out:
 295         kfree(buf);
 296 }
 297
 298 /*      pscsi_add_device_to_list():
 299  *
 300  *
 301  */
 302 static struct se_device *pscsi_add_device_to_list(
 303         struct se_hba *hba,
 304         struct se_subsystem_dev *se_dev,
 305         struct pscsi_dev_virt *pdv,
 306         struct scsi_device *sd,
 307         int dev_flags)
 308 {
 309         struct se_device *dev;
 310         struct se_dev_limits dev_limits;
 311         struct request_queue *q;
 312         struct queue_limits *limits;
 313
 314         memset(&dev_limits, 0, sizeof(struct se_dev_limits));
 315
 316         if (!sd->queue_depth) {
 317                 sd->queue_depth = PSCSI_DEFAULT_QUEUEDEPTH;
 318
 319                 pr_err("Set broken SCSI Device %d:%d:%d"
 320                         " queue_depth to %d\n", sd->channel, sd->id,
 321                                 sd->lun, sd->queue_depth);
 322         }
 323         /*
 324          * Setup the local scope queue_limits from struct request_queue->limits
 325          * to pass into transport_add_device_to_core_hba() as struct se_dev_limits.
 326          */
 327         q = sd->request_queue;
 328         limits = &dev_limits.limits;
 329         limits->logical_block_size = sd->sector_size;
 330         limits->max_hw_sectors = min_t(int, sd->host->max_sectors, queue_max_hw_sectors(q));
 331         limits->max_sectors = min_t(int, sd->host->max_sectors, queue_max_sectors(q));
 332         dev_limits.hw_queue_depth = sd->queue_depth;
 333         dev_limits.queue_depth = sd->queue_depth;
 334         /*
 335          * Setup our standard INQUIRY info into se_dev->t10_wwn
 336          */
 337         pscsi_set_inquiry_info(sd, &se_dev->t10_wwn);
 338
 339         /*
 340          * Set the pointer pdv->pdv_sd to from passed struct scsi_device,
 341          * which has already been referenced with Linux SCSI code with
 342          * scsi_device_get() in this file's pscsi_create_virtdevice().
 343          *
 344          * The passthrough operations called by the transport_add_device_*
 345          * function below will require this pointer to be set for passthroug
 346          *  ops.
 347          *
 348          * For the shutdown case in pscsi_free_device(), this struct
 349          * scsi_device  reference is released with Linux SCSI code
 350          * scsi_device_put() and the pdv->pdv_sd cleared.
 351          */
 352         pdv->pdv_sd = sd;
 353
 354         dev = transport_add_device_to_core_hba(hba, &pscsi_template,
 355                                 se_dev, dev_flags, pdv,
 356                                 &dev_limits, NULL, NULL);
 357         if (!dev) {
 358                 pdv->pdv_sd = NULL;
 359                 return NULL;
 360         }
 361
 362         /*
 363          * Locate VPD WWN Information used for various purposes within
 364          * the Storage Engine.
 365          */
 366         if (!pscsi_get_inquiry_vpd_serial(sd, &se_dev->t10_wwn)) {
 367                 /*
 368                  * If VPD Unit Serial returned GOOD status, try
 369                  * VPD Device Identification page (0x83).
 370                  */
 371                 pscsi_get_inquiry_vpd_device_ident(sd, &se_dev->t10_wwn);
 372         }
 373
 374         /*
 375          * For TYPE_TAPE, attempt to determine blocksize with MODE_SENSE.
 376          */
 377         if (sd->type == TYPE_TAPE)
 378                 pscsi_tape_read_blocksize(dev, sd);
 379         return dev;
 380 }
 381
 382 static void *pscsi_allocate_virtdevice(struct se_hba *hba, const char *name)
 383 {
 384         struct pscsi_dev_virt *pdv;
 385
 386         pdv = kzalloc(sizeof(struct pscsi_dev_virt), GFP_KERNEL);
 387         if (!pdv) {
 388                 pr_err("Unable to allocate memory for struct pscsi_dev_virt\n");
 389                 return NULL;
 390         }
 391         pdv->pdv_se_hba = hba;
 392
 393         pr_debug("PSCSI: Allocated pdv: %p for %s\n", pdv, name);
 394         return pdv;
 395 }
 396
 397 /*
 398  * Called with struct Scsi_Host->host_lock called.
 399  */
 400 static struct se_device *pscsi_create_type_disk(
 401         struct scsi_device *sd,
 402         struct pscsi_dev_virt *pdv,
 403         struct se_subsystem_dev *se_dev,
 404         struct se_hba *hba)
 405         __releases(sh->host_lock)
 406 {
 407         struct se_device *dev;
 408         struct pscsi_hba_virt *phv = (struct pscsi_hba_virt *)pdv->pdv_se_hba->hba_ptr;
 409         struct Scsi_Host *sh = sd->host;
 410         struct block_device *bd;
 411         u32 dev_flags = 0;
 412
 413         if (scsi_device_get(sd)) {
 414                 pr_err("scsi_device_get() failed for %d:%d:%d:%d\n",
 415                         sh->host_no, sd->channel, sd->id, sd->lun);
 416                 spin_unlock_irq(sh->host_lock);
 417                 return NULL;
 418         }
 419         spin_unlock_irq(sh->host_lock);
 420         /*
 421          * Claim exclusive struct block_device access to struct scsi_device
 422          * for TYPE_DISK using supplied udev_path
 423          */
 424         bd = blkdev_get_by_path(se_dev->se_dev_udev_path,
 425                                 FMODE_WRITE|FMODE_READ|FMODE_EXCL, pdv);
 426         if (IS_ERR(bd)) {
 427                 pr_err("pSCSI: blkdev_get_by_path() failed\n");
 428                 scsi_device_put(sd);
 429                 return NULL;
 430         }
 431         pdv->pdv_bd = bd;
 432
 433         dev = pscsi_add_device_to_list(hba, se_dev, pdv, sd, dev_flags);
 434         if (!dev) {
 435                 blkdev_put(pdv->pdv_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
 436                 scsi_device_put(sd);
 437                 return NULL;
 438         }
 439         pr_debug("CORE_PSCSI[%d] - Added TYPE_DISK for %d:%d:%d:%d\n",
 440                 phv->phv_host_id, sh->host_no, sd->channel, sd->id, sd->lun);
 441
 442         return dev;
 443 }
 444
 445 /*
 446  * Called with struct Scsi_Host->host_lock called.
 447  */
 448 static struct se_device *pscsi_create_type_rom(
 449         struct scsi_device *sd,
 450         struct pscsi_dev_virt *pdv,
 451         struct se_subsystem_dev *se_dev,
 452         struct se_hba *hba)
 453         __releases(sh->host_lock)
 454 {
 455         struct se_device *dev;
 456         struct pscsi_hba_virt *phv = (struct pscsi_hba_virt *)pdv->pdv_se_hba->hba_ptr;
 457         struct Scsi_Host *sh = sd->host;
 458         u32 dev_flags = 0;
 459
 460         if (scsi_device_get(sd)) {
 461                 pr_err("scsi_device_get() failed for %d:%d:%d:%d\n",
 462                         sh->host_no, sd->channel, sd->id, sd->lun);
 463                 spin_unlock_irq(sh->host_lock);
 464                 return NULL;
 465         }
 466         spin_unlock_irq(sh->host_lock);
 467
 468         dev = pscsi_add_device_to_list(hba, se_dev, pdv, sd, dev_flags);
 469         if (!dev) {
 470                 scsi_device_put(sd);
 471                 return NULL;
 472         }
 473         pr_debug("CORE_PSCSI[%d] - Added Type: %s for %d:%d:%d:%d\n",
 474                 phv->phv_host_id, scsi_device_type(sd->type), sh->host_no,
 475                 sd->channel, sd->id, sd->lun);
 476
 477         return dev;
 478 }
 479
 480 /*
 481  *Called with struct Scsi_Host->host_lock called.
 482  */
 483 static struct se_device *pscsi_create_type_other(
 484         struct scsi_device *sd,
 485         struct pscsi_dev_virt *pdv,
 486         struct se_subsystem_dev *se_dev,
 487         struct se_hba *hba)
 488         __releases(sh->host_lock)
 489 {
 490         struct se_device *dev;
 491         struct pscsi_hba_virt *phv = (struct pscsi_hba_virt *)pdv->pdv_se_hba->hba_ptr;
 492         struct Scsi_Host *sh = sd->host;
 493         u32 dev_flags = 0;
 494
 495         spin_unlock_irq(sh->host_lock);
 496         dev = pscsi_add_device_to_list(hba, se_dev, pdv, sd, dev_flags);
 497         if (!dev)
 498                 return NULL;
 499
 500         pr_debug("CORE_PSCSI[%d] - Added Type: %s for %d:%d:%d:%d\n",
 501                 phv->phv_host_id, scsi_device_type(sd->type), sh->host_no,
 502                 sd->channel, sd->id, sd->lun);
 503
 504         return dev;
 505 }
 506
 507 static struct se_device *pscsi_create_virtdevice(
 508         struct se_hba *hba,
 509         struct se_subsystem_dev *se_dev,
 510         void *p)
 511 {
 512         struct pscsi_dev_virt *pdv = (struct pscsi_dev_virt *)p;
 513         struct se_device *dev;
 514         struct scsi_device *sd;
 515         struct pscsi_hba_virt *phv = (struct pscsi_hba_virt *)hba->hba_ptr;
 516         struct Scsi_Host *sh = phv->phv_lld_host;
 517         int legacy_mode_enable = 0;
 518
 519         if (!pdv) {
 520                 pr_err("Unable to locate struct pscsi_dev_virt"
 521                                 " parameter\n");
 522                 return ERR_PTR(-EINVAL);
 523         }
 524         /*
 525          * If not running in PHV_LLD_SCSI_HOST_NO mode, locate the
 526          * struct Scsi_Host we will need to bring the TCM/pSCSI object online
 527          */
 528         if (!sh) {
 529                 if (phv->phv_mode == PHV_LLD_SCSI_HOST_NO) {
 530                         pr_err("pSCSI: Unable to locate struct"
 531                                 " Scsi_Host for PHV_LLD_SCSI_HOST_NO\n");
 532                         return ERR_PTR(-ENODEV);
 533                 }
 534                 /*
 535                  * For the newer PHV_VIRUTAL_HOST_ID struct scsi_device
 536                  * reference, we enforce that udev_path has been set
 537                  */
 538                 if (!(se_dev->su_dev_flags & SDF_USING_UDEV_PATH)) {
 539                         pr_err("pSCSI: udev_path attribute has not"
 540                                 " been set before ENABLE=1\n");
 541                         return ERR_PTR(-EINVAL);
 542                 }
 543                 /*
 544                  * If no scsi_host_id= was passed for PHV_VIRUTAL_HOST_ID,
 545                  * use the original TCM hba ID to reference Linux/SCSI Host No
 546                  * and enable for PHV_LLD_SCSI_HOST_NO mode.
 547                  */
 548                 if (!(pdv->pdv_flags & PDF_HAS_VIRT_HOST_ID)) {
 549                         spin_lock(&hba->device_lock);
 550                         if (!list_empty(&hba->hba_dev_list)) {
 551                                 pr_err("pSCSI: Unable to set hba_mode"
 552                                         " with active devices\n");
 553                                 spin_unlock(&hba->device_lock);
 554                                 return ERR_PTR(-EEXIST);
 555                         }
 556                         spin_unlock(&hba->device_lock);
 557
 558                         if (pscsi_pmode_enable_hba(hba, 1) != 1)
 559                                 return ERR_PTR(-ENODEV);
 560
 561                         legacy_mode_enable = 1;
 562                         hba->hba_flags |= HBA_FLAGS_PSCSI_MODE;
 563                         sh = phv->phv_lld_host;
 564                 } else {
 565                         sh = scsi_host_lookup(pdv->pdv_host_id);
 566                         if (IS_ERR(sh)) {
 567                                 pr_err("pSCSI: Unable to locate"
 568                                         " pdv_host_id: %d\n", pdv->pdv_host_id);
 569                                 return (struct se_device *) sh;
 570                         }
 571                 }
 572         } else {
 573                 if (phv->phv_mode == PHV_VIRUTAL_HOST_ID) {
 574                         pr_err("pSCSI: PHV_VIRUTAL_HOST_ID set while"
 575                                 " struct Scsi_Host exists\n");
 576                         return ERR_PTR(-EEXIST);
 577                 }
 578         }
 579
 580         spin_lock_irq(sh->host_lock);
 581         list_for_each_entry(sd, &sh->__devices, siblings) {
 582                 if ((pdv->pdv_channel_id != sd->channel) ||
 583                     (pdv->pdv_target_id != sd->id) ||
 584                     (pdv->pdv_lun_id != sd->lun))
 585                         continue;
 586                 /*
 587                  * Functions will release the held struct scsi_host->host_lock
 588                  * before calling calling pscsi_add_device_to_list() to register
 589                  * struct scsi_device with target_core_mod.
 590                  */
 591                 switch (sd->type) {
 592                 case TYPE_DISK:
 593                         dev = pscsi_create_type_disk(sd, pdv, se_dev, hba);
 594                         break;
 595                 case TYPE_ROM:
 596                         dev = pscsi_create_type_rom(sd, pdv, se_dev, hba);
 597                         break;
 598                 default:
 599                         dev = pscsi_create_type_other(sd, pdv, se_dev, hba);
 600                         break;
 601                 }
 602
 603                 if (!dev) {
 604                         if (phv->phv_mode == PHV_VIRUTAL_HOST_ID)
 605                                 scsi_host_put(sh);
 606                         else if (legacy_mode_enable) {
 607                                 pscsi_pmode_enable_hba(hba, 0);
 608                                 hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE;
 609                         }
 610                         pdv->pdv_sd = NULL;
 611                         return ERR_PTR(-ENODEV);
 612                 }
 613                 return dev;
 614         }
 615         spin_unlock_irq(sh->host_lock);
 616
 617         pr_err("pSCSI: Unable to locate %d:%d:%d:%d\n", sh->host_no,
 618                 pdv->pdv_channel_id,  pdv->pdv_target_id, pdv->pdv_lun_id);
 619
 620         if (phv->phv_mode == PHV_VIRUTAL_HOST_ID)
 621                 scsi_host_put(sh);
 622         else if (legacy_mode_enable) {
 623                 pscsi_pmode_enable_hba(hba, 0);
 624                 hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE;
 625         }
 626
 627         return ERR_PTR(-ENODEV);
 628 }
 629
 630 /*      pscsi_free_device(): (Part of se_subsystem_api_t template)
 631  *
 632  *
 633  */
 634 static void pscsi_free_device(void *p)
 635 {
 636         struct pscsi_dev_virt *pdv = p;
 637         struct pscsi_hba_virt *phv = pdv->pdv_se_hba->hba_ptr;
 638         struct scsi_device *sd = pdv->pdv_sd;
 639
 640         if (sd) {
 641                 /*
 642                  * Release exclusive pSCSI internal struct block_device claim for
 643                  * struct scsi_device with TYPE_DISK from pscsi_create_type_disk()
 644                  */
 645                 if ((sd->type == TYPE_DISK) && pdv->pdv_bd) {
 646                         blkdev_put(pdv->pdv_bd,
 647                                    FMODE_WRITE|FMODE_READ|FMODE_EXCL);
 648                         pdv->pdv_bd = NULL;
 649                 }
 650                 /*
 651                  * For HBA mode PHV_LLD_SCSI_HOST_NO, release the reference
 652                  * to struct Scsi_Host now.
 653                  */
 654                 if ((phv->phv_mode == PHV_LLD_SCSI_HOST_NO) &&
 655                     (phv->phv_lld_host != NULL))
 656                         scsi_host_put(phv->phv_lld_host);
 657
 658                 if ((sd->type == TYPE_DISK) || (sd->type == TYPE_ROM))
 659                         scsi_device_put(sd);
 660
 661                 pdv->pdv_sd = NULL;
 662         }
 663
 664         kfree(pdv);
 665 }
 666
 667 static inline struct pscsi_plugin_task *PSCSI_TASK(struct se_task *task)
 668 {
 669         return container_of(task, struct pscsi_plugin_task, pscsi_task);
 670 }
 671
 672
 673 /*      pscsi_transport_complete():
 674  *
 675  *
 676  */
 677 static int pscsi_transport_complete(struct se_task *task)
 678 {
 679         struct pscsi_dev_virt *pdv = task->se_dev->dev_ptr;
 680         struct scsi_device *sd = pdv->pdv_sd;
 681         int result;
 682         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
 683         unsigned char *cdb = &pt->pscsi_cdb[0];
 684
 685         result = pt->pscsi_result;
 686         /*
 687          * Hack to make sure that Write-Protect modepage is set if R/O mode is
 688          * forced.
 689          */
 690         if (((cdb[0] == MODE_SENSE) || (cdb[0] == MODE_SENSE_10)) &&
 691              (status_byte(result) << 1) == SAM_STAT_GOOD) {
 692                 if (!task->task_se_cmd->se_deve)
 693                         goto after_mode_sense;
 694
 695                 if (task->task_se_cmd->se_deve->lun_flags &
 696                                 TRANSPORT_LUNFLAGS_READ_ONLY) {
 697                         unsigned char *buf = transport_kmap_first_data_page(task->task_se_cmd);
 698
 699                         if (cdb[0] == MODE_SENSE_10) {
 700                                 if (!(buf[3] & 0x80))
 701                                         buf[3] |= 0x80;
 702                         } else {
 703                                 if (!(buf[2] & 0x80))
 704                                         buf[2] |= 0x80;
 705                         }
 706
 707                         transport_kunmap_first_data_page(task->task_se_cmd);
 708                 }
 709         }
 710 after_mode_sense:
 711
 712         if (sd->type != TYPE_TAPE)
 713                 goto after_mode_select;
 714
 715         /*
 716          * Hack to correctly obtain the initiator requested blocksize for
 717          * TYPE_TAPE.  Since this value is dependent upon each tape media,
 718          * struct scsi_device->sector_size will not contain the correct value
 719          * by default, so we go ahead and set it so
 720          * TRANSPORT(dev)->get_blockdev() returns the correct value to the
 721          * storage engine.
 722          */
 723         if (((cdb[0] == MODE_SELECT) || (cdb[0] == MODE_SELECT_10)) &&
 724               (status_byte(result) << 1) == SAM_STAT_GOOD) {
 725                 unsigned char *buf;
 726                 struct scatterlist *sg = task->task_sg;
 727                 u16 bdl;
 728                 u32 blocksize;
 729
 730                 buf = sg_virt(&sg[0]);
 731                 if (!buf) {
 732                         pr_err("Unable to get buf for scatterlist\n");
 733                         goto after_mode_select;
 734                 }
 735
 736                 if (cdb[0] == MODE_SELECT)
 737                         bdl = (buf[3]);
 738                 else
 739                         bdl = (buf[6] << 8) | (buf[7]);
 740
 741                 if (!bdl)
 742                         goto after_mode_select;
 743
 744                 if (cdb[0] == MODE_SELECT)
 745                         blocksize = (buf[9] << 16) | (buf[10] << 8) |
 746                                         (buf[11]);
 747                 else
 748                         blocksize = (buf[13] << 16) | (buf[14] << 8) |
 749                                         (buf[15]);
 750
 751                 sd->sector_size = blocksize;
 752         }
 753 after_mode_select:
 754
 755         if (status_byte(result) & CHECK_CONDITION)
 756                 return 1;
 757
 758         return 0;
 759 }
 760
 761 static struct se_task *
 762 pscsi_alloc_task(unsigned char *cdb)
 763 {
 764         struct pscsi_plugin_task *pt;
 765
 766         /*
 767          * Dynamically alloc cdb space, since it may be larger than
 768          * TCM_MAX_COMMAND_SIZE
 769          */
 770         pt = kzalloc(sizeof(*pt) + scsi_command_size(cdb), GFP_KERNEL);
 771         if (!pt) {
 772                 pr_err("Unable to allocate struct pscsi_plugin_task\n");
 773                 return NULL;
 774         }
 775
 776         return &pt->pscsi_task;
 777 }
 778
 779 static inline void pscsi_blk_init_request(
 780         struct se_task *task,
 781         struct pscsi_plugin_task *pt,
 782         struct request *req,
 783         int bidi_read)
 784 {
 785         /*
 786          * Defined as "scsi command" in include/linux/blkdev.h.
 787          */
 788         req->cmd_type = REQ_TYPE_BLOCK_PC;
 789         /*
 790          * For the extra BIDI-COMMAND READ struct request we do not
 791          * need to setup the remaining structure members
 792          */
 793         if (bidi_read)
 794                 return;
 795         /*
 796          * Setup the done function pointer for struct request,
 797          * also set the end_io_data pointer.to struct se_task.
 798          */
 799         req->end_io = pscsi_req_done;
 800         req->end_io_data = task;
 801         /*
 802          * Load the referenced struct se_task's SCSI CDB into
 803          * include/linux/blkdev.h:struct request->cmd
 804          */
 805         req->cmd_len = scsi_command_size(pt->pscsi_cdb);
 806         req->cmd = &pt->pscsi_cdb[0];
 807         /*
 808          * Setup pointer for outgoing sense data.
 809          */
 810         req->sense = &pt->pscsi_sense[0];
 811         req->sense_len = 0;
 812 }
 813
 814 /*
 815  * Used for pSCSI data payloads for all *NON* SCF_SCSI_DATA_SG_IO_CDB
 816 */
 817 static int pscsi_blk_get_request(struct se_task *task)
 818 {
 819         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
 820         struct pscsi_dev_virt *pdv = task->se_dev->dev_ptr;
 821
 822         pt->pscsi_req = blk_get_request(pdv->pdv_sd->request_queue,
 823                         (task->task_data_direction == DMA_TO_DEVICE),
 824                         GFP_KERNEL);
 825         if (!pt->pscsi_req || IS_ERR(pt->pscsi_req)) {
 826                 pr_err("PSCSI: blk_get_request() failed: %ld\n",
 827                                 IS_ERR(pt->pscsi_req));
 828                 return PYX_TRANSPORT_LU_COMM_FAILURE;
 829         }
 830         /*
 831          * Setup the newly allocated struct request for REQ_TYPE_BLOCK_PC,
 832          * and setup rq callback, CDB and sense.
 833          */
 834         pscsi_blk_init_request(task, pt, pt->pscsi_req, 0);
 835         return 0;
 836 }
 837
 838 /*      pscsi_do_task(): (Part of se_subsystem_api_t template)
 839  *
 840  *
 841  */
 842 static int pscsi_do_task(struct se_task *task)
 843 {
 844         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
 845         struct pscsi_dev_virt *pdv = task->se_dev->dev_ptr;
 846         /*
 847          * Set the struct request->timeout value based on peripheral
 848          * device type from SCSI.
 849          */
 850         if (pdv->pdv_sd->type == TYPE_DISK)
 851                 pt->pscsi_req->timeout = PS_TIMEOUT_DISK;
 852         else
 853                 pt->pscsi_req->timeout = PS_TIMEOUT_OTHER;
 854
 855         pt->pscsi_req->retries = PS_RETRY;
 856         /*
 857          * Queue the struct request into the struct scsi_device->request_queue.
 858          * Also check for HEAD_OF_QUEUE SAM TASK attr from received se_cmd
 859          * descriptor
 860          */
 861         blk_execute_rq_nowait(pdv->pdv_sd->request_queue, NULL, pt->pscsi_req,
 862                         (task->task_se_cmd->sam_task_attr == MSG_HEAD_TAG),
 863                         pscsi_req_done);
 864
 865         return PYX_TRANSPORT_SENT_TO_TRANSPORT;
 866 }
 867
 868 static void pscsi_free_task(struct se_task *task)
 869 {
 870         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
 871
 872         /*
 873          * We do not release the bio(s) here associated with this task, as
 874          * this is handled by bio_put() and pscsi_bi_endio().
 875          */
 876         kfree(pt);
 877 }
 878
 879 enum {
 880         Opt_scsi_host_id, Opt_scsi_channel_id, Opt_scsi_target_id,
 881         Opt_scsi_lun_id, Opt_err
 882 };
 883
 884 static match_table_t tokens = {
 885         {Opt_scsi_host_id, "scsi_host_id=%d"},
 886         {Opt_scsi_channel_id, "scsi_channel_id=%d"},
 887         {Opt_scsi_target_id, "scsi_target_id=%d"},
 888         {Opt_scsi_lun_id, "scsi_lun_id=%d"},
 889         {Opt_err, NULL}
 890 };
 891
 892 static ssize_t pscsi_set_configfs_dev_params(struct se_hba *hba,
 893         struct se_subsystem_dev *se_dev,
 894         const char *page,
 895         ssize_t count)
 896 {
 897         struct pscsi_dev_virt *pdv = se_dev->se_dev_su_ptr;
 898         struct pscsi_hba_virt *phv = hba->hba_ptr;
 899         char *orig, *ptr, *opts;
 900         substring_t args[MAX_OPT_ARGS];
 901         int ret = 0, arg, token;
 902
 903         opts = kstrdup(page, GFP_KERNEL);
 904         if (!opts)
 905                 return -ENOMEM;
 906
 907         orig = opts;
 908
 909         while ((ptr = strsep(&opts, ",")) != NULL) {
 910                 if (!*ptr)
 911                         continue;
 912
 913                 token = match_token(ptr, tokens, args);
 914                 switch (token) {
 915                 case Opt_scsi_host_id:
 916                         if (phv->phv_mode == PHV_LLD_SCSI_HOST_NO) {
 917                                 pr_err("PSCSI[%d]: Unable to accept"
 918                                         " scsi_host_id while phv_mode =="
 919                                         " PHV_LLD_SCSI_HOST_NO\n",
 920                                         phv->phv_host_id);
 921                                 ret = -EINVAL;
 922                                 goto out;
 923                         }
 924                         match_int(args, &arg);
 925                         pdv->pdv_host_id = arg;
 926                         pr_debug("PSCSI[%d]: Referencing SCSI Host ID:"
 927                                 " %d\n", phv->phv_host_id, pdv->pdv_host_id);
 928                         pdv->pdv_flags |= PDF_HAS_VIRT_HOST_ID;
 929                         break;
 930                 case Opt_scsi_channel_id:
 931                         match_int(args, &arg);
 932                         pdv->pdv_channel_id = arg;
 933                         pr_debug("PSCSI[%d]: Referencing SCSI Channel"
 934                                 " ID: %d\n",  phv->phv_host_id,
 935                                 pdv->pdv_channel_id);
 936                         pdv->pdv_flags |= PDF_HAS_CHANNEL_ID;
 937                         break;
 938                 case Opt_scsi_target_id:
 939                         match_int(args, &arg);
 940                         pdv->pdv_target_id = arg;
 941                         pr_debug("PSCSI[%d]: Referencing SCSI Target"
 942                                 " ID: %d\n", phv->phv_host_id,
 943                                 pdv->pdv_target_id);
 944                         pdv->pdv_flags |= PDF_HAS_TARGET_ID;
 945                         break;
 946                 case Opt_scsi_lun_id:
 947                         match_int(args, &arg);
 948                         pdv->pdv_lun_id = arg;
 949                         pr_debug("PSCSI[%d]: Referencing SCSI LUN ID:"
 950                                 " %d\n", phv->phv_host_id, pdv->pdv_lun_id);
 951                         pdv->pdv_flags |= PDF_HAS_LUN_ID;
 952                         break;
 953                 default:
 954                         break;
 955                 }
 956         }
 957
 958 out:
 959         kfree(orig);
 960         return (!ret) ? count : ret;
 961 }
 962
 963 static ssize_t pscsi_check_configfs_dev_params(
 964         struct se_hba *hba,
 965         struct se_subsystem_dev *se_dev)
 966 {
 967         struct pscsi_dev_virt *pdv = se_dev->se_dev_su_ptr;
 968
 969         if (!(pdv->pdv_flags & PDF_HAS_CHANNEL_ID) ||
 970             !(pdv->pdv_flags & PDF_HAS_TARGET_ID) ||
 971             !(pdv->pdv_flags & PDF_HAS_LUN_ID)) {
 972                 pr_err("Missing scsi_channel_id=, scsi_target_id= and"
 973                         " scsi_lun_id= parameters\n");
 974                 return -EINVAL;
 975         }
 976
 977         return 0;
 978 }
 979
 980 static ssize_t pscsi_show_configfs_dev_params(struct se_hba *hba,
 981                                               struct se_subsystem_dev *se_dev,
 982                                               char *b)
 983 {
 984         struct pscsi_hba_virt *phv = hba->hba_ptr;
 985         struct pscsi_dev_virt *pdv = se_dev->se_dev_su_ptr;
 986         struct scsi_device *sd = pdv->pdv_sd;
 987         unsigned char host_id[16];
 988         ssize_t bl;
 989         int i;
 990
 991         if (phv->phv_mode == PHV_VIRUTAL_HOST_ID)
 992                 snprintf(host_id, 16, "%d", pdv->pdv_host_id);
 993         else
 994                 snprintf(host_id, 16, "PHBA Mode");
 995
 996         bl = sprintf(b, "SCSI Device Bus Location:"
 997                 " Channel ID: %d Target ID: %d LUN: %d Host ID: %s\n",
 998                 pdv->pdv_channel_id, pdv->pdv_target_id, pdv->pdv_lun_id,
 999                 host_id);
1000
1001         if (sd) {
1002                 bl += sprintf(b + bl, "        ");
1003                 bl += sprintf(b + bl, "Vendor: ");
1004                 for (i = 0; i < 8; i++) {
1005                         if (ISPRINT(sd->vendor[i]))   /* printable character? */
1006                                 bl += sprintf(b + bl, "%c", sd->vendor[i]);
1007                         else
1008                                 bl += sprintf(b + bl, " ");
1009                 }
1010                 bl += sprintf(b + bl, " Model: ");
1011                 for (i = 0; i < 16; i++) {
1012                         if (ISPRINT(sd->model[i]))   /* printable character ? */
1013                                 bl += sprintf(b + bl, "%c", sd->model[i]);
1014                         else
1015                                 bl += sprintf(b + bl, " ");
1016                 }
1017                 bl += sprintf(b + bl, " Rev: ");
1018                 for (i = 0; i < 4; i++) {
1019                         if (ISPRINT(sd->rev[i]))   /* printable character ? */
1020                                 bl += sprintf(b + bl, "%c", sd->rev[i]);
1021                         else
1022                                 bl += sprintf(b + bl, " ");
1023                 }
1024                 bl += sprintf(b + bl, "\n");
1025         }
1026         return bl;
1027 }
1028
1029 static void pscsi_bi_endio(struct bio *bio, int error)
1030 {
1031         bio_put(bio);
1032 }
1033
1034 static inline struct bio *pscsi_get_bio(int sg_num)
1035 {
1036         struct bio *bio;
1037         /*
1038          * Use bio_malloc() following the comment in for bio -> struct request
1039          * in block/blk-core.c:blk_make_request()
1040          */
1041         bio = bio_kmalloc(GFP_KERNEL, sg_num);
1042         if (!bio) {
1043                 pr_err("PSCSI: bio_kmalloc() failed\n");
1044                 return NULL;
1045         }
1046         bio->bi_end_io = pscsi_bi_endio;
1047
1048         return bio;
1049 }
1050
1051 static int __pscsi_map_SG(
1052         struct se_task *task,
1053         struct scatterlist *task_sg,
1054         u32 task_sg_num,
1055         int bidi_read)
1056 {
1057         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1058         struct pscsi_dev_virt *pdv = task->se_dev->dev_ptr;
1059         struct bio *bio = NULL, *hbio = NULL, *tbio = NULL;
1060         struct page *page;
1061         struct scatterlist *sg;
1062         u32 data_len = task->task_size, i, len, bytes, off;
1063         int nr_pages = (task->task_size + task_sg[0].offset +
1064                         PAGE_SIZE - 1) >> PAGE_SHIFT;
1065         int nr_vecs = 0, rc, ret = PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES;
1066         int rw = (task->task_data_direction == DMA_TO_DEVICE);
1067
1068         if (!task->task_size)
1069                 return 0;
1070         /*
1071          * For SCF_SCSI_DATA_SG_IO_CDB, Use fs/bio.c:bio_add_page() to setup
1072          * the bio_vec maplist from task->task_sg ->
1073          * struct scatterlist memory.  The struct se_task->task_sg[] currently needs
1074          * to be attached to struct bios for submission to Linux/SCSI using
1075          * struct request to struct scsi_device->request_queue.
1076          *
1077          * Note that this will be changing post v2.6.28 as Target_Core_Mod/pSCSI
1078          * is ported to upstream SCSI passthrough functionality that accepts
1079          * struct scatterlist->page_link or struct page as a paraemeter.
1080          */
1081         pr_debug("PSCSI: nr_pages: %d\n", nr_pages);
1082
1083         for_each_sg(task_sg, sg, task_sg_num, i) {
1084                 page = sg_page(sg);
1085                 off = sg->offset;
1086                 len = sg->length;
1087
1088                 pr_debug("PSCSI: i: %d page: %p len: %d off: %d\n", i,
1089                         page, len, off);
1090
1091                 while (len > 0 && data_len > 0) {
1092                         bytes = min_t(unsigned int, len, PAGE_SIZE - off);
1093                         bytes = min(bytes, data_len);
1094
1095                         if (!bio) {
1096                                 nr_vecs = min_t(int, BIO_MAX_PAGES, nr_pages);
1097                                 nr_pages -= nr_vecs;
1098                                 /*
1099                                  * Calls bio_kmalloc() and sets bio->bi_end_io()
1100                                  */
1101                                 bio = pscsi_get_bio(nr_vecs);
1102                                 if (!bio)
1103                                         goto fail;
1104
1105                                 if (rw)
1106                                         bio->bi_rw |= REQ_WRITE;
1107
1108                                 pr_debug("PSCSI: Allocated bio: %p,"
1109                                         " dir: %s nr_vecs: %d\n", bio,
1110                                         (rw) ? "rw" : "r", nr_vecs);
1111                                 /*
1112                                  * Set *hbio pointer to handle the case:
1113                                  * nr_pages > BIO_MAX_PAGES, where additional
1114                                  * bios need to be added to complete a given
1115                                  * struct se_task
1116                                  */
1117                                 if (!hbio)
1118                                         hbio = tbio = bio;
1119                                 else
1120                                         tbio = tbio->bi_next = bio;
1121                         }
1122
1123                         pr_debug("PSCSI: Calling bio_add_pc_page() i: %d"
1124                                 " bio: %p page: %p len: %d off: %d\n", i, bio,
1125                                 page, len, off);
1126
1127                         rc = bio_add_pc_page(pdv->pdv_sd->request_queue,
1128                                         bio, page, bytes, off);
1129                         if (rc != bytes)
1130                                 goto fail;
1131
1132                         pr_debug("PSCSI: bio->bi_vcnt: %d nr_vecs: %d\n",
1133                                 bio->bi_vcnt, nr_vecs);
1134
1135                         if (bio->bi_vcnt > nr_vecs) {
1136                                 pr_debug("PSCSI: Reached bio->bi_vcnt max:"
1137                                         " %d i: %d bio: %p, allocating another"
1138                                         " bio\n", bio->bi_vcnt, i, bio);
1139                                 /*
1140                                  * Clear the pointer so that another bio will
1141                                  * be allocated with pscsi_get_bio() above, the
1142                                  * current bio has already been set *tbio and
1143                                  * bio->bi_next.
1144                                  */
1145                                 bio = NULL;
1146                         }
1147
1148                         page++;
1149                         len -= bytes;
1150                         data_len -= bytes;
1151                         off = 0;
1152                 }
1153         }
1154         /*
1155          * Setup the primary pt->pscsi_req used for non BIDI and BIDI-COMMAND
1156          * primary SCSI WRITE poayload mapped for struct se_task->task_sg[]
1157          */
1158         if (!bidi_read) {
1159                 /*
1160                  * Starting with v2.6.31, call blk_make_request() passing in *hbio to
1161                  * allocate the pSCSI task a struct request.
1162                  */
1163                 pt->pscsi_req = blk_make_request(pdv->pdv_sd->request_queue,
1164                                         hbio, GFP_KERNEL);
1165                 if (!pt->pscsi_req) {
1166                         pr_err("pSCSI: blk_make_request() failed\n");
1167                         goto fail;
1168                 }
1169                 /*
1170                  * Setup the newly allocated struct request for REQ_TYPE_BLOCK_PC,
1171                  * and setup rq callback, CDB and sense.
1172                  */
1173                 pscsi_blk_init_request(task, pt, pt->pscsi_req, 0);
1174
1175                 return task->task_sg_nents;
1176         }
1177         /*
1178          * Setup the secondary pt->pscsi_req->next_rq used for the extra BIDI-COMMAND
1179          * SCSI READ paylaod mapped for struct se_task->task_sg_bidi[]
1180          */
1181         pt->pscsi_req->next_rq = blk_make_request(pdv->pdv_sd->request_queue,
1182                                         hbio, GFP_KERNEL);
1183         if (!pt->pscsi_req->next_rq) {
1184                 pr_err("pSCSI: blk_make_request() failed for BIDI\n");
1185                 goto fail;
1186         }
1187         pscsi_blk_init_request(task, pt, pt->pscsi_req->next_rq, 1);
1188
1189         return task->task_sg_nents;
1190 fail:
1191         while (hbio) {
1192                 bio = hbio;
1193                 hbio = hbio->bi_next;
1194                 bio->bi_next = NULL;
1195                 bio_endio(bio, 0);
1196         }
1197         return ret;
1198 }
1199
1200 /*
1201  * pSCSI maps both ->map_control_SG() and ->map_data_SG() to a single call.
1202  */
1203 static int pscsi_map_SG(struct se_task *task)
1204 {
1205         int ret;
1206
1207         /*
1208          * Setup the main struct request for the task->task_sg[] payload
1209          */
1210
1211         ret = __pscsi_map_SG(task, task->task_sg, task->task_sg_nents, 0);
1212         if (ret >= 0 && task->task_sg_bidi) {
1213                 /*
1214                  * If present, set up the extra BIDI-COMMAND SCSI READ
1215                  * struct request and payload.
1216                  */
1217                 ret = __pscsi_map_SG(task, task->task_sg_bidi,
1218                                         task->task_sg_nents, 1);
1219         }
1220
1221         if (ret < 0)
1222                 return PYX_TRANSPORT_LU_COMM_FAILURE;
1223         return 0;
1224 }
1225
1226 static int pscsi_CDB_none(struct se_task *task)
1227 {
1228         return pscsi_blk_get_request(task);
1229 }
1230
1231 /*      pscsi_get_cdb():
1232  *
1233  *
1234  */
1235 static unsigned char *pscsi_get_cdb(struct se_task *task)
1236 {
1237         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1238
1239         return pt->pscsi_cdb;
1240 }
1241
1242 /*      pscsi_get_sense_buffer():
1243  *
1244  *
1245  */
1246 static unsigned char *pscsi_get_sense_buffer(struct se_task *task)
1247 {
1248         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1249
1250         return (unsigned char *)&pt->pscsi_sense[0];
1251 }
1252
1253 /*      pscsi_get_device_rev():
1254  *
1255  *
1256  */
1257 static u32 pscsi_get_device_rev(struct se_device *dev)
1258 {
1259         struct pscsi_dev_virt *pdv = dev->dev_ptr;
1260         struct scsi_device *sd = pdv->pdv_sd;
1261
1262         return (sd->scsi_level - 1) ? sd->scsi_level - 1 : 1;
1263 }
1264
1265 /*      pscsi_get_device_type():
1266  *
1267  *
1268  */
1269 static u32 pscsi_get_device_type(struct se_device *dev)
1270 {
1271         struct pscsi_dev_virt *pdv = dev->dev_ptr;
1272         struct scsi_device *sd = pdv->pdv_sd;
1273
1274         return sd->type;
1275 }
1276
1277 static sector_t pscsi_get_blocks(struct se_device *dev)
1278 {
1279         struct pscsi_dev_virt *pdv = dev->dev_ptr;
1280
1281         if (pdv->pdv_bd && pdv->pdv_bd->bd_part)
1282                 return pdv->pdv_bd->bd_part->nr_sects;
1283
1284         dump_stack();
1285         return 0;
1286 }
1287
1288 /*      pscsi_handle_SAM_STATUS_failures():
1289  *
1290  *
1291  */
1292 static inline void pscsi_process_SAM_status(
1293         struct se_task *task,
1294         struct pscsi_plugin_task *pt)
1295 {
1296         task->task_scsi_status = status_byte(pt->pscsi_result);
1297         if (task->task_scsi_status) {
1298                 task->task_scsi_status <<= 1;
1299                 pr_debug("PSCSI Status Byte exception at task: %p CDB:"
1300                         " 0x%02x Result: 0x%08x\n", task, pt->pscsi_cdb[0],
1301                         pt->pscsi_result);
1302         }
1303
1304         switch (host_byte(pt->pscsi_result)) {
1305         case DID_OK:
1306                 transport_complete_task(task, (!task->task_scsi_status));
1307                 break;
1308         default:
1309                 pr_debug("PSCSI Host Byte exception at task: %p CDB:"
1310                         " 0x%02x Result: 0x%08x\n", task, pt->pscsi_cdb[0],
1311                         pt->pscsi_result);
1312                 task->task_scsi_status = SAM_STAT_CHECK_CONDITION;
1313                 task->task_error_status = PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1314                 task->task_se_cmd->transport_error_status =
1315                                         PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1316                 transport_complete_task(task, 0);
1317                 break;
1318         }
1319 }
1320
1321 static void pscsi_req_done(struct request *req, int uptodate)
1322 {
1323         struct se_task *task = req->end_io_data;
1324         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1325
1326         pt->pscsi_result = req->errors;
1327         pt->pscsi_resid = req->resid_len;
1328
1329         pscsi_process_SAM_status(task, pt);
1330         /*
1331          * Release BIDI-READ if present
1332          */
1333         if (req->next_rq != NULL)
1334                 __blk_put_request(req->q, req->next_rq);
1335
1336         __blk_put_request(req->q, req);
1337         pt->pscsi_req = NULL;
1338 }
1339
1340 static struct se_subsystem_api pscsi_template = {
1341         .name                   = "pscsi",
1342         .owner                  = THIS_MODULE,
1343         .transport_type         = TRANSPORT_PLUGIN_PHBA_PDEV,
1344         .cdb_none               = pscsi_CDB_none,
1345         .map_control_SG         = pscsi_map_SG,
1346         .map_data_SG            = pscsi_map_SG,
1347         .attach_hba             = pscsi_attach_hba,
1348         .detach_hba             = pscsi_detach_hba,
1349         .pmode_enable_hba       = pscsi_pmode_enable_hba,
1350         .allocate_virtdevice    = pscsi_allocate_virtdevice,
1351         .create_virtdevice      = pscsi_create_virtdevice,
1352         .free_device            = pscsi_free_device,
1353         .transport_complete     = pscsi_transport_complete,
1354         .alloc_task             = pscsi_alloc_task,
1355         .do_task                = pscsi_do_task,
1356         .free_task              = pscsi_free_task,
1357         .check_configfs_dev_params = pscsi_check_configfs_dev_params,
1358         .set_configfs_dev_params = pscsi_set_configfs_dev_params,
1359         .show_configfs_dev_params = pscsi_show_configfs_dev_params,
1360         .get_cdb                = pscsi_get_cdb,
1361         .get_sense_buffer       = pscsi_get_sense_buffer,
1362         .get_device_rev         = pscsi_get_device_rev,
1363         .get_device_type        = pscsi_get_device_type,
1364         .get_blocks             = pscsi_get_blocks,
1365 };
1366
1367 static int __init pscsi_module_init(void)
1368 {
1369         return transport_subsystem_register(&pscsi_template);
1370 }
1371
1372 static void pscsi_module_exit(void)
1373 {
1374         transport_subsystem_release(&pscsi_template);
1375 }
1376
1377 MODULE_DESCRIPTION("TCM PSCSI subsystem plugin");
1378 MODULE_AUTHOR("nab@Linux-iSCSI.org");
1379 MODULE_LICENSE("GPL");
1380
1381 module_init(pscsi_module_init);
1382 module_exit(pscsi_module_exit);