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