scsi_pt.c revision 164906 
1/*-
2 * Implementation of SCSI Processor Target Peripheral driver for CAM.
3 *
4 * Copyright (c) 1998 Justin T. Gibbs.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions, and the following disclaimer,
12 *    without modification, immediately at the beginning of the file.
13 * 2. The name of the author may not be used to endorse or promote products
14 *    derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/sys/cam/scsi/scsi_pt.c 164906 2006-12-05 07:45:28Z mjacob $");
31
32#include <sys/param.h>
33#include <sys/queue.h>
34#include <sys/systm.h>
35#include <sys/kernel.h>
36#include <sys/types.h>
37#include <sys/bio.h>
38#include <sys/devicestat.h>
39#include <sys/malloc.h>
40#include <sys/conf.h>
41#include <sys/ptio.h>
42
43#include <cam/cam.h>
44#include <cam/cam_ccb.h>
45#include <cam/cam_periph.h>
46#include <cam/cam_xpt_periph.h>
47#include <cam/cam_debug.h>
48
49#include <cam/scsi/scsi_all.h>
50#include <cam/scsi/scsi_message.h>
51#include <cam/scsi/scsi_pt.h>
52
53#include "opt_pt.h"
54
55typedef enum {
56	PT_STATE_PROBE,
57	PT_STATE_NORMAL
58} pt_state;
59
60typedef enum {
61	PT_FLAG_NONE		= 0x00,
62	PT_FLAG_OPEN		= 0x01,
63	PT_FLAG_DEVICE_INVALID	= 0x02,
64	PT_FLAG_RETRY_UA	= 0x04
65} pt_flags;
66
67typedef enum {
68	PT_CCB_BUFFER_IO	= 0x01,
69	PT_CCB_WAITING		= 0x02,
70	PT_CCB_RETRY_UA		= 0x04,
71	PT_CCB_BUFFER_IO_UA	= PT_CCB_BUFFER_IO|PT_CCB_RETRY_UA
72} pt_ccb_state;
73
74/* Offsets into our private area for storing information */
75#define ccb_state	ppriv_field0
76#define ccb_bp		ppriv_ptr1
77
78struct pt_softc {
79	struct	 bio_queue_head bio_queue;
80	struct	 devstat *device_stats;
81	LIST_HEAD(, ccb_hdr) pending_ccbs;
82	pt_state state;
83	pt_flags flags;
84	union	 ccb saved_ccb;
85	int	 io_timeout;
86	struct cdev *dev;
87};
88
89static	d_open_t	ptopen;
90static	d_close_t	ptclose;
91static	d_strategy_t	ptstrategy;
92static	periph_init_t	ptinit;
93static	void		ptasync(void *callback_arg, u_int32_t code,
94				struct cam_path *path, void *arg);
95static	periph_ctor_t	ptctor;
96static	periph_oninv_t	ptoninvalidate;
97static	periph_dtor_t	ptdtor;
98static	periph_start_t	ptstart;
99static	void		ptdone(struct cam_periph *periph,
100			       union ccb *done_ccb);
101static	d_ioctl_t	ptioctl;
102static  int		pterror(union ccb *ccb, u_int32_t cam_flags,
103				u_int32_t sense_flags);
104
105void	scsi_send_receive(struct ccb_scsiio *csio, u_int32_t retries,
106			  void (*cbfcnp)(struct cam_periph *, union ccb *),
107			  u_int tag_action, int readop, u_int byte2,
108			  u_int32_t xfer_len, u_int8_t *data_ptr,
109			  u_int8_t sense_len, u_int32_t timeout);
110
111static struct periph_driver ptdriver =
112{
113	ptinit, "pt",
114	TAILQ_HEAD_INITIALIZER(ptdriver.units), /* generation */ 0
115};
116
117PERIPHDRIVER_DECLARE(pt, ptdriver);
118
119
120static struct cdevsw pt_cdevsw = {
121	.d_version =	D_VERSION,
122	.d_flags =	D_NEEDGIANT,
123	.d_open =	ptopen,
124	.d_close =	ptclose,
125	.d_read =	physread,
126	.d_write =	physwrite,
127	.d_ioctl =	ptioctl,
128	.d_strategy =	ptstrategy,
129	.d_name =	"pt",
130};
131
132#ifndef SCSI_PT_DEFAULT_TIMEOUT
133#define SCSI_PT_DEFAULT_TIMEOUT		60
134#endif
135
136static int
137ptopen(struct cdev *dev, int flags, int fmt, struct thread *td)
138{
139	struct cam_periph *periph;
140	struct pt_softc *softc;
141	int unit;
142	int error;
143	int s;
144
145	unit = minor(dev);
146	periph = (struct cam_periph *)dev->si_drv1;
147	if (periph == NULL)
148		return (ENXIO);
149
150	softc = (struct pt_softc *)periph->softc;
151
152	s = splsoftcam();
153	if (softc->flags & PT_FLAG_DEVICE_INVALID) {
154		splx(s);
155		return(ENXIO);
156	}
157
158	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
159	    ("ptopen: dev=%s (unit %d)\n", devtoname(dev), unit));
160
161	if ((error = cam_periph_lock(periph, PRIBIO|PCATCH)) != 0) {
162		splx(s);
163		return (error); /* error code from tsleep */
164	}
165
166	splx(s);
167
168	if ((softc->flags & PT_FLAG_OPEN) == 0) {
169		if (cam_periph_acquire(periph) != CAM_REQ_CMP)
170			error = ENXIO;
171		else
172			softc->flags |= PT_FLAG_OPEN;
173	} else
174		error = EBUSY;
175
176	cam_periph_unlock(periph);
177	return (error);
178}
179
180static int
181ptclose(struct cdev *dev, int flag, int fmt, struct thread *td)
182{
183	struct	cam_periph *periph;
184	struct	pt_softc *softc;
185	int	error;
186
187	periph = (struct cam_periph *)dev->si_drv1;
188	if (periph == NULL)
189		return (ENXIO);
190
191	softc = (struct pt_softc *)periph->softc;
192
193	if ((error = cam_periph_lock(periph, PRIBIO)) != 0)
194		return (error); /* error code from tsleep */
195
196	softc->flags &= ~PT_FLAG_OPEN;
197	cam_periph_unlock(periph);
198	cam_periph_release(periph);
199	return (0);
200}
201
202/*
203 * Actually translate the requested transfer into one the physical driver
204 * can understand.  The transfer is described by a buf and will include
205 * only one physical transfer.
206 */
207static void
208ptstrategy(struct bio *bp)
209{
210	struct cam_periph *periph;
211	struct pt_softc *softc;
212	int    s;
213
214	periph = (struct cam_periph *)bp->bio_dev->si_drv1;
215	bp->bio_resid = bp->bio_bcount;
216	if (periph == NULL) {
217		biofinish(bp, NULL, ENXIO);
218		return;
219	}
220	softc = (struct pt_softc *)periph->softc;
221
222	/*
223	 * Mask interrupts so that the pack cannot be invalidated until
224	 * after we are in the queue.  Otherwise, we might not properly
225	 * clean up one of the buffers.
226	 */
227	s = splbio();
228
229	/*
230	 * If the device has been made invalid, error out
231	 */
232	if ((softc->flags & PT_FLAG_DEVICE_INVALID)) {
233		splx(s);
234		biofinish(bp, NULL, ENXIO);
235		return;
236	}
237
238	/*
239	 * Place it in the queue of disk activities for this disk
240	 */
241	bioq_insert_tail(&softc->bio_queue, bp);
242
243	splx(s);
244
245	/*
246	 * Schedule ourselves for performing the work.
247	 */
248	xpt_schedule(periph, /* XXX priority */1);
249
250	return;
251}
252
253static void
254ptinit(void)
255{
256	cam_status status;
257	struct cam_path *path;
258
259	/*
260	 * Install a global async callback.  This callback will
261	 * receive async callbacks like "new device found".
262	 */
263	status = xpt_create_path(&path, /*periph*/NULL, CAM_XPT_PATH_ID,
264				 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD);
265
266	if (status == CAM_REQ_CMP) {
267		struct ccb_setasync csa;
268
269                xpt_setup_ccb(&csa.ccb_h, path, /*priority*/5);
270                csa.ccb_h.func_code = XPT_SASYNC_CB;
271                csa.event_enable = AC_FOUND_DEVICE;
272                csa.callback = ptasync;
273                csa.callback_arg = NULL;
274                xpt_action((union ccb *)&csa);
275		status = csa.ccb_h.status;
276                xpt_free_path(path);
277        }
278
279	if (status != CAM_REQ_CMP) {
280		printf("pt: Failed to attach master async callback "
281		       "due to status 0x%x!\n", status);
282	}
283}
284
285static cam_status
286ptctor(struct cam_periph *periph, void *arg)
287{
288	struct pt_softc *softc;
289	struct ccb_setasync csa;
290	struct ccb_getdev *cgd;
291
292	cgd = (struct ccb_getdev *)arg;
293	if (periph == NULL) {
294		printf("ptregister: periph was NULL!!\n");
295		return(CAM_REQ_CMP_ERR);
296	}
297
298	if (cgd == NULL) {
299		printf("ptregister: no getdev CCB, can't register device\n");
300		return(CAM_REQ_CMP_ERR);
301	}
302
303	softc = (struct pt_softc *)malloc(sizeof(*softc),M_DEVBUF,M_NOWAIT);
304
305	if (softc == NULL) {
306		printf("daregister: Unable to probe new device. "
307		       "Unable to allocate softc\n");
308		return(CAM_REQ_CMP_ERR);
309	}
310
311	bzero(softc, sizeof(*softc));
312	LIST_INIT(&softc->pending_ccbs);
313	softc->state = PT_STATE_NORMAL;
314	bioq_init(&softc->bio_queue);
315
316	softc->io_timeout = SCSI_PT_DEFAULT_TIMEOUT * 1000;
317
318	periph->softc = softc;
319
320	softc->device_stats = devstat_new_entry("pt",
321			  periph->unit_number, 0,
322			  DEVSTAT_NO_BLOCKSIZE,
323			  SID_TYPE(&cgd->inq_data) | DEVSTAT_TYPE_IF_SCSI,
324			  DEVSTAT_PRIORITY_OTHER);
325
326	softc->dev = make_dev(&pt_cdevsw, periph->unit_number, UID_ROOT,
327			      GID_OPERATOR, 0600, "%s%d", periph->periph_name,
328			      periph->unit_number);
329	softc->dev->si_drv1 = periph;
330
331	/*
332	 * Add async callbacks for bus reset and
333	 * bus device reset calls.  I don't bother
334	 * checking if this fails as, in most cases,
335	 * the system will function just fine without
336	 * them and the only alternative would be to
337	 * not attach the device on failure.
338	 */
339	xpt_setup_ccb(&csa.ccb_h, periph->path, /*priority*/5);
340	csa.ccb_h.func_code = XPT_SASYNC_CB;
341	csa.event_enable = AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE;
342	csa.callback = ptasync;
343	csa.callback_arg = periph;
344	xpt_action((union ccb *)&csa);
345
346	/* Tell the user we've attached to the device */
347	xpt_announce_periph(periph, NULL);
348
349	return(CAM_REQ_CMP);
350}
351
352static void
353ptoninvalidate(struct cam_periph *periph)
354{
355	int s;
356	struct pt_softc *softc;
357	struct ccb_setasync csa;
358
359	softc = (struct pt_softc *)periph->softc;
360
361	/*
362	 * De-register any async callbacks.
363	 */
364	xpt_setup_ccb(&csa.ccb_h, periph->path,
365		      /* priority */ 5);
366	csa.ccb_h.func_code = XPT_SASYNC_CB;
367	csa.event_enable = 0;
368	csa.callback = ptasync;
369	csa.callback_arg = periph;
370	xpt_action((union ccb *)&csa);
371
372	softc->flags |= PT_FLAG_DEVICE_INVALID;
373
374	/*
375	 * Although the oninvalidate() routines are always called at
376	 * splsoftcam, we need to be at splbio() here to keep the buffer
377	 * queue from being modified while we traverse it.
378	 */
379	s = splbio();
380
381	/*
382	 * Return all queued I/O with ENXIO.
383	 * XXX Handle any transactions queued to the card
384	 *     with XPT_ABORT_CCB.
385	 */
386	bioq_flush(&softc->bio_queue, NULL, ENXIO);
387
388	splx(s);
389
390	xpt_print(periph->path, "lost device\n");
391}
392
393static void
394ptdtor(struct cam_periph *periph)
395{
396	struct pt_softc *softc;
397
398	softc = (struct pt_softc *)periph->softc;
399
400	devstat_remove_entry(softc->device_stats);
401
402	destroy_dev(softc->dev);
403
404	xpt_print(periph->path, "removing device entry\n");
405	free(softc, M_DEVBUF);
406}
407
408static void
409ptasync(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg)
410{
411	struct cam_periph *periph;
412
413	periph = (struct cam_periph *)callback_arg;
414	switch (code) {
415	case AC_FOUND_DEVICE:
416	{
417		struct ccb_getdev *cgd;
418		cam_status status;
419
420		cgd = (struct ccb_getdev *)arg;
421		if (cgd == NULL)
422			break;
423
424		if (SID_TYPE(&cgd->inq_data) != T_PROCESSOR)
425			break;
426
427		/*
428		 * Allocate a peripheral instance for
429		 * this device and start the probe
430		 * process.
431		 */
432		status = cam_periph_alloc(ptctor, ptoninvalidate, ptdtor,
433					  ptstart, "pt", CAM_PERIPH_BIO,
434					  cgd->ccb_h.path, ptasync,
435					  AC_FOUND_DEVICE, cgd);
436
437		if (status != CAM_REQ_CMP
438		 && status != CAM_REQ_INPROG)
439			printf("ptasync: Unable to attach to new device "
440				"due to status 0x%x\n", status);
441		break;
442	}
443	case AC_SENT_BDR:
444	case AC_BUS_RESET:
445	{
446		struct pt_softc *softc;
447		struct ccb_hdr *ccbh;
448		int s;
449
450		softc = (struct pt_softc *)periph->softc;
451		s = splsoftcam();
452		/*
453		 * Don't fail on the expected unit attention
454		 * that will occur.
455		 */
456		softc->flags |= PT_FLAG_RETRY_UA;
457		LIST_FOREACH(ccbh, &softc->pending_ccbs, periph_links.le)
458			ccbh->ccb_state |= PT_CCB_RETRY_UA;
459		splx(s);
460	}
461	/* FALLTHROUGH */
462	default:
463		cam_periph_async(periph, code, path, arg);
464		break;
465	}
466}
467
468static void
469ptstart(struct cam_periph *periph, union ccb *start_ccb)
470{
471	struct pt_softc *softc;
472	struct bio *bp;
473	int s;
474
475	softc = (struct pt_softc *)periph->softc;
476
477	/*
478	 * See if there is a buf with work for us to do..
479	 */
480	s = splbio();
481	bp = bioq_first(&softc->bio_queue);
482	if (periph->immediate_priority <= periph->pinfo.priority) {
483		CAM_DEBUG_PRINT(CAM_DEBUG_SUBTRACE,
484				("queuing for immediate ccb\n"));
485		start_ccb->ccb_h.ccb_state = PT_CCB_WAITING;
486		SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h,
487				  periph_links.sle);
488		periph->immediate_priority = CAM_PRIORITY_NONE;
489		splx(s);
490		wakeup(&periph->ccb_list);
491	} else if (bp == NULL) {
492		splx(s);
493		xpt_release_ccb(start_ccb);
494	} else {
495		int oldspl;
496
497		bioq_remove(&softc->bio_queue, bp);
498
499		devstat_start_transaction_bio(softc->device_stats, bp);
500
501		scsi_send_receive(&start_ccb->csio,
502				  /*retries*/4,
503				  ptdone,
504				  MSG_SIMPLE_Q_TAG,
505				  bp->bio_cmd == BIO_READ,
506				  /*byte2*/0,
507				  bp->bio_bcount,
508				  bp->bio_data,
509				  /*sense_len*/SSD_FULL_SIZE,
510				  /*timeout*/softc->io_timeout);
511
512		start_ccb->ccb_h.ccb_state = PT_CCB_BUFFER_IO_UA;
513
514		/*
515		 * Block out any asyncronous callbacks
516		 * while we touch the pending ccb list.
517		 */
518		oldspl = splcam();
519		LIST_INSERT_HEAD(&softc->pending_ccbs, &start_ccb->ccb_h,
520				 periph_links.le);
521		splx(oldspl);
522
523		start_ccb->ccb_h.ccb_bp = bp;
524		bp = bioq_first(&softc->bio_queue);
525		splx(s);
526
527		xpt_action(start_ccb);
528
529		if (bp != NULL) {
530			/* Have more work to do, so ensure we stay scheduled */
531			xpt_schedule(periph, /* XXX priority */1);
532		}
533	}
534}
535
536static void
537ptdone(struct cam_periph *periph, union ccb *done_ccb)
538{
539	struct pt_softc *softc;
540	struct ccb_scsiio *csio;
541
542	softc = (struct pt_softc *)periph->softc;
543	csio = &done_ccb->csio;
544	switch (csio->ccb_h.ccb_state) {
545	case PT_CCB_BUFFER_IO:
546	case PT_CCB_BUFFER_IO_UA:
547	{
548		struct bio *bp;
549		int    oldspl;
550
551		bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
552		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
553			int error;
554			int s;
555			int sf;
556
557			if ((csio->ccb_h.ccb_state & PT_CCB_RETRY_UA) != 0)
558				sf = SF_RETRY_UA;
559			else
560				sf = 0;
561
562			error = pterror(done_ccb, CAM_RETRY_SELTO, sf);
563			if (error == ERESTART) {
564				/*
565				 * A retry was scheuled, so
566				 * just return.
567				 */
568				return;
569			}
570			if (error != 0) {
571				s = splbio();
572
573				if (error == ENXIO) {
574					/*
575					 * Catastrophic error.  Mark our device
576					 * as invalid.
577					 */
578					xpt_print(periph->path,
579					    "Invalidating device\n");
580					softc->flags |= PT_FLAG_DEVICE_INVALID;
581				}
582
583				/*
584				 * return all queued I/O with EIO, so that
585				 * the client can retry these I/Os in the
586				 * proper order should it attempt to recover.
587				 */
588				bioq_flush(&softc->bio_queue, NULL, EIO);
589				splx(s);
590				bp->bio_error = error;
591				bp->bio_resid = bp->bio_bcount;
592				bp->bio_flags |= BIO_ERROR;
593			} else {
594				bp->bio_resid = csio->resid;
595				bp->bio_error = 0;
596				if (bp->bio_resid != 0) {
597					/* Short transfer ??? */
598					bp->bio_flags |= BIO_ERROR;
599				}
600			}
601			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
602				cam_release_devq(done_ccb->ccb_h.path,
603						 /*relsim_flags*/0,
604						 /*reduction*/0,
605						 /*timeout*/0,
606						 /*getcount_only*/0);
607		} else {
608			bp->bio_resid = csio->resid;
609			if (bp->bio_resid != 0)
610				bp->bio_flags |= BIO_ERROR;
611		}
612
613		/*
614		 * Block out any asyncronous callbacks
615		 * while we touch the pending ccb list.
616		 */
617		oldspl = splcam();
618		LIST_REMOVE(&done_ccb->ccb_h, periph_links.le);
619		splx(oldspl);
620
621		biofinish(bp, softc->device_stats, 0);
622		break;
623	}
624	case PT_CCB_WAITING:
625		/* Caller will release the CCB */
626		wakeup(&done_ccb->ccb_h.cbfcnp);
627		return;
628	}
629	xpt_release_ccb(done_ccb);
630}
631
632static int
633pterror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
634{
635	struct pt_softc	  *softc;
636	struct cam_periph *periph;
637
638	periph = xpt_path_periph(ccb->ccb_h.path);
639	softc = (struct pt_softc *)periph->softc;
640
641	return(cam_periph_error(ccb, cam_flags, sense_flags,
642				&softc->saved_ccb));
643}
644
645static int
646ptioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
647{
648	struct cam_periph *periph;
649	struct pt_softc *softc;
650	int error;
651
652	periph = (struct cam_periph *)dev->si_drv1;
653	if (periph == NULL)
654		return(ENXIO);
655
656	softc = (struct pt_softc *)periph->softc;
657
658	if ((error = cam_periph_lock(periph, PRIBIO|PCATCH)) != 0) {
659		return (error); /* error code from tsleep */
660	}
661
662	switch(cmd) {
663	case PTIOCGETTIMEOUT:
664		if (softc->io_timeout >= 1000)
665			*(int *)addr = softc->io_timeout / 1000;
666		else
667			*(int *)addr = 0;
668		break;
669	case PTIOCSETTIMEOUT:
670	{
671		int s;
672
673		if (*(int *)addr < 1) {
674			error = EINVAL;
675			break;
676		}
677
678		s = splsoftcam();
679		softc->io_timeout = *(int *)addr * 1000;
680		splx(s);
681
682		break;
683	}
684	default:
685		error = cam_periph_ioctl(periph, cmd, addr, pterror);
686		break;
687	}
688
689	cam_periph_unlock(periph);
690
691	return(error);
692}
693
694void
695scsi_send_receive(struct ccb_scsiio *csio, u_int32_t retries,
696		  void (*cbfcnp)(struct cam_periph *, union ccb *),
697		  u_int tag_action, int readop, u_int byte2,
698		  u_int32_t xfer_len, u_int8_t *data_ptr, u_int8_t sense_len,
699		  u_int32_t timeout)
700{
701	struct scsi_send_receive *scsi_cmd;
702
703	scsi_cmd = (struct scsi_send_receive *)&csio->cdb_io.cdb_bytes;
704	scsi_cmd->opcode = readop ? RECEIVE : SEND;
705	scsi_cmd->byte2 = byte2;
706	scsi_ulto3b(xfer_len, scsi_cmd->xfer_len);
707	scsi_cmd->control = 0;
708
709	cam_fill_csio(csio,
710		      retries,
711		      cbfcnp,
712		      /*flags*/readop ? CAM_DIR_IN : CAM_DIR_OUT,
713		      tag_action,
714		      data_ptr,
715		      xfer_len,
716		      sense_len,
717		      sizeof(*scsi_cmd),
718		      timeout);
719}
720