1 /*******************************************************************************
2  * Filename:  target_core_pscsi.c
3  *
4  * This file contains the generic target mode <-> Linux SCSI subsystem plugin.
5  *
6  * (c) Copyright 2003-2013 Datera, Inc.
7  *
8  * Nicholas A. Bellinger <nab@kernel.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23  *
24  ******************************************************************************/
25 
26 #include <linux/string.h>
27 #include <linux/parser.h>
28 #include <linux/timer.h>
29 #include <linux/blkdev.h>
30 #include <linux/blk_types.h>
31 #include <linux/slab.h>
32 #include <linux/spinlock.h>
33 #include <linux/genhd.h>
34 #include <linux/cdrom.h>
35 #include <linux/ratelimit.h>
36 #include <linux/module.h>
37 #include <asm/unaligned.h>
38 
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_backend.h>
47 
48 #include "target_core_alua.h"
49 #include "target_core_pscsi.h"
50 
51 #define ISPRINT(a)  ((a >= ' ') && (a <= '~'))
52 
53 static inline struct pscsi_dev_virt *PSCSI_DEV(struct se_device *dev)
54 {
55 	return container_of(dev, struct pscsi_dev_virt, dev);
56 }
57 
58 static struct se_subsystem_api pscsi_template;
59 
60 static sense_reason_t pscsi_execute_cmd(struct se_cmd *cmd);
61 static void pscsi_req_done(struct request *, int);
62 
63 /*	pscsi_attach_hba():
64  *
65  * 	pscsi_get_sh() used scsi_host_lookup() to locate struct Scsi_Host.
66  *	from the passed SCSI Host ID.
67  */
68 static int pscsi_attach_hba(struct se_hba *hba, u32 host_id)
69 {
70 	struct pscsi_hba_virt *phv;
71 
72 	phv = kzalloc(sizeof(struct pscsi_hba_virt), GFP_KERNEL);
73 	if (!phv) {
74 		pr_err("Unable to allocate struct pscsi_hba_virt\n");
75 		return -ENOMEM;
76 	}
77 	phv->phv_host_id = host_id;
78 	phv->phv_mode = PHV_VIRTUAL_HOST_ID;
79 
80 	hba->hba_ptr = phv;
81 
82 	pr_debug("CORE_HBA[%d] - TCM SCSI HBA Driver %s on"
83 		" Generic Target Core Stack %s\n", hba->hba_id,
84 		PSCSI_VERSION, TARGET_CORE_MOD_VERSION);
85 	pr_debug("CORE_HBA[%d] - Attached SCSI HBA to Generic\n",
86 	       hba->hba_id);
87 
88 	return 0;
89 }
90 
91 static void pscsi_detach_hba(struct se_hba *hba)
92 {
93 	struct pscsi_hba_virt *phv = hba->hba_ptr;
94 	struct Scsi_Host *scsi_host = phv->phv_lld_host;
95 
96 	if (scsi_host) {
97 		scsi_host_put(scsi_host);
98 
99 		pr_debug("CORE_HBA[%d] - Detached SCSI HBA: %s from"
100 			" Generic Target Core\n", hba->hba_id,
101 			(scsi_host->hostt->name) ? (scsi_host->hostt->name) :
102 			"Unknown");
103 	} else
104 		pr_debug("CORE_HBA[%d] - Detached Virtual SCSI HBA"
105 			" from Generic Target Core\n", hba->hba_id);
106 
107 	kfree(phv);
108 	hba->hba_ptr = NULL;
109 }
110 
111 static int pscsi_pmode_enable_hba(struct se_hba *hba, unsigned long mode_flag)
112 {
113 	struct pscsi_hba_virt *phv = hba->hba_ptr;
114 	struct Scsi_Host *sh = phv->phv_lld_host;
115 	/*
116 	 * Release the struct Scsi_Host
117 	 */
118 	if (!mode_flag) {
119 		if (!sh)
120 			return 0;
121 
122 		phv->phv_lld_host = NULL;
123 		phv->phv_mode = PHV_VIRTUAL_HOST_ID;
124 
125 		pr_debug("CORE_HBA[%d] - Disabled pSCSI HBA Passthrough"
126 			" %s\n", hba->hba_id, (sh->hostt->name) ?
127 			(sh->hostt->name) : "Unknown");
128 
129 		scsi_host_put(sh);
130 		return 0;
131 	}
132 	/*
133 	 * Otherwise, locate struct Scsi_Host from the original passed
134 	 * pSCSI Host ID and enable for phba mode
135 	 */
136 	sh = scsi_host_lookup(phv->phv_host_id);
137 	if (!sh) {
138 		pr_err("pSCSI: Unable to locate SCSI Host for"
139 			" phv_host_id: %d\n", phv->phv_host_id);
140 		return -EINVAL;
141 	}
142 
143 	phv->phv_lld_host = sh;
144 	phv->phv_mode = PHV_LLD_SCSI_HOST_NO;
145 
146 	pr_debug("CORE_HBA[%d] - Enabled pSCSI HBA Passthrough %s\n",
147 		hba->hba_id, (sh->hostt->name) ? (sh->hostt->name) : "Unknown");
148 
149 	return 1;
150 }
151 
152 static void pscsi_tape_read_blocksize(struct se_device *dev,
153 		struct scsi_device *sdev)
154 {
155 	unsigned char cdb[MAX_COMMAND_SIZE], *buf;
156 	int ret;
157 
158 	buf = kzalloc(12, GFP_KERNEL);
159 	if (!buf)
160 		return;
161 
162 	memset(cdb, 0, MAX_COMMAND_SIZE);
163 	cdb[0] = MODE_SENSE;
164 	cdb[4] = 0x0c; /* 12 bytes */
165 
166 	ret = scsi_execute_req(sdev, cdb, DMA_FROM_DEVICE, buf, 12, NULL,
167 			HZ, 1, NULL);
168 	if (ret)
169 		goto out_free;
170 
171 	/*
172 	 * If MODE_SENSE still returns zero, set the default value to 1024.
173 	 */
174 	sdev->sector_size = (buf[9] << 16) | (buf[10] << 8) | (buf[11]);
175 	if (!sdev->sector_size)
176 		sdev->sector_size = 1024;
177 out_free:
178 	kfree(buf);
179 }
180 
181 static void
182 pscsi_set_inquiry_info(struct scsi_device *sdev, struct t10_wwn *wwn)
183 {
184 	unsigned char *buf;
185 
186 	if (sdev->inquiry_len < INQUIRY_LEN)
187 		return;
188 
189 	buf = sdev->inquiry;
190 	if (!buf)
191 		return;
192 	/*
193 	 * Use sdev->inquiry from drivers/scsi/scsi_scan.c:scsi_alloc_sdev()
194 	 */
195 	memcpy(&wwn->vendor[0], &buf[8], sizeof(wwn->vendor));
196 	memcpy(&wwn->model[0], &buf[16], sizeof(wwn->model));
197 	memcpy(&wwn->revision[0], &buf[32], sizeof(wwn->revision));
198 }
199 
200 static int
201 pscsi_get_inquiry_vpd_serial(struct scsi_device *sdev, struct t10_wwn *wwn)
202 {
203 	unsigned char cdb[MAX_COMMAND_SIZE], *buf;
204 	int ret;
205 
206 	buf = kzalloc(INQUIRY_VPD_SERIAL_LEN, GFP_KERNEL);
207 	if (!buf)
208 		return -ENOMEM;
209 
210 	memset(cdb, 0, MAX_COMMAND_SIZE);
211 	cdb[0] = INQUIRY;
212 	cdb[1] = 0x01; /* Query VPD */
213 	cdb[2] = 0x80; /* Unit Serial Number */
214 	cdb[3] = (INQUIRY_VPD_SERIAL_LEN >> 8) & 0xff;
215 	cdb[4] = (INQUIRY_VPD_SERIAL_LEN & 0xff);
216 
217 	ret = scsi_execute_req(sdev, cdb, DMA_FROM_DEVICE, buf,
218 			      INQUIRY_VPD_SERIAL_LEN, NULL, HZ, 1, NULL);
219 	if (ret)
220 		goto out_free;
221 
222 	snprintf(&wwn->unit_serial[0], INQUIRY_VPD_SERIAL_LEN, "%s", &buf[4]);
223 
224 	wwn->t10_dev->dev_flags |= DF_FIRMWARE_VPD_UNIT_SERIAL;
225 
226 	kfree(buf);
227 	return 0;
228 
229 out_free:
230 	kfree(buf);
231 	return -EPERM;
232 }
233 
234 static void
235 pscsi_get_inquiry_vpd_device_ident(struct scsi_device *sdev,
236 		struct t10_wwn *wwn)
237 {
238 	unsigned char cdb[MAX_COMMAND_SIZE], *buf, *page_83;
239 	int ident_len, page_len, off = 4, ret;
240 	struct t10_vpd *vpd;
241 
242 	buf = kzalloc(INQUIRY_VPD_SERIAL_LEN, GFP_KERNEL);
243 	if (!buf)
244 		return;
245 
246 	memset(cdb, 0, MAX_COMMAND_SIZE);
247 	cdb[0] = INQUIRY;
248 	cdb[1] = 0x01; /* Query VPD */
249 	cdb[2] = 0x83; /* Device Identifier */
250 	cdb[3] = (INQUIRY_VPD_DEVICE_IDENTIFIER_LEN >> 8) & 0xff;
251 	cdb[4] = (INQUIRY_VPD_DEVICE_IDENTIFIER_LEN & 0xff);
252 
253 	ret = scsi_execute_req(sdev, cdb, DMA_FROM_DEVICE, buf,
254 			      INQUIRY_VPD_DEVICE_IDENTIFIER_LEN,
255 			      NULL, HZ, 1, NULL);
256 	if (ret)
257 		goto out;
258 
259 	page_len = (buf[2] << 8) | buf[3];
260 	while (page_len > 0) {
261 		/* Grab a pointer to the Identification descriptor */
262 		page_83 = &buf[off];
263 		ident_len = page_83[3];
264 		if (!ident_len) {
265 			pr_err("page_83[3]: identifier"
266 					" length zero!\n");
267 			break;
268 		}
269 		pr_debug("T10 VPD Identifier Length: %d\n", ident_len);
270 
271 		vpd = kzalloc(sizeof(struct t10_vpd), GFP_KERNEL);
272 		if (!vpd) {
273 			pr_err("Unable to allocate memory for"
274 					" struct t10_vpd\n");
275 			goto out;
276 		}
277 		INIT_LIST_HEAD(&vpd->vpd_list);
278 
279 		transport_set_vpd_proto_id(vpd, page_83);
280 		transport_set_vpd_assoc(vpd, page_83);
281 
282 		if (transport_set_vpd_ident_type(vpd, page_83) < 0) {
283 			off += (ident_len + 4);
284 			page_len -= (ident_len + 4);
285 			kfree(vpd);
286 			continue;
287 		}
288 		if (transport_set_vpd_ident(vpd, page_83) < 0) {
289 			off += (ident_len + 4);
290 			page_len -= (ident_len + 4);
291 			kfree(vpd);
292 			continue;
293 		}
294 
295 		list_add_tail(&vpd->vpd_list, &wwn->t10_vpd_list);
296 		off += (ident_len + 4);
297 		page_len -= (ident_len + 4);
298 	}
299 
300 out:
301 	kfree(buf);
302 }
303 
304 static int pscsi_add_device_to_list(struct se_device *dev,
305 		struct scsi_device *sd)
306 {
307 	struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
308 	struct request_queue *q = sd->request_queue;
309 
310 	pdv->pdv_sd = sd;
311 
312 	if (!sd->queue_depth) {
313 		sd->queue_depth = PSCSI_DEFAULT_QUEUEDEPTH;
314 
315 		pr_err("Set broken SCSI Device %d:%d:%llu"
316 			" queue_depth to %d\n", sd->channel, sd->id,
317 				sd->lun, sd->queue_depth);
318 	}
319 
320 	dev->dev_attrib.hw_block_size = sd->sector_size;
321 	dev->dev_attrib.hw_max_sectors =
322 		min_t(int, sd->host->max_sectors, queue_max_hw_sectors(q));
323 	dev->dev_attrib.hw_queue_depth = sd->queue_depth;
324 
325 	/*
326 	 * Setup our standard INQUIRY info into se_dev->t10_wwn
327 	 */
328 	pscsi_set_inquiry_info(sd, &dev->t10_wwn);
329 
330 	/*
331 	 * Locate VPD WWN Information used for various purposes within
332 	 * the Storage Engine.
333 	 */
334 	if (!pscsi_get_inquiry_vpd_serial(sd, &dev->t10_wwn)) {
335 		/*
336 		 * If VPD Unit Serial returned GOOD status, try
337 		 * VPD Device Identification page (0x83).
338 		 */
339 		pscsi_get_inquiry_vpd_device_ident(sd, &dev->t10_wwn);
340 	}
341 
342 	/*
343 	 * For TYPE_TAPE, attempt to determine blocksize with MODE_SENSE.
344 	 */
345 	if (sd->type == TYPE_TAPE)
346 		pscsi_tape_read_blocksize(dev, sd);
347 	return 0;
348 }
349 
350 static struct se_device *pscsi_alloc_device(struct se_hba *hba,
351 		const char *name)
352 {
353 	struct pscsi_dev_virt *pdv;
354 
355 	pdv = kzalloc(sizeof(struct pscsi_dev_virt), GFP_KERNEL);
356 	if (!pdv) {
357 		pr_err("Unable to allocate memory for struct pscsi_dev_virt\n");
358 		return NULL;
359 	}
360 
361 	pr_debug("PSCSI: Allocated pdv: %p for %s\n", pdv, name);
362 	return &pdv->dev;
363 }
364 
365 /*
366  * Called with struct Scsi_Host->host_lock called.
367  */
368 static int pscsi_create_type_disk(struct se_device *dev, struct scsi_device *sd)
369 	__releases(sh->host_lock)
370 {
371 	struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;
372 	struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
373 	struct Scsi_Host *sh = sd->host;
374 	struct block_device *bd;
375 	int ret;
376 
377 	if (scsi_device_get(sd)) {
378 		pr_err("scsi_device_get() failed for %d:%d:%d:%llu\n",
379 			sh->host_no, sd->channel, sd->id, sd->lun);
380 		spin_unlock_irq(sh->host_lock);
381 		return -EIO;
382 	}
383 	spin_unlock_irq(sh->host_lock);
384 	/*
385 	 * Claim exclusive struct block_device access to struct scsi_device
386 	 * for TYPE_DISK using supplied udev_path
387 	 */
388 	bd = blkdev_get_by_path(dev->udev_path,
389 				FMODE_WRITE|FMODE_READ|FMODE_EXCL, pdv);
390 	if (IS_ERR(bd)) {
391 		pr_err("pSCSI: blkdev_get_by_path() failed\n");
392 		scsi_device_put(sd);
393 		return PTR_ERR(bd);
394 	}
395 	pdv->pdv_bd = bd;
396 
397 	ret = pscsi_add_device_to_list(dev, sd);
398 	if (ret) {
399 		blkdev_put(pdv->pdv_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
400 		scsi_device_put(sd);
401 		return ret;
402 	}
403 
404 	pr_debug("CORE_PSCSI[%d] - Added TYPE_DISK for %d:%d:%d:%llu\n",
405 		phv->phv_host_id, sh->host_no, sd->channel, sd->id, sd->lun);
406 	return 0;
407 }
408 
409 /*
410  * Called with struct Scsi_Host->host_lock called.
411  */
412 static int pscsi_create_type_rom(struct se_device *dev, struct scsi_device *sd)
413 	__releases(sh->host_lock)
414 {
415 	struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;
416 	struct Scsi_Host *sh = sd->host;
417 	int ret;
418 
419 	if (scsi_device_get(sd)) {
420 		pr_err("scsi_device_get() failed for %d:%d:%d:%llu\n",
421 			sh->host_no, sd->channel, sd->id, sd->lun);
422 		spin_unlock_irq(sh->host_lock);
423 		return -EIO;
424 	}
425 	spin_unlock_irq(sh->host_lock);
426 
427 	ret = pscsi_add_device_to_list(dev, sd);
428 	if (ret) {
429 		scsi_device_put(sd);
430 		return ret;
431 	}
432 	pr_debug("CORE_PSCSI[%d] - Added Type: %s for %d:%d:%d:%llu\n",
433 		phv->phv_host_id, scsi_device_type(sd->type), sh->host_no,
434 		sd->channel, sd->id, sd->lun);
435 
436 	return 0;
437 }
438 
439 /*
440  * Called with struct Scsi_Host->host_lock called.
441  */
442 static int pscsi_create_type_other(struct se_device *dev,
443 		struct scsi_device *sd)
444 	__releases(sh->host_lock)
445 {
446 	struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;
447 	struct Scsi_Host *sh = sd->host;
448 	int ret;
449 
450 	spin_unlock_irq(sh->host_lock);
451 	ret = pscsi_add_device_to_list(dev, sd);
452 	if (ret)
453 		return ret;
454 
455 	pr_debug("CORE_PSCSI[%d] - Added Type: %s for %d:%d:%d:%llu\n",
456 		phv->phv_host_id, scsi_device_type(sd->type), sh->host_no,
457 		sd->channel, sd->id, sd->lun);
458 	return 0;
459 }
460 
461 static int pscsi_configure_device(struct se_device *dev)
462 {
463 	struct se_hba *hba = dev->se_hba;
464 	struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
465 	struct scsi_device *sd;
466 	struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;
467 	struct Scsi_Host *sh = phv->phv_lld_host;
468 	int legacy_mode_enable = 0;
469 	int ret;
470 
471 	if (!(pdv->pdv_flags & PDF_HAS_CHANNEL_ID) ||
472 	    !(pdv->pdv_flags & PDF_HAS_TARGET_ID) ||
473 	    !(pdv->pdv_flags & PDF_HAS_LUN_ID)) {
474 		pr_err("Missing scsi_channel_id=, scsi_target_id= and"
475 			" scsi_lun_id= parameters\n");
476 		return -EINVAL;
477 	}
478 
479 	/*
480 	 * If not running in PHV_LLD_SCSI_HOST_NO mode, locate the
481 	 * struct Scsi_Host we will need to bring the TCM/pSCSI object online
482 	 */
483 	if (!sh) {
484 		if (phv->phv_mode == PHV_LLD_SCSI_HOST_NO) {
485 			pr_err("pSCSI: Unable to locate struct"
486 				" Scsi_Host for PHV_LLD_SCSI_HOST_NO\n");
487 			return -ENODEV;
488 		}
489 		/*
490 		 * For the newer PHV_VIRTUAL_HOST_ID struct scsi_device
491 		 * reference, we enforce that udev_path has been set
492 		 */
493 		if (!(dev->dev_flags & DF_USING_UDEV_PATH)) {
494 			pr_err("pSCSI: udev_path attribute has not"
495 				" been set before ENABLE=1\n");
496 			return -EINVAL;
497 		}
498 		/*
499 		 * If no scsi_host_id= was passed for PHV_VIRTUAL_HOST_ID,
500 		 * use the original TCM hba ID to reference Linux/SCSI Host No
501 		 * and enable for PHV_LLD_SCSI_HOST_NO mode.
502 		 */
503 		if (!(pdv->pdv_flags & PDF_HAS_VIRT_HOST_ID)) {
504 			if (hba->dev_count) {
505 				pr_err("pSCSI: Unable to set hba_mode"
506 					" with active devices\n");
507 				return -EEXIST;
508 			}
509 
510 			if (pscsi_pmode_enable_hba(hba, 1) != 1)
511 				return -ENODEV;
512 
513 			legacy_mode_enable = 1;
514 			hba->hba_flags |= HBA_FLAGS_PSCSI_MODE;
515 			sh = phv->phv_lld_host;
516 		} else {
517 			sh = scsi_host_lookup(pdv->pdv_host_id);
518 			if (!sh) {
519 				pr_err("pSCSI: Unable to locate"
520 					" pdv_host_id: %d\n", pdv->pdv_host_id);
521 				return -EINVAL;
522 			}
523 		}
524 	} else {
525 		if (phv->phv_mode == PHV_VIRTUAL_HOST_ID) {
526 			pr_err("pSCSI: PHV_VIRTUAL_HOST_ID set while"
527 				" struct Scsi_Host exists\n");
528 			return -EEXIST;
529 		}
530 	}
531 
532 	spin_lock_irq(sh->host_lock);
533 	list_for_each_entry(sd, &sh->__devices, siblings) {
534 		if ((pdv->pdv_channel_id != sd->channel) ||
535 		    (pdv->pdv_target_id != sd->id) ||
536 		    (pdv->pdv_lun_id != sd->lun))
537 			continue;
538 		/*
539 		 * Functions will release the held struct scsi_host->host_lock
540 		 * before calling calling pscsi_add_device_to_list() to register
541 		 * struct scsi_device with target_core_mod.
542 		 */
543 		switch (sd->type) {
544 		case TYPE_DISK:
545 			ret = pscsi_create_type_disk(dev, sd);
546 			break;
547 		case TYPE_ROM:
548 			ret = pscsi_create_type_rom(dev, sd);
549 			break;
550 		default:
551 			ret = pscsi_create_type_other(dev, sd);
552 			break;
553 		}
554 
555 		if (ret) {
556 			if (phv->phv_mode == PHV_VIRTUAL_HOST_ID)
557 				scsi_host_put(sh);
558 			else if (legacy_mode_enable) {
559 				pscsi_pmode_enable_hba(hba, 0);
560 				hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE;
561 			}
562 			pdv->pdv_sd = NULL;
563 			return ret;
564 		}
565 		return 0;
566 	}
567 	spin_unlock_irq(sh->host_lock);
568 
569 	pr_err("pSCSI: Unable to locate %d:%d:%d:%d\n", sh->host_no,
570 		pdv->pdv_channel_id,  pdv->pdv_target_id, pdv->pdv_lun_id);
571 
572 	if (phv->phv_mode == PHV_VIRTUAL_HOST_ID)
573 		scsi_host_put(sh);
574 	else if (legacy_mode_enable) {
575 		pscsi_pmode_enable_hba(hba, 0);
576 		hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE;
577 	}
578 
579 	return -ENODEV;
580 }
581 
582 static void pscsi_free_device(struct se_device *dev)
583 {
584 	struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
585 	struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;
586 	struct scsi_device *sd = pdv->pdv_sd;
587 
588 	if (sd) {
589 		/*
590 		 * Release exclusive pSCSI internal struct block_device claim for
591 		 * struct scsi_device with TYPE_DISK from pscsi_create_type_disk()
592 		 */
593 		if ((sd->type == TYPE_DISK) && pdv->pdv_bd) {
594 			blkdev_put(pdv->pdv_bd,
595 				   FMODE_WRITE|FMODE_READ|FMODE_EXCL);
596 			pdv->pdv_bd = NULL;
597 		}
598 		/*
599 		 * For HBA mode PHV_LLD_SCSI_HOST_NO, release the reference
600 		 * to struct Scsi_Host now.
601 		 */
602 		if ((phv->phv_mode == PHV_LLD_SCSI_HOST_NO) &&
603 		    (phv->phv_lld_host != NULL))
604 			scsi_host_put(phv->phv_lld_host);
605 
606 		if ((sd->type == TYPE_DISK) || (sd->type == TYPE_ROM))
607 			scsi_device_put(sd);
608 
609 		pdv->pdv_sd = NULL;
610 	}
611 
612 	kfree(pdv);
613 }
614 
615 static void pscsi_transport_complete(struct se_cmd *cmd, struct scatterlist *sg,
616 				     unsigned char *sense_buffer)
617 {
618 	struct pscsi_dev_virt *pdv = PSCSI_DEV(cmd->se_dev);
619 	struct scsi_device *sd = pdv->pdv_sd;
620 	int result;
621 	struct pscsi_plugin_task *pt = cmd->priv;
622 	unsigned char *cdb;
623 	/*
624 	 * Special case for REPORT_LUNs handling where pscsi_plugin_task has
625 	 * not been allocated because TCM is handling the emulation directly.
626 	 */
627 	if (!pt)
628 		return;
629 
630 	cdb = &pt->pscsi_cdb[0];
631 	result = pt->pscsi_result;
632 	/*
633 	 * Hack to make sure that Write-Protect modepage is set if R/O mode is
634 	 * forced.
635 	 */
636 	if (!cmd->se_deve || !cmd->data_length)
637 		goto after_mode_sense;
638 
639 	if (((cdb[0] == MODE_SENSE) || (cdb[0] == MODE_SENSE_10)) &&
640 	     (status_byte(result) << 1) == SAM_STAT_GOOD) {
641 		if (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY) {
642 			unsigned char *buf;
643 
644 			buf = transport_kmap_data_sg(cmd);
645 			if (!buf)
646 				; /* XXX: TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE */
647 
648 			if (cdb[0] == MODE_SENSE_10) {
649 				if (!(buf[3] & 0x80))
650 					buf[3] |= 0x80;
651 			} else {
652 				if (!(buf[2] & 0x80))
653 					buf[2] |= 0x80;
654 			}
655 
656 			transport_kunmap_data_sg(cmd);
657 		}
658 	}
659 after_mode_sense:
660 
661 	if (sd->type != TYPE_TAPE || !cmd->data_length)
662 		goto after_mode_select;
663 
664 	/*
665 	 * Hack to correctly obtain the initiator requested blocksize for
666 	 * TYPE_TAPE.  Since this value is dependent upon each tape media,
667 	 * struct scsi_device->sector_size will not contain the correct value
668 	 * by default, so we go ahead and set it so
669 	 * TRANSPORT(dev)->get_blockdev() returns the correct value to the
670 	 * storage engine.
671 	 */
672 	if (((cdb[0] == MODE_SELECT) || (cdb[0] == MODE_SELECT_10)) &&
673 	      (status_byte(result) << 1) == SAM_STAT_GOOD) {
674 		unsigned char *buf;
675 		u16 bdl;
676 		u32 blocksize;
677 
678 		buf = sg_virt(&sg[0]);
679 		if (!buf) {
680 			pr_err("Unable to get buf for scatterlist\n");
681 			goto after_mode_select;
682 		}
683 
684 		if (cdb[0] == MODE_SELECT)
685 			bdl = (buf[3]);
686 		else
687 			bdl = (buf[6] << 8) | (buf[7]);
688 
689 		if (!bdl)
690 			goto after_mode_select;
691 
692 		if (cdb[0] == MODE_SELECT)
693 			blocksize = (buf[9] << 16) | (buf[10] << 8) |
694 					(buf[11]);
695 		else
696 			blocksize = (buf[13] << 16) | (buf[14] << 8) |
697 					(buf[15]);
698 
699 		sd->sector_size = blocksize;
700 	}
701 after_mode_select:
702 
703 	if (sense_buffer && (status_byte(result) & CHECK_CONDITION)) {
704 		memcpy(sense_buffer, pt->pscsi_sense, TRANSPORT_SENSE_BUFFER);
705 		cmd->se_cmd_flags |= SCF_TRANSPORT_TASK_SENSE;
706 	}
707 }
708 
709 enum {
710 	Opt_scsi_host_id, Opt_scsi_channel_id, Opt_scsi_target_id,
711 	Opt_scsi_lun_id, Opt_err
712 };
713 
714 static match_table_t tokens = {
715 	{Opt_scsi_host_id, "scsi_host_id=%d"},
716 	{Opt_scsi_channel_id, "scsi_channel_id=%d"},
717 	{Opt_scsi_target_id, "scsi_target_id=%d"},
718 	{Opt_scsi_lun_id, "scsi_lun_id=%d"},
719 	{Opt_err, NULL}
720 };
721 
722 static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
723 		const char *page, ssize_t count)
724 {
725 	struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
726 	struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;
727 	char *orig, *ptr, *opts;
728 	substring_t args[MAX_OPT_ARGS];
729 	int ret = 0, arg, token;
730 
731 	opts = kstrdup(page, GFP_KERNEL);
732 	if (!opts)
733 		return -ENOMEM;
734 
735 	orig = opts;
736 
737 	while ((ptr = strsep(&opts, ",\n")) != NULL) {
738 		if (!*ptr)
739 			continue;
740 
741 		token = match_token(ptr, tokens, args);
742 		switch (token) {
743 		case Opt_scsi_host_id:
744 			if (phv->phv_mode == PHV_LLD_SCSI_HOST_NO) {
745 				pr_err("PSCSI[%d]: Unable to accept"
746 					" scsi_host_id while phv_mode =="
747 					" PHV_LLD_SCSI_HOST_NO\n",
748 					phv->phv_host_id);
749 				ret = -EINVAL;
750 				goto out;
751 			}
752 			ret = match_int(args, &arg);
753 			if (ret)
754 				goto out;
755 			pdv->pdv_host_id = arg;
756 			pr_debug("PSCSI[%d]: Referencing SCSI Host ID:"
757 				" %d\n", phv->phv_host_id, pdv->pdv_host_id);
758 			pdv->pdv_flags |= PDF_HAS_VIRT_HOST_ID;
759 			break;
760 		case Opt_scsi_channel_id:
761 			ret = match_int(args, &arg);
762 			if (ret)
763 				goto out;
764 			pdv->pdv_channel_id = arg;
765 			pr_debug("PSCSI[%d]: Referencing SCSI Channel"
766 				" ID: %d\n",  phv->phv_host_id,
767 				pdv->pdv_channel_id);
768 			pdv->pdv_flags |= PDF_HAS_CHANNEL_ID;
769 			break;
770 		case Opt_scsi_target_id:
771 			ret = match_int(args, &arg);
772 			if (ret)
773 				goto out;
774 			pdv->pdv_target_id = arg;
775 			pr_debug("PSCSI[%d]: Referencing SCSI Target"
776 				" ID: %d\n", phv->phv_host_id,
777 				pdv->pdv_target_id);
778 			pdv->pdv_flags |= PDF_HAS_TARGET_ID;
779 			break;
780 		case Opt_scsi_lun_id:
781 			ret = match_int(args, &arg);
782 			if (ret)
783 				goto out;
784 			pdv->pdv_lun_id = arg;
785 			pr_debug("PSCSI[%d]: Referencing SCSI LUN ID:"
786 				" %d\n", phv->phv_host_id, pdv->pdv_lun_id);
787 			pdv->pdv_flags |= PDF_HAS_LUN_ID;
788 			break;
789 		default:
790 			break;
791 		}
792 	}
793 
794 out:
795 	kfree(orig);
796 	return (!ret) ? count : ret;
797 }
798 
799 static ssize_t pscsi_show_configfs_dev_params(struct se_device *dev, char *b)
800 {
801 	struct pscsi_hba_virt *phv = dev->se_hba->hba_ptr;
802 	struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
803 	struct scsi_device *sd = pdv->pdv_sd;
804 	unsigned char host_id[16];
805 	ssize_t bl;
806 	int i;
807 
808 	if (phv->phv_mode == PHV_VIRTUAL_HOST_ID)
809 		snprintf(host_id, 16, "%d", pdv->pdv_host_id);
810 	else
811 		snprintf(host_id, 16, "PHBA Mode");
812 
813 	bl = sprintf(b, "SCSI Device Bus Location:"
814 		" Channel ID: %d Target ID: %d LUN: %d Host ID: %s\n",
815 		pdv->pdv_channel_id, pdv->pdv_target_id, pdv->pdv_lun_id,
816 		host_id);
817 
818 	if (sd) {
819 		bl += sprintf(b + bl, "        ");
820 		bl += sprintf(b + bl, "Vendor: ");
821 		for (i = 0; i < 8; i++) {
822 			if (ISPRINT(sd->vendor[i]))   /* printable character? */
823 				bl += sprintf(b + bl, "%c", sd->vendor[i]);
824 			else
825 				bl += sprintf(b + bl, " ");
826 		}
827 		bl += sprintf(b + bl, " Model: ");
828 		for (i = 0; i < 16; i++) {
829 			if (ISPRINT(sd->model[i]))   /* printable character ? */
830 				bl += sprintf(b + bl, "%c", sd->model[i]);
831 			else
832 				bl += sprintf(b + bl, " ");
833 		}
834 		bl += sprintf(b + bl, " Rev: ");
835 		for (i = 0; i < 4; i++) {
836 			if (ISPRINT(sd->rev[i]))   /* printable character ? */
837 				bl += sprintf(b + bl, "%c", sd->rev[i]);
838 			else
839 				bl += sprintf(b + bl, " ");
840 		}
841 		bl += sprintf(b + bl, "\n");
842 	}
843 	return bl;
844 }
845 
846 static void pscsi_bi_endio(struct bio *bio, int error)
847 {
848 	bio_put(bio);
849 }
850 
851 static inline struct bio *pscsi_get_bio(int nr_vecs)
852 {
853 	struct bio *bio;
854 	/*
855 	 * Use bio_malloc() following the comment in for bio -> struct request
856 	 * in block/blk-core.c:blk_make_request()
857 	 */
858 	bio = bio_kmalloc(GFP_KERNEL, nr_vecs);
859 	if (!bio) {
860 		pr_err("PSCSI: bio_kmalloc() failed\n");
861 		return NULL;
862 	}
863 	bio->bi_end_io = pscsi_bi_endio;
864 
865 	return bio;
866 }
867 
868 static sense_reason_t
869 pscsi_map_sg(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
870 		enum dma_data_direction data_direction, struct bio **hbio)
871 {
872 	struct pscsi_dev_virt *pdv = PSCSI_DEV(cmd->se_dev);
873 	struct bio *bio = NULL, *tbio = NULL;
874 	struct page *page;
875 	struct scatterlist *sg;
876 	u32 data_len = cmd->data_length, i, len, bytes, off;
877 	int nr_pages = (cmd->data_length + sgl[0].offset +
878 			PAGE_SIZE - 1) >> PAGE_SHIFT;
879 	int nr_vecs = 0, rc;
880 	int rw = (data_direction == DMA_TO_DEVICE);
881 
882 	*hbio = NULL;
883 
884 	pr_debug("PSCSI: nr_pages: %d\n", nr_pages);
885 
886 	for_each_sg(sgl, sg, sgl_nents, i) {
887 		page = sg_page(sg);
888 		off = sg->offset;
889 		len = sg->length;
890 
891 		pr_debug("PSCSI: i: %d page: %p len: %d off: %d\n", i,
892 			page, len, off);
893 
894 		/*
895 		 * We only have one page of data in each sg element,
896 		 * we can not cross a page boundary.
897 		 */
898 		if (off + len > PAGE_SIZE)
899 			goto fail;
900 
901 		if (len > 0 && data_len > 0) {
902 			bytes = min_t(unsigned int, len, PAGE_SIZE - off);
903 			bytes = min(bytes, data_len);
904 
905 			if (!bio) {
906 				nr_vecs = min_t(int, BIO_MAX_PAGES, nr_pages);
907 				nr_pages -= nr_vecs;
908 				/*
909 				 * Calls bio_kmalloc() and sets bio->bi_end_io()
910 				 */
911 				bio = pscsi_get_bio(nr_vecs);
912 				if (!bio)
913 					goto fail;
914 
915 				if (rw)
916 					bio->bi_rw |= REQ_WRITE;
917 
918 				pr_debug("PSCSI: Allocated bio: %p,"
919 					" dir: %s nr_vecs: %d\n", bio,
920 					(rw) ? "rw" : "r", nr_vecs);
921 				/*
922 				 * Set *hbio pointer to handle the case:
923 				 * nr_pages > BIO_MAX_PAGES, where additional
924 				 * bios need to be added to complete a given
925 				 * command.
926 				 */
927 				if (!*hbio)
928 					*hbio = tbio = bio;
929 				else
930 					tbio = tbio->bi_next = bio;
931 			}
932 
933 			pr_debug("PSCSI: Calling bio_add_pc_page() i: %d"
934 				" bio: %p page: %p len: %d off: %d\n", i, bio,
935 				page, len, off);
936 
937 			rc = bio_add_pc_page(pdv->pdv_sd->request_queue,
938 					bio, page, bytes, off);
939 			if (rc != bytes)
940 				goto fail;
941 
942 			pr_debug("PSCSI: bio->bi_vcnt: %d nr_vecs: %d\n",
943 				bio->bi_vcnt, nr_vecs);
944 
945 			if (bio->bi_vcnt > nr_vecs) {
946 				pr_debug("PSCSI: Reached bio->bi_vcnt max:"
947 					" %d i: %d bio: %p, allocating another"
948 					" bio\n", bio->bi_vcnt, i, bio);
949 				/*
950 				 * Clear the pointer so that another bio will
951 				 * be allocated with pscsi_get_bio() above, the
952 				 * current bio has already been set *tbio and
953 				 * bio->bi_next.
954 				 */
955 				bio = NULL;
956 			}
957 
958 			data_len -= bytes;
959 		}
960 	}
961 
962 	return 0;
963 fail:
964 	while (*hbio) {
965 		bio = *hbio;
966 		*hbio = (*hbio)->bi_next;
967 		bio_endio(bio, 0);	/* XXX: should be error */
968 	}
969 	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
970 }
971 
972 /*
973  * Clear a lun set in the cdb if the initiator talking to use spoke
974  * and old standards version, as we can't assume the underlying device
975  * won't choke up on it.
976  */
977 static inline void pscsi_clear_cdb_lun(unsigned char *cdb)
978 {
979 	switch (cdb[0]) {
980 	case READ_10: /* SBC - RDProtect */
981 	case READ_12: /* SBC - RDProtect */
982 	case READ_16: /* SBC - RDProtect */
983 	case SEND_DIAGNOSTIC: /* SPC - SELF-TEST Code */
984 	case VERIFY: /* SBC - VRProtect */
985 	case VERIFY_16: /* SBC - VRProtect */
986 	case WRITE_VERIFY: /* SBC - VRProtect */
987 	case WRITE_VERIFY_12: /* SBC - VRProtect */
988 	case MAINTENANCE_IN: /* SPC - Parameter Data Format for SA RTPG */
989 		break;
990 	default:
991 		cdb[1] &= 0x1f; /* clear logical unit number */
992 		break;
993 	}
994 }
995 
996 static sense_reason_t
997 pscsi_parse_cdb(struct se_cmd *cmd)
998 {
999 	unsigned char *cdb = cmd->t_task_cdb;
1000 
1001 	if (cmd->se_cmd_flags & SCF_BIDI)
1002 		return TCM_UNSUPPORTED_SCSI_OPCODE;
1003 
1004 	pscsi_clear_cdb_lun(cdb);
1005 
1006 	/*
1007 	 * For REPORT LUNS we always need to emulate the response, for everything
1008 	 * else the default for pSCSI is to pass the command to the underlying
1009 	 * LLD / physical hardware.
1010 	 */
1011 	switch (cdb[0]) {
1012 	case REPORT_LUNS:
1013 		cmd->execute_cmd = spc_emulate_report_luns;
1014 		return 0;
1015 	case READ_6:
1016 	case READ_10:
1017 	case READ_12:
1018 	case READ_16:
1019 	case WRITE_6:
1020 	case WRITE_10:
1021 	case WRITE_12:
1022 	case WRITE_16:
1023 	case WRITE_VERIFY:
1024 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
1025 		/* FALLTHROUGH*/
1026 	default:
1027 		cmd->execute_cmd = pscsi_execute_cmd;
1028 		return 0;
1029 	}
1030 }
1031 
1032 static sense_reason_t
1033 pscsi_execute_cmd(struct se_cmd *cmd)
1034 {
1035 	struct scatterlist *sgl = cmd->t_data_sg;
1036 	u32 sgl_nents = cmd->t_data_nents;
1037 	enum dma_data_direction data_direction = cmd->data_direction;
1038 	struct pscsi_dev_virt *pdv = PSCSI_DEV(cmd->se_dev);
1039 	struct pscsi_plugin_task *pt;
1040 	struct request *req;
1041 	struct bio *hbio;
1042 	sense_reason_t ret;
1043 
1044 	/*
1045 	 * Dynamically alloc cdb space, since it may be larger than
1046 	 * TCM_MAX_COMMAND_SIZE
1047 	 */
1048 	pt = kzalloc(sizeof(*pt) + scsi_command_size(cmd->t_task_cdb), GFP_KERNEL);
1049 	if (!pt) {
1050 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1051 	}
1052 	cmd->priv = pt;
1053 
1054 	memcpy(pt->pscsi_cdb, cmd->t_task_cdb,
1055 		scsi_command_size(cmd->t_task_cdb));
1056 
1057 	if (!sgl) {
1058 		req = blk_get_request(pdv->pdv_sd->request_queue,
1059 				(data_direction == DMA_TO_DEVICE),
1060 				GFP_KERNEL);
1061 		if (IS_ERR(req)) {
1062 			pr_err("PSCSI: blk_get_request() failed\n");
1063 			ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1064 			goto fail;
1065 		}
1066 
1067 		blk_rq_set_block_pc(req);
1068 	} else {
1069 		BUG_ON(!cmd->data_length);
1070 
1071 		ret = pscsi_map_sg(cmd, sgl, sgl_nents, data_direction, &hbio);
1072 		if (ret)
1073 			goto fail;
1074 
1075 		req = blk_make_request(pdv->pdv_sd->request_queue, hbio,
1076 				       GFP_KERNEL);
1077 		if (IS_ERR(req)) {
1078 			pr_err("pSCSI: blk_make_request() failed\n");
1079 			ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1080 			goto fail_free_bio;
1081 		}
1082 	}
1083 
1084 	req->end_io = pscsi_req_done;
1085 	req->end_io_data = cmd;
1086 	req->cmd_len = scsi_command_size(pt->pscsi_cdb);
1087 	req->cmd = &pt->pscsi_cdb[0];
1088 	req->sense = &pt->pscsi_sense[0];
1089 	req->sense_len = 0;
1090 	if (pdv->pdv_sd->type == TYPE_DISK)
1091 		req->timeout = PS_TIMEOUT_DISK;
1092 	else
1093 		req->timeout = PS_TIMEOUT_OTHER;
1094 	req->retries = PS_RETRY;
1095 
1096 	blk_execute_rq_nowait(pdv->pdv_sd->request_queue, NULL, req,
1097 			(cmd->sam_task_attr == MSG_HEAD_TAG),
1098 			pscsi_req_done);
1099 
1100 	return 0;
1101 
1102 fail_free_bio:
1103 	while (hbio) {
1104 		struct bio *bio = hbio;
1105 		hbio = hbio->bi_next;
1106 		bio_endio(bio, 0);	/* XXX: should be error */
1107 	}
1108 	ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1109 fail:
1110 	kfree(pt);
1111 	return ret;
1112 }
1113 
1114 /*	pscsi_get_device_type():
1115  *
1116  *
1117  */
1118 static u32 pscsi_get_device_type(struct se_device *dev)
1119 {
1120 	struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
1121 	struct scsi_device *sd = pdv->pdv_sd;
1122 
1123 	return sd->type;
1124 }
1125 
1126 static sector_t pscsi_get_blocks(struct se_device *dev)
1127 {
1128 	struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
1129 
1130 	if (pdv->pdv_bd && pdv->pdv_bd->bd_part)
1131 		return pdv->pdv_bd->bd_part->nr_sects;
1132 
1133 	dump_stack();
1134 	return 0;
1135 }
1136 
1137 static void pscsi_req_done(struct request *req, int uptodate)
1138 {
1139 	struct se_cmd *cmd = req->end_io_data;
1140 	struct pscsi_plugin_task *pt = cmd->priv;
1141 
1142 	pt->pscsi_result = req->errors;
1143 	pt->pscsi_resid = req->resid_len;
1144 
1145 	cmd->scsi_status = status_byte(pt->pscsi_result) << 1;
1146 	if (cmd->scsi_status) {
1147 		pr_debug("PSCSI Status Byte exception at cmd: %p CDB:"
1148 			" 0x%02x Result: 0x%08x\n", cmd, pt->pscsi_cdb[0],
1149 			pt->pscsi_result);
1150 	}
1151 
1152 	switch (host_byte(pt->pscsi_result)) {
1153 	case DID_OK:
1154 		target_complete_cmd(cmd, cmd->scsi_status);
1155 		break;
1156 	default:
1157 		pr_debug("PSCSI Host Byte exception at cmd: %p CDB:"
1158 			" 0x%02x Result: 0x%08x\n", cmd, pt->pscsi_cdb[0],
1159 			pt->pscsi_result);
1160 		target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
1161 		break;
1162 	}
1163 
1164 	__blk_put_request(req->q, req);
1165 	kfree(pt);
1166 }
1167 
1168 static struct se_subsystem_api pscsi_template = {
1169 	.name			= "pscsi",
1170 	.owner			= THIS_MODULE,
1171 	.transport_type		= TRANSPORT_PLUGIN_PHBA_PDEV,
1172 	.attach_hba		= pscsi_attach_hba,
1173 	.detach_hba		= pscsi_detach_hba,
1174 	.pmode_enable_hba	= pscsi_pmode_enable_hba,
1175 	.alloc_device		= pscsi_alloc_device,
1176 	.configure_device	= pscsi_configure_device,
1177 	.free_device		= pscsi_free_device,
1178 	.transport_complete	= pscsi_transport_complete,
1179 	.parse_cdb		= pscsi_parse_cdb,
1180 	.set_configfs_dev_params = pscsi_set_configfs_dev_params,
1181 	.show_configfs_dev_params = pscsi_show_configfs_dev_params,
1182 	.get_device_type	= pscsi_get_device_type,
1183 	.get_blocks		= pscsi_get_blocks,
1184 };
1185 
1186 static int __init pscsi_module_init(void)
1187 {
1188 	return transport_subsystem_register(&pscsi_template);
1189 }
1190 
1191 static void __exit pscsi_module_exit(void)
1192 {
1193 	transport_subsystem_release(&pscsi_template);
1194 }
1195 
1196 MODULE_DESCRIPTION("TCM PSCSI subsystem plugin");
1197 MODULE_AUTHOR("nab@Linux-iSCSI.org");
1198 MODULE_LICENSE("GPL");
1199 
1200 module_init(pscsi_module_init);
1201 module_exit(pscsi_module_exit);
1202