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