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 ERR_CAST(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->task_se_cmd->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 void pscsi_free_task(struct se_task *task)
 780 {
 781         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
 782
 783         /*
 784          * We do not release the bio(s) here associated with this task, as
 785          * this is handled by bio_put() and pscsi_bi_endio().
 786          */
 787         kfree(pt);
 788 }
 789
 790 enum {
 791         Opt_scsi_host_id, Opt_scsi_channel_id, Opt_scsi_target_id,
 792         Opt_scsi_lun_id, Opt_err
 793 };
 794
 795 static match_table_t tokens = {
 796         {Opt_scsi_host_id, "scsi_host_id=%d"},
 797         {Opt_scsi_channel_id, "scsi_channel_id=%d"},
 798         {Opt_scsi_target_id, "scsi_target_id=%d"},
 799         {Opt_scsi_lun_id, "scsi_lun_id=%d"},
 800         {Opt_err, NULL}
 801 };
 802
 803 static ssize_t pscsi_set_configfs_dev_params(struct se_hba *hba,
 804         struct se_subsystem_dev *se_dev,
 805         const char *page,
 806         ssize_t count)
 807 {
 808         struct pscsi_dev_virt *pdv = se_dev->se_dev_su_ptr;
 809         struct pscsi_hba_virt *phv = hba->hba_ptr;
 810         char *orig, *ptr, *opts;
 811         substring_t args[MAX_OPT_ARGS];
 812         int ret = 0, arg, token;
 813
 814         opts = kstrdup(page, GFP_KERNEL);
 815         if (!opts)
 816                 return -ENOMEM;
 817
 818         orig = opts;
 819
 820         while ((ptr = strsep(&opts, ",")) != NULL) {
 821                 if (!*ptr)
 822                         continue;
 823
 824                 token = match_token(ptr, tokens, args);
 825                 switch (token) {
 826                 case Opt_scsi_host_id:
 827                         if (phv->phv_mode == PHV_LLD_SCSI_HOST_NO) {
 828                                 pr_err("PSCSI[%d]: Unable to accept"
 829                                         " scsi_host_id while phv_mode =="
 830                                         " PHV_LLD_SCSI_HOST_NO\n",
 831                                         phv->phv_host_id);
 832                                 ret = -EINVAL;
 833                                 goto out;
 834                         }
 835                         match_int(args, &arg);
 836                         pdv->pdv_host_id = arg;
 837                         pr_debug("PSCSI[%d]: Referencing SCSI Host ID:"
 838                                 " %d\n", phv->phv_host_id, pdv->pdv_host_id);
 839                         pdv->pdv_flags |= PDF_HAS_VIRT_HOST_ID;
 840                         break;
 841                 case Opt_scsi_channel_id:
 842                         match_int(args, &arg);
 843                         pdv->pdv_channel_id = arg;
 844                         pr_debug("PSCSI[%d]: Referencing SCSI Channel"
 845                                 " ID: %d\n",  phv->phv_host_id,
 846                                 pdv->pdv_channel_id);
 847                         pdv->pdv_flags |= PDF_HAS_CHANNEL_ID;
 848                         break;
 849                 case Opt_scsi_target_id:
 850                         match_int(args, &arg);
 851                         pdv->pdv_target_id = arg;
 852                         pr_debug("PSCSI[%d]: Referencing SCSI Target"
 853                                 " ID: %d\n", phv->phv_host_id,
 854                                 pdv->pdv_target_id);
 855                         pdv->pdv_flags |= PDF_HAS_TARGET_ID;
 856                         break;
 857                 case Opt_scsi_lun_id:
 858                         match_int(args, &arg);
 859                         pdv->pdv_lun_id = arg;
 860                         pr_debug("PSCSI[%d]: Referencing SCSI LUN ID:"
 861                                 " %d\n", phv->phv_host_id, pdv->pdv_lun_id);
 862                         pdv->pdv_flags |= PDF_HAS_LUN_ID;
 863                         break;
 864                 default:
 865                         break;
 866                 }
 867         }
 868
 869 out:
 870         kfree(orig);
 871         return (!ret) ? count : ret;
 872 }
 873
 874 static ssize_t pscsi_check_configfs_dev_params(
 875         struct se_hba *hba,
 876         struct se_subsystem_dev *se_dev)
 877 {
 878         struct pscsi_dev_virt *pdv = se_dev->se_dev_su_ptr;
 879
 880         if (!(pdv->pdv_flags & PDF_HAS_CHANNEL_ID) ||
 881             !(pdv->pdv_flags & PDF_HAS_TARGET_ID) ||
 882             !(pdv->pdv_flags & PDF_HAS_LUN_ID)) {
 883                 pr_err("Missing scsi_channel_id=, scsi_target_id= and"
 884                         " scsi_lun_id= parameters\n");
 885                 return -EINVAL;
 886         }
 887
 888         return 0;
 889 }
 890
 891 static ssize_t pscsi_show_configfs_dev_params(struct se_hba *hba,
 892                                               struct se_subsystem_dev *se_dev,
 893                                               char *b)
 894 {
 895         struct pscsi_hba_virt *phv = hba->hba_ptr;
 896         struct pscsi_dev_virt *pdv = se_dev->se_dev_su_ptr;
 897         struct scsi_device *sd = pdv->pdv_sd;
 898         unsigned char host_id[16];
 899         ssize_t bl;
 900         int i;
 901
 902         if (phv->phv_mode == PHV_VIRUTAL_HOST_ID)
 903                 snprintf(host_id, 16, "%d", pdv->pdv_host_id);
 904         else
 905                 snprintf(host_id, 16, "PHBA Mode");
 906
 907         bl = sprintf(b, "SCSI Device Bus Location:"
 908                 " Channel ID: %d Target ID: %d LUN: %d Host ID: %s\n",
 909                 pdv->pdv_channel_id, pdv->pdv_target_id, pdv->pdv_lun_id,
 910                 host_id);
 911
 912         if (sd) {
 913                 bl += sprintf(b + bl, "        ");
 914                 bl += sprintf(b + bl, "Vendor: ");
 915                 for (i = 0; i < 8; i++) {
 916                         if (ISPRINT(sd->vendor[i]))   /* printable character? */
 917                                 bl += sprintf(b + bl, "%c", sd->vendor[i]);
 918                         else
 919                                 bl += sprintf(b + bl, " ");
 920                 }
 921                 bl += sprintf(b + bl, " Model: ");
 922                 for (i = 0; i < 16; i++) {
 923                         if (ISPRINT(sd->model[i]))   /* printable character ? */
 924                                 bl += sprintf(b + bl, "%c", sd->model[i]);
 925                         else
 926                                 bl += sprintf(b + bl, " ");
 927                 }
 928                 bl += sprintf(b + bl, " Rev: ");
 929                 for (i = 0; i < 4; i++) {
 930                         if (ISPRINT(sd->rev[i]))   /* printable character ? */
 931                                 bl += sprintf(b + bl, "%c", sd->rev[i]);
 932                         else
 933                                 bl += sprintf(b + bl, " ");
 934                 }
 935                 bl += sprintf(b + bl, "\n");
 936         }
 937         return bl;
 938 }
 939
 940 static void pscsi_bi_endio(struct bio *bio, int error)
 941 {
 942         bio_put(bio);
 943 }
 944
 945 static inline struct bio *pscsi_get_bio(int sg_num)
 946 {
 947         struct bio *bio;
 948         /*
 949          * Use bio_malloc() following the comment in for bio -> struct request
 950          * in block/blk-core.c:blk_make_request()
 951          */
 952         bio = bio_kmalloc(GFP_KERNEL, sg_num);
 953         if (!bio) {
 954                 pr_err("PSCSI: bio_kmalloc() failed\n");
 955                 return NULL;
 956         }
 957         bio->bi_end_io = pscsi_bi_endio;
 958
 959         return bio;
 960 }
 961
 962 static int pscsi_map_sg(struct se_task *task, struct scatterlist *task_sg,
 963                 struct bio **hbio)
 964 {
 965         struct pscsi_dev_virt *pdv = task->task_se_cmd->se_dev->dev_ptr;
 966         u32 task_sg_num = task->task_sg_nents;
 967         struct bio *bio = NULL, *tbio = NULL;
 968         struct page *page;
 969         struct scatterlist *sg;
 970         u32 data_len = task->task_size, i, len, bytes, off;
 971         int nr_pages = (task->task_size + task_sg[0].offset +
 972                         PAGE_SIZE - 1) >> PAGE_SHIFT;
 973         int nr_vecs = 0, rc, ret = PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES;
 974         int rw = (task->task_data_direction == DMA_TO_DEVICE);
 975
 976         *hbio = NULL;
 977
 978         pr_debug("PSCSI: nr_pages: %d\n", nr_pages);
 979
 980         for_each_sg(task_sg, sg, task_sg_num, i) {
 981                 page = sg_page(sg);
 982                 off = sg->offset;
 983                 len = sg->length;
 984
 985                 pr_debug("PSCSI: i: %d page: %p len: %d off: %d\n", i,
 986                         page, len, off);
 987
 988                 while (len > 0 && data_len > 0) {
 989                         bytes = min_t(unsigned int, len, PAGE_SIZE - off);
 990                         bytes = min(bytes, data_len);
 991
 992                         if (!bio) {
 993                                 nr_vecs = min_t(int, BIO_MAX_PAGES, nr_pages);
 994                                 nr_pages -= nr_vecs;
 995                                 /*
 996                                  * Calls bio_kmalloc() and sets bio->bi_end_io()
 997                                  */
 998                                 bio = pscsi_get_bio(nr_vecs);
 999                                 if (!bio)
1000                                         goto fail;
1001
1002                                 if (rw)
1003                                         bio->bi_rw |= REQ_WRITE;
1004
1005                                 pr_debug("PSCSI: Allocated bio: %p,"
1006                                         " dir: %s nr_vecs: %d\n", bio,
1007                                         (rw) ? "rw" : "r", nr_vecs);
1008                                 /*
1009                                  * Set *hbio pointer to handle the case:
1010                                  * nr_pages > BIO_MAX_PAGES, where additional
1011                                  * bios need to be added to complete a given
1012                                  * struct se_task
1013                                  */
1014                                 if (!*hbio)
1015                                         *hbio = tbio = bio;
1016                                 else
1017                                         tbio = tbio->bi_next = bio;
1018                         }
1019
1020                         pr_debug("PSCSI: Calling bio_add_pc_page() i: %d"
1021                                 " bio: %p page: %p len: %d off: %d\n", i, bio,
1022                                 page, len, off);
1023
1024                         rc = bio_add_pc_page(pdv->pdv_sd->request_queue,
1025                                         bio, page, bytes, off);
1026                         if (rc != bytes)
1027                                 goto fail;
1028
1029                         pr_debug("PSCSI: bio->bi_vcnt: %d nr_vecs: %d\n",
1030                                 bio->bi_vcnt, nr_vecs);
1031
1032                         if (bio->bi_vcnt > nr_vecs) {
1033                                 pr_debug("PSCSI: Reached bio->bi_vcnt max:"
1034                                         " %d i: %d bio: %p, allocating another"
1035                                         " bio\n", bio->bi_vcnt, i, bio);
1036                                 /*
1037                                  * Clear the pointer so that another bio will
1038                                  * be allocated with pscsi_get_bio() above, the
1039                                  * current bio has already been set *tbio and
1040                                  * bio->bi_next.
1041                                  */
1042                                 bio = NULL;
1043                         }
1044
1045                         page++;
1046                         len -= bytes;
1047                         data_len -= bytes;
1048                         off = 0;
1049                 }
1050         }
1051
1052         return task->task_sg_nents;
1053 fail:
1054         while (*hbio) {
1055                 bio = *hbio;
1056                 *hbio = (*hbio)->bi_next;
1057                 bio->bi_next = NULL;
1058                 bio_endio(bio, 0);      /* XXX: should be error */
1059         }
1060         return ret;
1061 }
1062
1063 static int pscsi_do_task(struct se_task *task)
1064 {
1065         struct pscsi_dev_virt *pdv = task->task_se_cmd->se_dev->dev_ptr;
1066         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1067         struct request *req;
1068         struct bio *hbio;
1069         int ret;
1070
1071         target_get_task_cdb(task, pt->pscsi_cdb);
1072
1073         if (task->task_se_cmd->se_cmd_flags & SCF_SCSI_NON_DATA_CDB) {
1074                 req = blk_get_request(pdv->pdv_sd->request_queue,
1075                                 (task->task_data_direction == DMA_TO_DEVICE),
1076                                 GFP_KERNEL);
1077                 if (!req || IS_ERR(req)) {
1078                         pr_err("PSCSI: blk_get_request() failed: %ld\n",
1079                                         req ? IS_ERR(req) : -ENOMEM);
1080                         return PYX_TRANSPORT_LU_COMM_FAILURE;
1081                 }
1082         } else {
1083                 BUG_ON(!task->task_size);
1084
1085                 /*
1086                  * Setup the main struct request for the task->task_sg[] payload
1087                  */
1088                 ret = pscsi_map_sg(task, task->task_sg, &hbio);
1089                 if (ret < 0)
1090                         return PYX_TRANSPORT_LU_COMM_FAILURE;
1091
1092                 req = blk_make_request(pdv->pdv_sd->request_queue, hbio,
1093                                        GFP_KERNEL);
1094                 if (!req) {
1095                         pr_err("pSCSI: blk_make_request() failed\n");
1096                         goto fail;
1097                 }
1098         }
1099
1100         req->cmd_type = REQ_TYPE_BLOCK_PC;
1101         req->end_io = pscsi_req_done;
1102         req->end_io_data = task;
1103         req->cmd_len = scsi_command_size(pt->pscsi_cdb);
1104         req->cmd = &pt->pscsi_cdb[0];
1105         req->sense = &pt->pscsi_sense[0];
1106         req->sense_len = 0;
1107         if (pdv->pdv_sd->type == TYPE_DISK)
1108                 req->timeout = PS_TIMEOUT_DISK;
1109         else
1110                 req->timeout = PS_TIMEOUT_OTHER;
1111         req->retries = PS_RETRY;
1112
1113         blk_execute_rq_nowait(pdv->pdv_sd->request_queue, NULL, req,
1114                         (task->task_se_cmd->sam_task_attr == MSG_HEAD_TAG),
1115                         pscsi_req_done);
1116
1117         return PYX_TRANSPORT_SENT_TO_TRANSPORT;
1118
1119 fail:
1120         while (hbio) {
1121                 struct bio *bio = hbio;
1122                 hbio = hbio->bi_next;
1123                 bio->bi_next = NULL;
1124                 bio_endio(bio, 0);      /* XXX: should be error */
1125         }
1126         return PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES;
1127 }
1128
1129 /*      pscsi_get_sense_buffer():
1130  *
1131  *
1132  */
1133 static unsigned char *pscsi_get_sense_buffer(struct se_task *task)
1134 {
1135         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1136
1137         return (unsigned char *)&pt->pscsi_sense[0];
1138 }
1139
1140 /*      pscsi_get_device_rev():
1141  *
1142  *
1143  */
1144 static u32 pscsi_get_device_rev(struct se_device *dev)
1145 {
1146         struct pscsi_dev_virt *pdv = dev->dev_ptr;
1147         struct scsi_device *sd = pdv->pdv_sd;
1148
1149         return (sd->scsi_level - 1) ? sd->scsi_level - 1 : 1;
1150 }
1151
1152 /*      pscsi_get_device_type():
1153  *
1154  *
1155  */
1156 static u32 pscsi_get_device_type(struct se_device *dev)
1157 {
1158         struct pscsi_dev_virt *pdv = dev->dev_ptr;
1159         struct scsi_device *sd = pdv->pdv_sd;
1160
1161         return sd->type;
1162 }
1163
1164 static sector_t pscsi_get_blocks(struct se_device *dev)
1165 {
1166         struct pscsi_dev_virt *pdv = dev->dev_ptr;
1167
1168         if (pdv->pdv_bd && pdv->pdv_bd->bd_part)
1169                 return pdv->pdv_bd->bd_part->nr_sects;
1170
1171         dump_stack();
1172         return 0;
1173 }
1174
1175 /*      pscsi_handle_SAM_STATUS_failures():
1176  *
1177  *
1178  */
1179 static inline void pscsi_process_SAM_status(
1180         struct se_task *task,
1181         struct pscsi_plugin_task *pt)
1182 {
1183         task->task_scsi_status = status_byte(pt->pscsi_result);
1184         if (task->task_scsi_status) {
1185                 task->task_scsi_status <<= 1;
1186                 pr_debug("PSCSI Status Byte exception at task: %p CDB:"
1187                         " 0x%02x Result: 0x%08x\n", task, pt->pscsi_cdb[0],
1188                         pt->pscsi_result);
1189         }
1190
1191         switch (host_byte(pt->pscsi_result)) {
1192         case DID_OK:
1193                 transport_complete_task(task, (!task->task_scsi_status));
1194                 break;
1195         default:
1196                 pr_debug("PSCSI Host Byte exception at task: %p CDB:"
1197                         " 0x%02x Result: 0x%08x\n", task, pt->pscsi_cdb[0],
1198                         pt->pscsi_result);
1199                 task->task_scsi_status = SAM_STAT_CHECK_CONDITION;
1200                 task->task_error_status = PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1201                 task->task_se_cmd->transport_error_status =
1202                                         PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1203                 transport_complete_task(task, 0);
1204                 break;
1205         }
1206 }
1207
1208 static void pscsi_req_done(struct request *req, int uptodate)
1209 {
1210         struct se_task *task = req->end_io_data;
1211         struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1212
1213         pt->pscsi_result = req->errors;
1214         pt->pscsi_resid = req->resid_len;
1215
1216         pscsi_process_SAM_status(task, pt);
1217         __blk_put_request(req->q, req);
1218 }
1219
1220 static struct se_subsystem_api pscsi_template = {
1221         .name                   = "pscsi",
1222         .owner                  = THIS_MODULE,
1223         .transport_type         = TRANSPORT_PLUGIN_PHBA_PDEV,
1224         .attach_hba             = pscsi_attach_hba,
1225         .detach_hba             = pscsi_detach_hba,
1226         .pmode_enable_hba       = pscsi_pmode_enable_hba,
1227         .allocate_virtdevice    = pscsi_allocate_virtdevice,
1228         .create_virtdevice      = pscsi_create_virtdevice,
1229         .free_device            = pscsi_free_device,
1230         .transport_complete     = pscsi_transport_complete,
1231         .alloc_task             = pscsi_alloc_task,
1232         .do_task                = pscsi_do_task,
1233         .free_task              = pscsi_free_task,
1234         .check_configfs_dev_params = pscsi_check_configfs_dev_params,
1235         .set_configfs_dev_params = pscsi_set_configfs_dev_params,
1236         .show_configfs_dev_params = pscsi_show_configfs_dev_params,
1237         .get_sense_buffer       = pscsi_get_sense_buffer,
1238         .get_device_rev         = pscsi_get_device_rev,
1239         .get_device_type        = pscsi_get_device_type,
1240         .get_blocks             = pscsi_get_blocks,
1241 };
1242
1243 static int __init pscsi_module_init(void)
1244 {
1245         return transport_subsystem_register(&pscsi_template);
1246 }
1247
1248 static void pscsi_module_exit(void)
1249 {
1250         transport_subsystem_release(&pscsi_template);
1251 }
1252
1253 MODULE_DESCRIPTION("TCM PSCSI subsystem plugin");
1254 MODULE_AUTHOR("nab@Linux-iSCSI.org");
1255 MODULE_LICENSE("GPL");
1256
1257 module_init(pscsi_module_init);
1258 module_exit(pscsi_module_exit);