xref: /titanic_52/usr/src/uts/common/io/scsi/targets/st.c (revision b89e420ae1290e425c29db875ec0c0546006eec7)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  *  Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
24  *  Copyright (c) 2011 Bayard G. Bell. All rights reserved.
25  */
26 
27 /*
28  * SCSI	 SCSA-compliant and not-so-DDI-compliant Tape Driver
29  */
30 
31 #if defined(lint) && !defined(DEBUG)
32 #define	DEBUG	1
33 #endif
34 
35 #include <sys/modctl.h>
36 #include <sys/scsi/scsi.h>
37 #include <sys/mtio.h>
38 #include <sys/scsi/targets/stdef.h>
39 #include <sys/file.h>
40 #include <sys/kstat.h>
41 #include <sys/ddidmareq.h>
42 #include <sys/ddi.h>
43 #include <sys/sunddi.h>
44 #include <sys/byteorder.h>
45 
46 #define	IOSP	KSTAT_IO_PTR(un->un_stats)
47 /*
48  * stats maintained only for reads/writes as commands
49  * like rewind etc skew the wait/busy times
50  */
51 #define	IS_RW(bp) 	((bp)->b_bcount > 0)
52 #define	ST_DO_KSTATS(bp, kstat_function) \
53 	if ((bp != un->un_sbufp) && un->un_stats && IS_RW(bp)) { \
54 		kstat_function(IOSP); \
55 	}
56 
57 #define	ST_DO_ERRSTATS(un, x)  \
58 	if (un->un_errstats) { \
59 		struct st_errstats *stp; \
60 		stp = (struct st_errstats *)un->un_errstats->ks_data; \
61 		stp->x.value.ul++; \
62 	}
63 
64 #define	FILL_SCSI1_LUN(devp, pkt) 					\
65 	if ((devp)->sd_inq->inq_ansi == 0x1) {				\
66 		int _lun;						\
67 		_lun = ddi_prop_get_int(DDI_DEV_T_ANY, (devp)->sd_dev,	\
68 		    DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0);		\
69 		if (_lun > 0) {						\
70 			((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun =	\
71 			    _lun;					\
72 		}							\
73 	}
74 
75 /*
76  * get an available contig mem header, cp.
77  * when big_enough is true, we will return NULL, if no big enough
78  * contig mem is found.
79  * when big_enough is false, we will try to find cp containing big
80  * enough contig mem. if not found, we will ruturn the last cp available.
81  *
82  * used by st_get_contig_mem()
83  */
84 #define	ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough) {		\
85 	struct contig_mem *tmp_cp = NULL;				\
86 	for ((cp) = (un)->un_contig_mem;				\
87 	    (cp) != NULL;						\
88 	    tmp_cp = (cp), (cp) = (cp)->cm_next) { 			\
89 		if (((cp)->cm_len >= (len)) || 				\
90 		    (!(big_enough) && ((cp)->cm_next == NULL))) { 	\
91 			if (tmp_cp == NULL) { 				\
92 				(un)->un_contig_mem = (cp)->cm_next; 	\
93 			} else { 					\
94 				tmp_cp->cm_next = (cp)->cm_next; 	\
95 			} 						\
96 			(cp)->cm_next = NULL; 				\
97 			(un)->un_contig_mem_available_num--; 		\
98 			break; 						\
99 		} 							\
100 	} 								\
101 }
102 
103 #define	ST_NUM_MEMBERS(array)	(sizeof (array) / sizeof (array[0]))
104 #define	COPY_POS(dest, source) bcopy(source, dest, sizeof (tapepos_t))
105 #define	ISALNUM(byte) \
106 	(((byte) >= 'a' && (byte) <= 'z') || \
107 	((byte) >= 'A' && (byte) <= 'Z') || \
108 	((byte) >= '0' && (byte) <= '9'))
109 
110 #define	ONE_K	1024
111 
112 #define	MAX_SPACE_CNT(cnt) if (cnt >= 0) { \
113 		if (cnt > MIN(SP_CNT_MASK, INT32_MAX)) \
114 			return (EINVAL); \
115 	} else { \
116 		if (-(cnt) > MIN(SP_CNT_MASK, INT32_MAX)) \
117 			return (EINVAL); \
118 	} \
119 
120 /*
121  * Global External Data Definitions
122  */
123 extern struct scsi_key_strings scsi_cmds[];
124 extern uchar_t	scsi_cdb_size[];
125 
126 /*
127  * Local Static Data
128  */
129 static void *st_state;
130 static char *const st_label = "st";
131 static volatile int st_recov_sz = sizeof (recov_info);
132 static const char mp_misconf[] = {
133 	"St Tape is misconfigured, MPxIO enabled and "
134 	"tape-command-recovery-disable set in st.conf\n"
135 };
136 
137 #ifdef	__x86
138 /*
139  * We need to use below DMA attr to alloc physically contiguous
140  * memory to do I/O in big block size
141  */
142 static ddi_dma_attr_t st_contig_mem_dma_attr = {
143 	DMA_ATTR_V0,    /* version number */
144 	0x0,		/* lowest usable address */
145 	0xFFFFFFFFull,  /* high DMA address range */
146 	0xFFFFFFFFull,  /* DMA counter register */
147 	1,		/* DMA address alignment */
148 	1,		/* DMA burstsizes */
149 	1,		/* min effective DMA size */
150 	0xFFFFFFFFull,  /* max DMA xfer size */
151 	0xFFFFFFFFull,  /* segment boundary */
152 	1,		/* s/g list length */
153 	1,		/* granularity of device */
154 	0		/* DMA transfer flags */
155 };
156 
157 static ddi_device_acc_attr_t st_acc_attr = {
158 	DDI_DEVICE_ATTR_V0,
159 	DDI_NEVERSWAP_ACC,
160 	DDI_STRICTORDER_ACC
161 };
162 
163 /* set limitation for the number of contig_mem */
164 static int st_max_contig_mem_num = ST_MAX_CONTIG_MEM_NUM;
165 #endif
166 
167 /*
168  * Tunable parameters
169  *
170  * DISCLAIMER
171  * ----------
172  * These parameters are intended for use only in system testing; if you use
173  * them in production systems, you do so at your own risk. Altering any
174  * variable not listed below may cause unpredictable system behavior.
175  *
176  * st_check_media_time
177  *
178  *   Three second state check
179  *
180  * st_allow_large_xfer
181  *
182  *   Gated with ST_NO_RECSIZE_LIMIT
183  *
184  *   0 - Transfers larger than 64KB will not be allowed
185  *       regardless of the setting of ST_NO_RECSIZE_LIMIT
186  *   1 - Transfers larger than 64KB will be allowed
187  *       if ST_NO_RECSIZE_LIMIT is TRUE for the drive
188  *
189  * st_report_soft_errors_on_close
190  *
191  *  Gated with ST_SOFT_ERROR_REPORTING
192  *
193  *  0 - Errors will not be reported on close regardless
194  *      of the setting of ST_SOFT_ERROR_REPORTING
195  *
196  *  1 - Errors will be reported on close if
197  *      ST_SOFT_ERROR_REPORTING is TRUE for the drive
198  */
199 static int st_selection_retry_count = ST_SEL_RETRY_COUNT;
200 static int st_retry_count	= ST_RETRY_COUNT;
201 
202 static int st_io_time		= ST_IO_TIME;
203 static int st_long_timeout_x	= ST_LONG_TIMEOUT_X;
204 
205 static int st_space_time	= ST_SPACE_TIME;
206 static int st_long_space_time_x	= ST_LONG_SPACE_TIME_X;
207 
208 static int st_error_level	= SCSI_ERR_RETRYABLE;
209 static int st_check_media_time	= 3000000;	/* 3 Second State Check */
210 
211 static int st_max_throttle	= ST_MAX_THROTTLE;
212 
213 static clock_t st_wait_cmds_complete = ST_WAIT_CMDS_COMPLETE;
214 
215 static int st_allow_large_xfer = 1;
216 static int st_report_soft_errors_on_close = 1;
217 
218 /*
219  * End of tunable parameters list
220  */
221 
222 
223 
224 /*
225  * Asynchronous I/O and persistent errors, refer to PSARC/1995/228
226  *
227  * Asynchronous I/O's main offering is that it is a non-blocking way to do
228  * reads and writes.  The driver will queue up all the requests it gets and
229  * have them ready to transport to the HBA.  Unfortunately, we cannot always
230  * just ship the I/O requests to the HBA, as there errors and exceptions
231  * that may happen when we don't want the HBA to continue.  Therein comes
232  * the flush-on-errors capability.  If the HBA supports it, then st will
233  * send in st_max_throttle I/O requests at the same time.
234  *
235  * Persistent errors : This was also reasonably simple.  In the interrupt
236  * routines, if there was an error or exception (FM, LEOT, media error,
237  * transport error), the persistent error bits are set and shuts everything
238  * down, but setting the throttle to zero.  If we hit and exception in the
239  * HBA, and flush-on-errors were set, we wait for all outstanding I/O's to
240  * come back (with CMD_ABORTED), then flush all bp's in the wait queue with
241  * the appropriate error, and this will preserve order. Of course, depending
242  * on the exception we have to show a zero read or write before we show
243  * errors back to the application.
244  */
245 
246 extern const int st_ndrivetypes;	/* defined in st_conf.c */
247 extern const struct st_drivetype st_drivetypes[];
248 extern const char st_conf_version[];
249 
250 #ifdef STDEBUG
251 static int st_soft_error_report_debug = 0;
252 volatile int st_debug = 0;
253 static volatile dev_info_t *st_lastdev;
254 static kmutex_t st_debug_mutex;
255 #endif
256 
257 #define	ST_MT02_NAME	"Emulex  MT02 QIC-11/24  "
258 
259 static const struct vid_drivetype {
260 	char	*vid;
261 	char	type;
262 } st_vid_dt[] = {
263 	{"LTO-CVE ",	MT_LTO},
264 	{"QUANTUM ",    MT_ISDLT},
265 	{"SONY    ",    MT_ISAIT},
266 	{"STK     ",	MT_ISSTK9840}
267 };
268 
269 static const struct driver_minor_data {
270 	char	*name;
271 	int	minor;
272 } st_minor_data[] = {
273 	/*
274 	 * The top 4 entries are for the default densities,
275 	 * don't alter their position.
276 	 */
277 	{"",	0},
278 	{"n",	MT_NOREWIND},
279 	{"b",	MT_BSD},
280 	{"bn",	MT_NOREWIND | MT_BSD},
281 	{"l",	MT_DENSITY1},
282 	{"m",	MT_DENSITY2},
283 	{"h",	MT_DENSITY3},
284 	{"c",	MT_DENSITY4},
285 	{"u",	MT_DENSITY4},
286 	{"ln",	MT_DENSITY1 | MT_NOREWIND},
287 	{"mn",	MT_DENSITY2 | MT_NOREWIND},
288 	{"hn",	MT_DENSITY3 | MT_NOREWIND},
289 	{"cn",	MT_DENSITY4 | MT_NOREWIND},
290 	{"un",	MT_DENSITY4 | MT_NOREWIND},
291 	{"lb",	MT_DENSITY1 | MT_BSD},
292 	{"mb",	MT_DENSITY2 | MT_BSD},
293 	{"hb",	MT_DENSITY3 | MT_BSD},
294 	{"cb",	MT_DENSITY4 | MT_BSD},
295 	{"ub",	MT_DENSITY4 | MT_BSD},
296 	{"lbn",	MT_DENSITY1 | MT_NOREWIND | MT_BSD},
297 	{"mbn",	MT_DENSITY2 | MT_NOREWIND | MT_BSD},
298 	{"hbn",	MT_DENSITY3 | MT_NOREWIND | MT_BSD},
299 	{"cbn",	MT_DENSITY4 | MT_NOREWIND | MT_BSD},
300 	{"ubn",	MT_DENSITY4 | MT_NOREWIND | MT_BSD}
301 };
302 
303 /* strings used in many debug and warning messages */
304 static const char wr_str[]  = "write";
305 static const char rd_str[]  = "read";
306 static const char wrg_str[] = "writing";
307 static const char rdg_str[] = "reading";
308 static const char *space_strs[] = {
309 	"records",
310 	"filemarks",
311 	"sequential filemarks",
312 	"eod",
313 	"setmarks",
314 	"sequential setmarks",
315 	"Reserved",
316 	"Reserved"
317 };
318 static const char *load_strs[] = {
319 	"unload",		/* LD_UNLOAD		0 */
320 	"load",			/* LD_LOAD		1 */
321 	"retension",		/* LD_RETEN		2 */
322 	"load reten",		/* LD_LOAD | LD_RETEN	3 */
323 	"eod",			/* LD_EOT		4 */
324 	"load EOD",		/* LD_LOAD | LD_EOT	5 */
325 	"reten EOD",		/* LD_RETEN | LD_EOT	6 */
326 	"load reten EOD"	/* LD_LOAD|LD_RETEN|LD_EOT 7 */
327 	"hold",			/* LD_HOLD		8 */
328 	"load and hold"		/* LD_LOAD | LD_HOLD	9 */
329 };
330 
331 static const char *errstatenames[] = {
332 	"COMMAND_DONE",
333 	"COMMAND_DONE_ERROR",
334 	"COMMAND_DONE_ERROR_RECOVERED",
335 	"QUE_COMMAND",
336 	"QUE_BUSY_COMMAND",
337 	"QUE_SENSE",
338 	"JUST_RETURN",
339 	"COMMAND_DONE_EACCES",
340 	"QUE_LAST_COMMAND",
341 	"COMMAND_TIMEOUT",
342 	"PATH_FAILED",
343 	"DEVICE_RESET",
344 	"DEVICE_TAMPER",
345 	"ATTEMPT_RETRY"
346 };
347 
348 const char *bogusID = "Unknown Media ID";
349 
350 /* default density offsets in the table above */
351 #define	DEF_BLANK	0
352 #define	DEF_NOREWIND	1
353 #define	DEF_BSD		2
354 #define	DEF_BSD_NR	3
355 
356 /* Sense Key, ASC/ASCQ for which tape ejection is needed */
357 
358 static struct tape_failure_code {
359 	uchar_t key;
360 	uchar_t add_code;
361 	uchar_t qual_code;
362 } st_tape_failure_code[] = {
363 	{ KEY_HARDWARE_ERROR, 0x15, 0x01},
364 	{ KEY_HARDWARE_ERROR, 0x44, 0x00},
365 	{ KEY_HARDWARE_ERROR, 0x53, 0x00},
366 	{ KEY_HARDWARE_ERROR, 0x53, 0x01},
367 	{ KEY_NOT_READY, 0x53, 0x00},
368 	{ 0xff}
369 };
370 
371 /*  clean bit position and mask */
372 
373 static struct cln_bit_position {
374 	ushort_t cln_bit_byte;
375 	uchar_t cln_bit_mask;
376 } st_cln_bit_position[] = {
377 	{ 21, 0x08},
378 	{ 70, 0xc0},
379 	{ 18, 0x81}  /* 80 bit indicates in bit mode, 1 bit clean light is on */
380 };
381 
382 /*
383  * architecture dependent allocation restrictions. For x86, we'll set
384  * dma_attr_addr_hi to st_max_phys_addr and dma_attr_sgllen to
385  * st_sgl_size during _init().
386  */
387 #if defined(__sparc)
388 static ddi_dma_attr_t st_alloc_attr = {
389 	DMA_ATTR_V0,	/* version number */
390 	0x0,		/* lowest usable address */
391 	0xFFFFFFFFull,	/* high DMA address range */
392 	0xFFFFFFFFull,	/* DMA counter register */
393 	1,		/* DMA address alignment */
394 	1,		/* DMA burstsizes */
395 	1,		/* min effective DMA size */
396 	0xFFFFFFFFull,	/* max DMA xfer size */
397 	0xFFFFFFFFull,	/* segment boundary */
398 	1,		/* s/g list length */
399 	512,		/* granularity of device */
400 	0		/* DMA transfer flags */
401 };
402 #elif defined(__x86)
403 static ddi_dma_attr_t st_alloc_attr = {
404 	DMA_ATTR_V0,	/* version number */
405 	0x0,		/* lowest usable address */
406 	0x0,		/* high DMA address range [set in _init()] */
407 	0xFFFFull,	/* DMA counter register */
408 	512,		/* DMA address alignment */
409 	1,		/* DMA burstsizes */
410 	1,		/* min effective DMA size */
411 	0xFFFFFFFFull,	/* max DMA xfer size */
412 	0xFFFFFFFFull,  /* segment boundary */
413 	0,		/* s/g list length */
414 	512,		/* granularity of device [set in _init()] */
415 	0		/* DMA transfer flags */
416 };
417 uint64_t st_max_phys_addr = 0xFFFFFFFFull;
418 int st_sgl_size = 0xF;
419 
420 #endif
421 
422 /*
423  * Configuration Data:
424  *
425  * Device driver ops vector
426  */
427 static int st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p);
428 static int st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p);
429 static int st_read(dev_t  dev,  struct   uio   *uio_p,   cred_t *cred_p);
430 static int st_write(dev_t  dev,  struct  uio   *uio_p,   cred_t *cred_p);
431 static int st_open(dev_t  *devp,  int  flag,  int  otyp,  cred_t *cred_p);
432 static int st_close(dev_t  dev,  int  flag,  int  otyp,  cred_t *cred_p);
433 static int st_strategy(struct buf *bp);
434 static int st_queued_strategy(buf_t *bp);
435 static int st_ioctl(dev_t dev, int cmd, intptr_t arg, int  flag,
436 	cred_t *cred_p, int *rval_p);
437 extern int nulldev(), nodev();
438 
439 static struct cb_ops st_cb_ops = {
440 	st_open,		/* open */
441 	st_close,		/* close */
442 	st_queued_strategy,	/* strategy Not Block device but async checks */
443 	nodev,			/* print */
444 	nodev,			/* dump */
445 	st_read,		/* read */
446 	st_write,		/* write */
447 	st_ioctl,		/* ioctl */
448 	nodev,			/* devmap */
449 	nodev,			/* mmap */
450 	nodev,			/* segmap */
451 	nochpoll,		/* poll */
452 	ddi_prop_op,		/* cb_prop_op */
453 	0,			/* streamtab  */
454 	D_64BIT | D_MP | D_NEW | D_HOTPLUG |
455 	D_OPEN_RETURNS_EINTR,	/* cb_flag */
456 	CB_REV,			/* cb_rev */
457 	st_aread, 		/* async I/O read entry point */
458 	st_awrite		/* async I/O write entry point */
459 
460 };
461 
462 static int st_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
463 		void **result);
464 static int st_probe(dev_info_t *dev);
465 static int st_attach(dev_info_t *dev, ddi_attach_cmd_t cmd);
466 static int st_detach(dev_info_t *dev, ddi_detach_cmd_t cmd);
467 
468 static struct dev_ops st_ops = {
469 	DEVO_REV,		/* devo_rev, */
470 	0,			/* refcnt  */
471 	st_info,		/* info */
472 	nulldev,		/* identify */
473 	st_probe,		/* probe */
474 	st_attach,		/* attach */
475 	st_detach,		/* detach */
476 	nodev,			/* reset */
477 	&st_cb_ops,		/* driver operations */
478 	(struct bus_ops *)0,	/* bus operations */
479 	nulldev,		/* power */
480 	ddi_quiesce_not_needed,	/* devo_quiesce */
481 };
482 
483 /*
484  * Local Function Declarations
485  */
486 static char *st_print_scsi_cmd(char cmd);
487 static void st_print_cdb(dev_info_t *dip, char *label, uint_t level,
488     char *title, char *cdb);
489 static void st_clean_print(dev_info_t *dev, char *label, uint_t level,
490     char *title, char *data, int len);
491 static int st_doattach(struct scsi_device *devp, int (*canwait)());
492 static void st_known_tape_type(struct scsi_tape *un);
493 static int st_get_conf_from_st_dot_conf(struct scsi_tape *, char *,
494     struct st_drivetype *);
495 static int st_get_conf_from_st_conf_dot_c(struct scsi_tape *, char *,
496     struct st_drivetype *);
497 static int st_get_conf_from_tape_drive(struct scsi_tape *, char *,
498     struct st_drivetype *);
499 static int st_get_densities_from_tape_drive(struct scsi_tape *,
500     struct st_drivetype *);
501 static int st_get_timeout_values_from_tape_drive(struct scsi_tape *,
502     struct st_drivetype *);
503 static int st_get_timeouts_value(struct scsi_tape *, uchar_t, ushort_t *,
504     ushort_t);
505 static int st_get_default_conf(struct scsi_tape *, char *,
506     struct st_drivetype *);
507 static int st_rw(dev_t dev, struct uio *uio, int flag);
508 static int st_arw(dev_t dev, struct aio_req *aio, int flag);
509 static int st_find_eod(struct scsi_tape *un);
510 static int st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag);
511 static int st_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *, int flag);
512 static int st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag);
513 static int st_mtiocltop(struct scsi_tape *un, intptr_t arg, int flag);
514 static int st_do_mtioctop(struct scsi_tape *un, struct mtlop *mtop);
515 static void st_start(struct scsi_tape *un);
516 static int st_handle_start_busy(struct scsi_tape *un, struct buf *bp,
517     clock_t timeout_interval, int queued);
518 static int st_handle_intr_busy(struct scsi_tape *un, struct buf *bp,
519     clock_t timeout_interval);
520 static int st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp);
521 static void st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp);
522 static void st_init(struct scsi_tape *un);
523 static void st_make_cmd(struct scsi_tape *un, struct buf *bp,
524     int (*func)(caddr_t));
525 static void st_make_uscsi_cmd(struct scsi_tape *, struct uscsi_cmd *,
526     struct buf *bp, int (*func)(caddr_t));
527 static void st_intr(struct scsi_pkt *pkt);
528 static void st_set_state(struct scsi_tape *un, buf_t *bp);
529 static void st_test_append(struct buf *bp);
530 static int st_runout(caddr_t);
531 static int st_cmd(struct scsi_tape *un, int com, int64_t count, int wait);
532 static int st_setup_cmd(struct scsi_tape *un, buf_t *bp, int com,
533     int64_t count);
534 static int st_set_compression(struct scsi_tape *un);
535 static int st_write_fm(dev_t dev, int wfm);
536 static int st_determine_generic(struct scsi_tape *un);
537 static int st_determine_density(struct scsi_tape *un, int rw);
538 static int st_get_density(struct scsi_tape *un);
539 static int st_set_density(struct scsi_tape *un);
540 static int st_loadtape(struct scsi_tape *un);
541 static int st_modesense(struct scsi_tape *un);
542 static int st_modeselect(struct scsi_tape *un);
543 static errstate st_handle_incomplete(struct scsi_tape *un, struct buf *bp);
544 static int st_wrongtapetype(struct scsi_tape *un);
545 static errstate st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt);
546 static errstate st_handle_sense(struct scsi_tape *un, struct buf *bp,
547     tapepos_t *);
548 static errstate st_handle_autosense(struct scsi_tape *un, struct buf *bp,
549     tapepos_t *);
550 static int st_get_error_entry(struct scsi_tape *un, intptr_t arg, int flag);
551 static void st_update_error_stack(struct scsi_tape *un, struct scsi_pkt *pkt,
552     struct scsi_arq_status *cmd);
553 static void st_empty_error_stack(struct scsi_tape *un);
554 static errstate st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt,
555     struct scsi_arq_status *, tapepos_t *);
556 static int st_report_soft_errors(dev_t dev, int flag);
557 static void st_delayed_cv_broadcast(void *arg);
558 static int st_check_media(dev_t dev, enum mtio_state state);
559 static int st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
560 static void st_intr_restart(void *arg);
561 static void st_start_restart(void *arg);
562 static int st_gen_mode_sense(struct scsi_tape *un, ubufunc_t ubf, int page,
563     struct seq_mode *page_data, int page_size);
564 static int st_change_block_size(struct scsi_tape *un, uint32_t nblksz);
565 static int st_gen_mode_select(struct scsi_tape *un, ubufunc_t ubf,
566     struct seq_mode *page_data, int page_size);
567 static int st_read_block_limits(struct scsi_tape *un,
568     struct read_blklim *read_blk);
569 static int st_report_density_support(struct scsi_tape *un,
570     uchar_t *density_data, size_t buflen);
571 static int st_report_supported_operation(struct scsi_tape *un,
572     uchar_t *oper_data, uchar_t option_code, ushort_t service_action);
573 static int st_tape_init(struct scsi_tape *un);
574 static void st_flush(struct scsi_tape *un);
575 static void st_set_pe_errno(struct scsi_tape *un);
576 static void st_hba_unflush(struct scsi_tape *un);
577 static void st_turn_pe_on(struct scsi_tape *un);
578 static void st_turn_pe_off(struct scsi_tape *un);
579 static void st_set_pe_flag(struct scsi_tape *un);
580 static void st_clear_pe(struct scsi_tape *un);
581 static void st_wait_for_io(struct scsi_tape *un);
582 static int st_set_devconfig_page(struct scsi_tape *un, int compression_on);
583 static int st_set_datacomp_page(struct scsi_tape *un, int compression_on);
584 static int st_reserve_release(struct scsi_tape *un, int command, ubufunc_t ubf);
585 static int st_check_cdb_for_need_to_reserve(struct scsi_tape *un, uchar_t *cdb);
586 static int st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd,
587     int count);
588 static int st_take_ownership(struct scsi_tape *un, ubufunc_t ubf);
589 static int st_check_asc_ascq(struct scsi_tape *un);
590 static int st_check_clean_bit(struct scsi_tape *un);
591 static int st_check_alert_flags(struct scsi_tape *un);
592 static int st_check_sequential_clean_bit(struct scsi_tape *un);
593 static int st_check_sense_clean_bit(struct scsi_tape *un);
594 static int st_clear_unit_attentions(dev_t dev_instance, int max_trys);
595 static void st_calculate_timeouts(struct scsi_tape *un);
596 static writablity st_is_drive_worm(struct scsi_tape *un);
597 static int st_read_attributes(struct scsi_tape *un, uint16_t attribute,
598     void *buf, size_t size, ubufunc_t bufunc);
599 static int st_get_special_inquiry(struct scsi_tape *un, uchar_t size,
600     caddr_t dest, uchar_t page);
601 static int st_update_block_pos(struct scsi_tape *un, bufunc_t bf,
602     int post_space);
603 static int st_interpret_read_pos(struct scsi_tape const *un, tapepos_t *dest,
604     read_p_types type, size_t data_sz, const caddr_t responce, int post_space);
605 static int st_get_read_pos(struct scsi_tape *un, buf_t *bp);
606 static int st_logical_block_locate(struct scsi_tape *un, ubufunc_t ubf,
607     tapepos_t *pos, uint64_t lblk, uchar_t partition);
608 static int st_mtfsf_ioctl(struct scsi_tape *un, int64_t files);
609 static int st_mtfsr_ioctl(struct scsi_tape *un, int64_t count);
610 static int st_mtbsf_ioctl(struct scsi_tape *un, int64_t files);
611 static int st_mtnbsf_ioctl(struct scsi_tape *un, int64_t count);
612 static int st_mtbsr_ioctl(struct scsi_tape *un, int64_t num);
613 static int st_mtfsfm_ioctl(struct scsi_tape *un, int64_t cnt);
614 static int st_mtbsfm_ioctl(struct scsi_tape *un, int64_t cnt);
615 static int st_backward_space_files(struct scsi_tape *un, int64_t count,
616     int infront);
617 static int st_forward_space_files(struct scsi_tape *un, int64_t files);
618 static int st_scenic_route_to_begining_of_file(struct scsi_tape *un,
619     int32_t fileno);
620 static int st_space_to_begining_of_file(struct scsi_tape *un);
621 static int st_space_records(struct scsi_tape *un, int64_t records);
622 static int st_get_media_identification(struct scsi_tape *un, ubufunc_t bufunc);
623 static errstate st_command_recovery(struct scsi_tape *un, struct scsi_pkt *pkt,
624     errstate onentry);
625 static void st_recover(void *arg);
626 static void st_recov_cb(struct scsi_pkt *pkt);
627 static int st_rcmd(struct scsi_tape *un, int com, int64_t count, int wait);
628 static int st_uscsi_rcmd(struct scsi_tape *un, struct uscsi_cmd *ucmd,
629     int flag);
630 static void st_add_recovery_info_to_pkt(struct scsi_tape *un, buf_t *bp,
631     struct scsi_pkt *cmd);
632 static int st_check_mode_for_change(struct scsi_tape *un, ubufunc_t ubf);
633 static int st_test_path_to_device(struct scsi_tape *un);
634 static int st_recovery_read_pos(struct scsi_tape *un, read_p_types type,
635     read_pos_data_t *raw);
636 static int st_recovery_get_position(struct scsi_tape *un, tapepos_t *read,
637     read_pos_data_t *raw);
638 static int st_compare_expected_position(struct scsi_tape *un, st_err_info *ei,
639     cmd_attribute const * cmd_att, tapepos_t *read);
640 static errstate st_recover_reissue_pkt(struct scsi_tape *us,
641     struct scsi_pkt *pkt);
642 static int st_transport(struct scsi_tape *un, struct scsi_pkt *pkt);
643 static buf_t *st_remove_from_queue(buf_t **head, buf_t **tail, buf_t *bp);
644 static void st_add_to_queue(buf_t **head, buf_t **tail, buf_t *end, buf_t *bp);
645 static int st_reset(struct scsi_tape *un, int reset_type);
646 static void st_reset_notification(caddr_t arg);
647 static const cmd_attribute *st_lookup_cmd_attribute(unsigned char cmd);
648 
649 static int st_set_target_TLR_mode(struct scsi_tape *un, ubufunc_t ubf);
650 static int st_make_sure_mode_data_is_correct(struct scsi_tape *un,
651     ubufunc_t ubf);
652 
653 #ifdef	__x86
654 /*
655  * routines for I/O in big block size
656  */
657 static void st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp);
658 static struct contig_mem *st_get_contig_mem(struct scsi_tape *un, size_t len,
659     int alloc_flags);
660 static int st_bigblk_xfer_done(struct buf *bp);
661 static struct buf *st_get_bigblk_bp(struct buf *bp);
662 #endif
663 static void st_print_position(dev_info_t *dev, char *label, uint_t level,
664     const char *comment, tapepos_t *pos);
665 
666 /*
667  * error statistics create/update functions
668  */
669 static int st_create_errstats(struct scsi_tape *, int);
670 static int st_validate_tapemarks(struct scsi_tape *un, ubufunc_t ubf,
671     tapepos_t *pos);
672 
673 #ifdef STDEBUG
674 static void st_debug_cmds(struct scsi_tape *un, int com, int count, int wait);
675 #endif /* STDEBUG */
676 static char *st_dev_name(dev_t dev);
677 
678 #if !defined(lint)
679 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt",
680     scsi_pkt buf uio scsi_cdb uscsi_cmd))
681 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_extended_sense scsi_status))
682 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", recov_info))
683 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device))
684 _NOTE(DATA_READABLE_WITHOUT_LOCK(st_drivetype scsi_address))
685 #endif
686 
687 /*
688  * autoconfiguration routines.
689  */
690 
691 static struct modldrv modldrv = {
692 	&mod_driverops,		/* Type of module. This one is a driver */
693 	"SCSI tape Driver", 	/* Name of the module. */
694 	&st_ops			/* driver ops */
695 };
696 
697 static struct modlinkage modlinkage = {
698 	MODREV_1, &modldrv, NULL
699 };
700 
701 /*
702  * Notes on Post Reset Behavior in the tape driver:
703  *
704  * When the tape drive is opened, the driver  attempts  to make sure that
705  * the tape head is positioned exactly where it was left when it was last
706  * closed  provided  the  medium  is not  changed.  If the tape  drive is
707  * opened in O_NDELAY mode, the repositioning  (if necessary for any loss
708  * of position due to reset) will happen when the first tape operation or
709  * I/O occurs.  The repositioning (if required) may not be possible under
710  * certain situations such as when the device firmware not able to report
711  * the medium  change in the REQUEST  SENSE data  because of a reset or a
712  * misbehaving  bus  not  allowing  the  reposition  to  happen.  In such
713  * extraordinary  situations, where the driver fails to position the head
714  * at its  original  position,  it will fail the open the first  time, to
715  * save the applications from overwriting the data.  All further attempts
716  * to open the tape device will result in the driver  attempting  to load
717  * the  tape at BOT  (beginning  of  tape).  Also a  warning  message  to
718  * indicate  that further  attempts to open the tape device may result in
719  * the tape being  loaded at BOT will be printed on the  console.  If the
720  * tape  device is opened  in  O_NDELAY  mode,  failure  to  restore  the
721  * original tape head  position,  will result in the failure of the first
722  * tape  operation  or I/O,  Further,  the  driver  will  invalidate  its
723  * internal tape position  which will  necessitate  the  applications  to
724  * validate the position by using either a tape  positioning  ioctl (such
725  * as MTREW) or closing and reopening the tape device.
726  *
727  */
728 
729 int
730 _init(void)
731 {
732 	int e;
733 
734 	if (((e = ddi_soft_state_init(&st_state,
735 	    sizeof (struct scsi_tape), ST_MAXUNIT)) != 0)) {
736 		return (e);
737 	}
738 
739 	if ((e = mod_install(&modlinkage)) != 0) {
740 		ddi_soft_state_fini(&st_state);
741 	} else {
742 #ifdef STDEBUG
743 		mutex_init(&st_debug_mutex, NULL, MUTEX_DRIVER, NULL);
744 #endif
745 
746 #if defined(__x86)
747 		/* set the max physical address for iob allocs on x86 */
748 		st_alloc_attr.dma_attr_addr_hi = st_max_phys_addr;
749 
750 		/*
751 		 * set the sgllen for iob allocs on x86. If this is set less
752 		 * than the number of pages the buffer will take
753 		 * (taking into account alignment), it would force the
754 		 * allocator to try and allocate contiguous pages.
755 		 */
756 		st_alloc_attr.dma_attr_sgllen = st_sgl_size;
757 #endif
758 	}
759 
760 	return (e);
761 }
762 
763 int
764 _fini(void)
765 {
766 	int e;
767 
768 	if ((e = mod_remove(&modlinkage)) != 0) {
769 		return (e);
770 	}
771 
772 #ifdef STDEBUG
773 	mutex_destroy(&st_debug_mutex);
774 #endif
775 
776 	ddi_soft_state_fini(&st_state);
777 
778 	return (e);
779 }
780 
781 int
782 _info(struct modinfo *modinfop)
783 {
784 	return (mod_info(&modlinkage, modinfop));
785 }
786 
787 
788 static int
789 st_probe(dev_info_t *devi)
790 {
791 	int instance;
792 	struct scsi_device *devp;
793 	int rval;
794 
795 #if !defined(__sparc)
796 	char    *tape_prop;
797 	int	tape_prop_len;
798 #endif
799 
800 	ST_ENTR(devi, st_probe);
801 
802 	/* If self identifying device */
803 	if (ddi_dev_is_sid(devi) == DDI_SUCCESS) {
804 		return (DDI_PROBE_DONTCARE);
805 	}
806 
807 #if !defined(__sparc)
808 	/*
809 	 * Since some x86 HBAs have devnodes that look like SCSI as
810 	 * far as we can tell but aren't really SCSI (DADK, like mlx)
811 	 * we check for the presence of the "tape" property.
812 	 */
813 	if (ddi_prop_op(DDI_DEV_T_NONE, devi, PROP_LEN_AND_VAL_ALLOC,
814 	    DDI_PROP_CANSLEEP, "tape",
815 	    (caddr_t)&tape_prop, &tape_prop_len) != DDI_PROP_SUCCESS) {
816 		return (DDI_PROBE_FAILURE);
817 	}
818 	if (strncmp(tape_prop, "sctp", tape_prop_len) != 0) {
819 		kmem_free(tape_prop, tape_prop_len);
820 		return (DDI_PROBE_FAILURE);
821 	}
822 	kmem_free(tape_prop, tape_prop_len);
823 #endif
824 
825 	devp = ddi_get_driver_private(devi);
826 	instance = ddi_get_instance(devi);
827 
828 	if (ddi_get_soft_state(st_state, instance) != NULL) {
829 		return (DDI_PROBE_PARTIAL);
830 	}
831 
832 
833 	/*
834 	 * Turn around and call probe routine to see whether
835 	 * we actually have a tape at this SCSI nexus.
836 	 */
837 	if (scsi_probe(devp, NULL_FUNC) == SCSIPROBE_EXISTS) {
838 
839 		/*
840 		 * In checking the whole inq_dtype byte we are looking at both
841 		 * the Peripheral Qualifier and the Peripheral Device Type.
842 		 * For this driver we are only interested in sequential devices
843 		 * that are connected or capable if connecting to this logical
844 		 * unit.
845 		 */
846 		if (devp->sd_inq->inq_dtype ==
847 		    (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) {
848 			ST_DEBUG6(devi, st_label, SCSI_DEBUG,
849 			    "probe exists\n");
850 			rval = DDI_PROBE_SUCCESS;
851 		} else {
852 			rval = DDI_PROBE_FAILURE;
853 		}
854 	} else {
855 		ST_DEBUG6(devi, st_label, SCSI_DEBUG,
856 		    "probe failure: nothing there\n");
857 		rval = DDI_PROBE_FAILURE;
858 	}
859 	scsi_unprobe(devp);
860 	return (rval);
861 }
862 
863 static int
864 st_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
865 {
866 	int 	instance;
867 	int	wide;
868 	int 	dev_instance;
869 	int	ret_status;
870 	struct	scsi_device *devp;
871 	int	node_ix;
872 	struct	scsi_tape *un;
873 
874 	ST_ENTR(devi, st_attach);
875 
876 	devp = ddi_get_driver_private(devi);
877 	instance = ddi_get_instance(devi);
878 
879 	switch (cmd) {
880 		case DDI_ATTACH:
881 			if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
882 			    "tape-command-recovery-disable", 0) != 0) {
883 				st_recov_sz = sizeof (pkt_info);
884 			}
885 			if (st_doattach(devp, SLEEP_FUNC) == DDI_FAILURE) {
886 				return (DDI_FAILURE);
887 			}
888 			break;
889 		case DDI_RESUME:
890 			/*
891 			 * Suspend/Resume
892 			 *
893 			 * When the driver suspended, there might be
894 			 * outstanding cmds and therefore we need to
895 			 * reset the suspended flag and resume the scsi
896 			 * watch thread and restart commands and timeouts
897 			 */
898 
899 			if (!(un = ddi_get_soft_state(st_state, instance))) {
900 				return (DDI_FAILURE);
901 			}
902 			dev_instance = ((un->un_dev == 0) ? MTMINOR(instance) :
903 			    un->un_dev);
904 
905 			mutex_enter(ST_MUTEX);
906 
907 			un->un_throttle = un->un_max_throttle;
908 			un->un_tids_at_suspend = 0;
909 			un->un_pwr_mgmt = ST_PWR_NORMAL;
910 
911 			if (un->un_swr_token) {
912 				scsi_watch_resume(un->un_swr_token);
913 			}
914 
915 			/*
916 			 * Restart timeouts
917 			 */
918 			if ((un->un_tids_at_suspend & ST_DELAY_TID) != 0) {
919 				mutex_exit(ST_MUTEX);
920 				un->un_delay_tid = timeout(
921 				    st_delayed_cv_broadcast, un,
922 				    drv_usectohz((clock_t)
923 				    MEDIA_ACCESS_DELAY));
924 				mutex_enter(ST_MUTEX);
925 			}
926 
927 			if (un->un_tids_at_suspend & ST_HIB_TID) {
928 				mutex_exit(ST_MUTEX);
929 				un->un_hib_tid = timeout(st_intr_restart, un,
930 				    ST_STATUS_BUSY_TIMEOUT);
931 				mutex_enter(ST_MUTEX);
932 			}
933 
934 			ret_status = st_clear_unit_attentions(dev_instance, 5);
935 
936 			/*
937 			 * now check if we need to restore the tape position
938 			 */
939 			if ((un->un_suspend_pos.pmode != invalid) &&
940 			    ((un->un_suspend_pos.fileno > 0) ||
941 			    (un->un_suspend_pos.blkno > 0)) ||
942 			    (un->un_suspend_pos.lgclblkno > 0)) {
943 				if (ret_status != 0) {
944 					/*
945 					 * tape didn't get good TUR
946 					 * just print out error messages
947 					 */
948 					scsi_log(ST_DEVINFO, st_label, CE_WARN,
949 					    "st_attach-RESUME: tape failure "
950 					    " tape position will be lost");
951 				} else {
952 					/* this prints errors */
953 					(void) st_validate_tapemarks(un,
954 					    st_uscsi_cmd, &un->un_suspend_pos);
955 				}
956 				/*
957 				 * there are no retries, if there is an error
958 				 * we don't know if the tape has changed
959 				 */
960 				un->un_suspend_pos.pmode = invalid;
961 			}
962 
963 			/* now we are ready to start up any queued I/Os */
964 			if (un->un_ncmds || un->un_quef) {
965 				st_start(un);
966 			}
967 
968 			cv_broadcast(&un->un_suspend_cv);
969 			mutex_exit(ST_MUTEX);
970 			return (DDI_SUCCESS);
971 
972 		default:
973 			return (DDI_FAILURE);
974 	}
975 
976 	un = ddi_get_soft_state(st_state, instance);
977 
978 	ST_DEBUG(devi, st_label, SCSI_DEBUG,
979 	    "st_attach: instance=%x\n", instance);
980 
981 	/*
982 	 * Add a zero-length attribute to tell the world we support
983 	 * kernel ioctls (for layered drivers)
984 	 */
985 	(void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
986 	    DDI_KERNEL_IOCTL, NULL, 0);
987 
988 	ddi_report_dev((dev_info_t *)devi);
989 
990 	/*
991 	 * If it's a SCSI-2 tape drive which supports wide,
992 	 * tell the host adapter to use wide.
993 	 */
994 	wide = ((devp->sd_inq->inq_rdf == RDF_SCSI2) &&
995 	    (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) ?  1 : 0;
996 
997 	if (scsi_ifsetcap(ROUTE, "wide-xfer", wide, 1) == 1) {
998 		ST_DEBUG(devi, st_label, SCSI_DEBUG,
999 		    "Wide Transfer %s\n", wide ? "enabled" : "disabled");
1000 	}
1001 
1002 	/*
1003 	 * enable autorequest sense; keep the rq packet around in case
1004 	 * the autorequest sense fails because of a busy condition
1005 	 * do a getcap first in case the capability is not variable
1006 	 */
1007 	if (scsi_ifgetcap(ROUTE, "auto-rqsense", 1) == 1) {
1008 		un->un_arq_enabled = 1;
1009 	} else {
1010 		un->un_arq_enabled =
1011 		    ((scsi_ifsetcap(ROUTE, "auto-rqsense", 1, 1) == 1) ? 1 : 0);
1012 	}
1013 
1014 	ST_DEBUG(devi, st_label, SCSI_DEBUG, "auto request sense %s\n",
1015 	    (un->un_arq_enabled ? "enabled" : "disabled"));
1016 
1017 	un->un_untagged_qing =
1018 	    (scsi_ifgetcap(ROUTE, "untagged-qing", 0) == 1);
1019 
1020 	/*
1021 	 * XXX - This is just for 2.6.  to tell users that write buffering
1022 	 *	has gone away.
1023 	 */
1024 	if (un->un_arq_enabled && un->un_untagged_qing) {
1025 		if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
1026 		    "tape-driver-buffering", 0) != 0) {
1027 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1028 			    "Write Data Buffering has been depricated. Your "
1029 			    "applications should continue to work normally.\n"
1030 			    " But, they should  ported to use Asynchronous "
1031 			    " I/O\n"
1032 			    " For more information, read about "
1033 			    " tape-driver-buffering "
1034 			    "property in the st(7d) man page\n");
1035 		}
1036 	}
1037 
1038 	un->un_max_throttle = un->un_throttle = un->un_last_throttle = 1;
1039 	un->un_flush_on_errors = 0;
1040 	un->un_mkr_pkt = (struct scsi_pkt *)NULL;
1041 
1042 	ST_DEBUG(devi, st_label, SCSI_DEBUG,
1043 	    "throttle=%x, max_throttle = %x\n",
1044 	    un->un_throttle, un->un_max_throttle);
1045 
1046 	/* initialize persistent errors to nil */
1047 	un->un_persistence = 0;
1048 	un->un_persist_errors = 0;
1049 
1050 	/*
1051 	 * Get dma-max from HBA driver. If it is not defined, use 64k
1052 	 */
1053 	un->un_maxdma	= scsi_ifgetcap(&devp->sd_address, "dma-max", 1);
1054 	if (un->un_maxdma == -1) {
1055 		ST_DEBUG(devi, st_label, SCSI_DEBUG,
1056 		    "Received a value that looked like -1. Using 64k maxdma");
1057 		un->un_maxdma = (64 * ONE_K);
1058 	}
1059 
1060 #ifdef	__x86
1061 	/*
1062 	 * for x86, the device may be able to DMA more than the system will
1063 	 * allow under some circumstances. We need account for both the HBA's
1064 	 * and system's contraints.
1065 	 *
1066 	 * Get the maximum DMA under worse case conditions. e.g. looking at the
1067 	 * device constraints, the max copy buffer size, and the worse case
1068 	 * fragmentation. NOTE: this may differ from dma-max since dma-max
1069 	 * doesn't take the worse case framentation into account.
1070 	 *
1071 	 * e.g. a device may be able to DMA 16MBytes, but can only DMA 1MByte
1072 	 * if none of the pages are contiguous. Keeping track of both of these
1073 	 * values allows us to support larger tape block sizes on some devices.
1074 	 */
1075 	un->un_maxdma_arch = scsi_ifgetcap(&devp->sd_address, "dma-max-arch",
1076 	    1);
1077 
1078 	/*
1079 	 * If the dma-max-arch capability is not implemented, or the value
1080 	 * comes back higher than what was reported in dma-max, use dma-max.
1081 	 */
1082 	if ((un->un_maxdma_arch == -1) ||
1083 	    ((uint_t)un->un_maxdma < (uint_t)un->un_maxdma_arch)) {
1084 		un->un_maxdma_arch = un->un_maxdma;
1085 	}
1086 #endif
1087 
1088 	/*
1089 	 * Get the max allowable cdb size
1090 	 */
1091 	un->un_max_cdb_sz =
1092 	    scsi_ifgetcap(&devp->sd_address, "max-cdb-length", 1);
1093 	if (un->un_max_cdb_sz < CDB_GROUP0) {
1094 		ST_DEBUG(devi, st_label, SCSI_DEBUG,
1095 		    "HBA reported max-cdb-length as %d\n", un->un_max_cdb_sz);
1096 		un->un_max_cdb_sz = CDB_GROUP4; /* optimistic default */
1097 	}
1098 
1099 	if (strcmp(ddi_driver_name(ddi_get_parent(ST_DEVINFO)), "scsi_vhci")) {
1100 		un->un_multipath = 0;
1101 	} else {
1102 		un->un_multipath = 1;
1103 	}
1104 
1105 	un->un_maxbsize = MAXBSIZE_UNKNOWN;
1106 
1107 	un->un_mediastate = MTIO_NONE;
1108 	un->un_HeadClean  = TAPE_ALERT_SUPPORT_UNKNOWN;
1109 
1110 	/*
1111 	 * initialize kstats
1112 	 */
1113 	un->un_stats = kstat_create("st", instance, NULL, "tape",
1114 	    KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
1115 	if (un->un_stats) {
1116 		un->un_stats->ks_lock = ST_MUTEX;
1117 		kstat_install(un->un_stats);
1118 	}
1119 	(void) st_create_errstats(un, instance);
1120 
1121 	/*
1122 	 * find the drive type for this target
1123 	 */
1124 	mutex_enter(ST_MUTEX);
1125 	un->un_dev = MTMINOR(instance);
1126 	st_known_tape_type(un);
1127 	un->un_dev = 0;
1128 	mutex_exit(ST_MUTEX);
1129 
1130 	for (node_ix = 0; node_ix < ST_NUM_MEMBERS(st_minor_data); node_ix++) {
1131 		int minor;
1132 		char *name;
1133 
1134 		name  = st_minor_data[node_ix].name;
1135 		minor = st_minor_data[node_ix].minor;
1136 
1137 		/*
1138 		 * For default devices set the density to the
1139 		 * preferred default density for this device.
1140 		 */
1141 		if (node_ix <= DEF_BSD_NR) {
1142 			minor |= un->un_dp->default_density;
1143 		}
1144 		minor |= MTMINOR(instance);
1145 
1146 		if (ddi_create_minor_node(devi, name, S_IFCHR, minor,
1147 		    DDI_NT_TAPE, NULL) == DDI_SUCCESS) {
1148 			continue;
1149 		}
1150 
1151 		ddi_remove_minor_node(devi, NULL);
1152 
1153 		(void) scsi_reset_notify(ROUTE, SCSI_RESET_CANCEL,
1154 		    st_reset_notification, (caddr_t)un);
1155 		cv_destroy(&un->un_clscv);
1156 		cv_destroy(&un->un_sbuf_cv);
1157 		cv_destroy(&un->un_queue_cv);
1158 		cv_destroy(&un->un_state_cv);
1159 #ifdef	__x86
1160 		cv_destroy(&un->un_contig_mem_cv);
1161 #endif
1162 		cv_destroy(&un->un_suspend_cv);
1163 		cv_destroy(&un->un_tape_busy_cv);
1164 		cv_destroy(&un->un_recov_buf_cv);
1165 		if (un->un_recov_taskq) {
1166 			ddi_taskq_destroy(un->un_recov_taskq);
1167 		}
1168 		if (un->un_sbufp) {
1169 			freerbuf(un->un_sbufp);
1170 		}
1171 		if (un->un_recov_buf) {
1172 			freerbuf(un->un_recov_buf);
1173 		}
1174 		if (un->un_uscsi_rqs_buf) {
1175 			kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
1176 		}
1177 		if (un->un_mspl) {
1178 			i_ddi_mem_free((caddr_t)un->un_mspl, NULL);
1179 		}
1180 		if (un->un_dp_size) {
1181 			kmem_free(un->un_dp, un->un_dp_size);
1182 		}
1183 		if (un->un_state) {
1184 			kstat_delete(un->un_stats);
1185 		}
1186 		if (un->un_errstats) {
1187 			kstat_delete(un->un_errstats);
1188 		}
1189 
1190 		scsi_destroy_pkt(un->un_rqs);
1191 		scsi_free_consistent_buf(un->un_rqs_bp);
1192 		ddi_soft_state_free(st_state, instance);
1193 		devp->sd_private = NULL;
1194 		devp->sd_sense = NULL;
1195 
1196 		ddi_prop_remove_all(devi);
1197 		return (DDI_FAILURE);
1198 	}
1199 
1200 	return (DDI_SUCCESS);
1201 }
1202 
1203 /*
1204  * st_detach:
1205  *
1206  * we allow a detach if and only if:
1207  *	- no tape is currently inserted
1208  *	- tape position is at BOT or unknown
1209  *		(if it is not at BOT then a no rewind
1210  *		device was opened and we have to preserve state)
1211  *	- it must be in a closed state : no timeouts or scsi_watch requests
1212  *		will exist if it is closed, so we don't need to check for
1213  *		them here.
1214  */
1215 /*ARGSUSED*/
1216 static int
1217 st_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
1218 {
1219 	int instance;
1220 	int result;
1221 	struct scsi_device *devp;
1222 	struct scsi_tape *un;
1223 	clock_t wait_cmds_complete;
1224 
1225 	ST_ENTR(devi, st_detach);
1226 
1227 	instance = ddi_get_instance(devi);
1228 
1229 	if (!(un = ddi_get_soft_state(st_state, instance))) {
1230 		return (DDI_FAILURE);
1231 	}
1232 
1233 	mutex_enter(ST_MUTEX);
1234 
1235 	/*
1236 	 * Clear error entry stack
1237 	 */
1238 	st_empty_error_stack(un);
1239 
1240 	mutex_exit(ST_MUTEX);
1241 
1242 	switch (cmd) {
1243 
1244 	case DDI_DETACH:
1245 		/*
1246 		 * Undo what we did in st_attach & st_doattach,
1247 		 * freeing resources and removing things we installed.
1248 		 * The system framework guarantees we are not active
1249 		 * with this devinfo node in any other entry points at
1250 		 * this time.
1251 		 */
1252 
1253 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1254 		    "st_detach: instance=%x, un=%p\n", instance,
1255 		    (void *)un);
1256 
1257 		if (((un->un_dp->options & ST_UNLOADABLE) == 0) ||
1258 		    ((un->un_rsvd_status & ST_APPLICATION_RESERVATIONS) != 0) ||
1259 		    (un->un_ncmds != 0) || (un->un_quef != NULL) ||
1260 		    (un->un_state != ST_STATE_CLOSED)) {
1261 			/*
1262 			 * we cannot unload some targets because the
1263 			 * inquiry returns junk unless immediately
1264 			 * after a reset
1265 			 */
1266 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
1267 			    "cannot unload instance %x\n", instance);
1268 			un->un_unit_attention_flags |= 4;
1269 			return (DDI_FAILURE);
1270 		}
1271 
1272 		/*
1273 		 * if the tape has been removed then we may unload;
1274 		 * do a test unit ready and if it returns NOT READY
1275 		 * then we assume that it is safe to unload.
1276 		 * as a side effect, pmode may be set to invalid if the
1277 		 * the test unit ready fails;
1278 		 * also un_state may be set to non-closed, so reset it
1279 		 */
1280 		if ((un->un_dev) &&		/* Been opened since attach */
1281 		    ((un->un_pos.pmode == legacy) &&
1282 		    (un->un_pos.fileno > 0) ||	/* Known position not rewound */
1283 		    (un->un_pos.blkno != 0)) ||	/* Or within first file */
1284 		    ((un->un_pos.pmode == logical) &&
1285 		    (un->un_pos.lgclblkno > 0))) {
1286 			mutex_enter(ST_MUTEX);
1287 			/*
1288 			 * Send Test Unit Ready in the hopes that if
1289 			 * the drive is not in the state we think it is.
1290 			 * And the state will be changed so it can be detached.
1291 			 * If the command fails to reach the device and
1292 			 * the drive was not rewound or unloaded we want
1293 			 * to fail the detach till a user command fails
1294 			 * where after the detach will succead.
1295 			 */
1296 			result = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
1297 			/*
1298 			 * After TUR un_state may be set to non-closed,
1299 			 * so reset it back.
1300 			 */
1301 			un->un_state = ST_STATE_CLOSED;
1302 			mutex_exit(ST_MUTEX);
1303 		}
1304 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1305 		    "un_status=%x, fileno=%x, blkno=%x\n",
1306 		    un->un_status, un->un_pos.fileno, un->un_pos.blkno);
1307 
1308 		/*
1309 		 * check again:
1310 		 * if we are not at BOT then it is not safe to unload
1311 		 */
1312 		if ((un->un_dev) &&		/* Been opened since attach */
1313 		    (result != EACCES) &&	/* drive is use by somebody */
1314 		    ((((un->un_pos.pmode == legacy) &&
1315 		    (un->un_pos.fileno > 0) ||	/* Known position not rewound */
1316 		    (un->un_pos.blkno != 0)) ||	/* Or within first file */
1317 		    ((un->un_pos.pmode == logical) &&
1318 		    (un->un_pos.lgclblkno > 0))) &&
1319 		    ((un->un_state == ST_STATE_CLOSED) &&
1320 		    (un->un_laststate == ST_STATE_CLOSING)))) {
1321 
1322 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1323 			    "cannot detach: pmode=%d fileno=0x%x, blkno=0x%x"
1324 			    " lgclblkno=0x%"PRIx64"\n", un->un_pos.pmode,
1325 			    un->un_pos.fileno, un->un_pos.blkno,
1326 			    un->un_pos.lgclblkno);
1327 			un->un_unit_attention_flags |= 4;
1328 			return (DDI_FAILURE);
1329 		}
1330 
1331 		/*
1332 		 * Just To make sure that we have released the
1333 		 * tape unit .
1334 		 */
1335 		if (un->un_dev && (un->un_rsvd_status & ST_RESERVE) &&
1336 		    !DEVI_IS_DEVICE_REMOVED(devi)) {
1337 			mutex_enter(ST_MUTEX);
1338 			(void) st_reserve_release(un, ST_RELEASE, st_uscsi_cmd);
1339 			mutex_exit(ST_MUTEX);
1340 		}
1341 
1342 		/*
1343 		 * now remove other data structures allocated in st_doattach()
1344 		 */
1345 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1346 		    "destroying/freeing\n");
1347 
1348 		(void) scsi_reset_notify(ROUTE, SCSI_RESET_CANCEL,
1349 		    st_reset_notification, (caddr_t)un);
1350 		cv_destroy(&un->un_clscv);
1351 		cv_destroy(&un->un_sbuf_cv);
1352 		cv_destroy(&un->un_queue_cv);
1353 		cv_destroy(&un->un_suspend_cv);
1354 		cv_destroy(&un->un_tape_busy_cv);
1355 		cv_destroy(&un->un_recov_buf_cv);
1356 
1357 		if (un->un_recov_taskq) {
1358 			ddi_taskq_destroy(un->un_recov_taskq);
1359 		}
1360 
1361 		if (un->un_hib_tid) {
1362 			(void) untimeout(un->un_hib_tid);
1363 			un->un_hib_tid = 0;
1364 		}
1365 
1366 		if (un->un_delay_tid) {
1367 			(void) untimeout(un->un_delay_tid);
1368 			un->un_delay_tid = 0;
1369 		}
1370 		cv_destroy(&un->un_state_cv);
1371 
1372 #ifdef	__x86
1373 		cv_destroy(&un->un_contig_mem_cv);
1374 
1375 		if (un->un_contig_mem_hdl != NULL) {
1376 			ddi_dma_free_handle(&un->un_contig_mem_hdl);
1377 		}
1378 #endif
1379 		if (un->un_sbufp) {
1380 			freerbuf(un->un_sbufp);
1381 		}
1382 		if (un->un_recov_buf) {
1383 			freerbuf(un->un_recov_buf);
1384 		}
1385 		if (un->un_uscsi_rqs_buf) {
1386 			kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
1387 		}
1388 		if (un->un_mspl) {
1389 			i_ddi_mem_free((caddr_t)un->un_mspl, NULL);
1390 		}
1391 		if (un->un_rqs) {
1392 			scsi_destroy_pkt(un->un_rqs);
1393 			scsi_free_consistent_buf(un->un_rqs_bp);
1394 		}
1395 		if (un->un_mkr_pkt) {
1396 			scsi_destroy_pkt(un->un_mkr_pkt);
1397 		}
1398 		if (un->un_arq_enabled) {
1399 			(void) scsi_ifsetcap(ROUTE, "auto-rqsense", 0, 1);
1400 		}
1401 		if (un->un_dp_size) {
1402 			kmem_free(un->un_dp, un->un_dp_size);
1403 		}
1404 		if (un->un_stats) {
1405 			kstat_delete(un->un_stats);
1406 			un->un_stats = (kstat_t *)0;
1407 		}
1408 		if (un->un_errstats) {
1409 			kstat_delete(un->un_errstats);
1410 			un->un_errstats = (kstat_t *)0;
1411 		}
1412 		if (un->un_media_id_len) {
1413 			kmem_free(un->un_media_id, un->un_media_id_len);
1414 		}
1415 		devp = ST_SCSI_DEVP;
1416 		ddi_soft_state_free(st_state, instance);
1417 		devp->sd_private = NULL;
1418 		devp->sd_sense = NULL;
1419 		scsi_unprobe(devp);
1420 		ddi_prop_remove_all(devi);
1421 		ddi_remove_minor_node(devi, NULL);
1422 		ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach done\n");
1423 		return (DDI_SUCCESS);
1424 
1425 	case DDI_SUSPEND:
1426 
1427 		/*
1428 		 * Suspend/Resume
1429 		 *
1430 		 * To process DDI_SUSPEND, we must do the following:
1431 		 *
1432 		 *  - check ddi_removing_power to see if power will be turned
1433 		 *    off. if so, return DDI_FAILURE
1434 		 *  - check if we are already suspended,
1435 		 *    if so, return DDI_FAILURE
1436 		 *  - check if device state is CLOSED,
1437 		 *    if not, return DDI_FAILURE.
1438 		 *  - wait until outstanding operations complete
1439 		 *  - save tape state
1440 		 *  - block new operations
1441 		 *  - cancel pending timeouts
1442 		 *
1443 		 */
1444 
1445 		if (ddi_removing_power(devi)) {
1446 			return (DDI_FAILURE);
1447 		}
1448 
1449 		if (un->un_dev == 0)
1450 			un->un_dev = MTMINOR(instance);
1451 
1452 		mutex_enter(ST_MUTEX);
1453 
1454 		/*
1455 		 * Shouldn't already be suspended, if so return failure
1456 		 */
1457 		if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
1458 			mutex_exit(ST_MUTEX);
1459 			return (DDI_FAILURE);
1460 		}
1461 		if (un->un_state != ST_STATE_CLOSED) {
1462 			mutex_exit(ST_MUTEX);
1463 			return (DDI_FAILURE);
1464 		}
1465 
1466 		/*
1467 		 * Wait for all outstanding I/O's to complete
1468 		 *
1469 		 * we wait on both ncmds and the wait queue for times
1470 		 * when we are flushing after persistent errors are
1471 		 * flagged, which is when ncmds can be 0, and the
1472 		 * queue can still have I/O's.  This way we preserve
1473 		 * order of biodone's.
1474 		 */
1475 		wait_cmds_complete = ddi_get_lbolt();
1476 		wait_cmds_complete +=
1477 		    st_wait_cmds_complete * drv_usectohz(1000000);
1478 		while (un->un_ncmds || un->un_quef ||
1479 		    (un->un_state == ST_STATE_RESOURCE_WAIT)) {
1480 
1481 			if (cv_timedwait(&un->un_tape_busy_cv, ST_MUTEX,
1482 			    wait_cmds_complete) == -1) {
1483 				/*
1484 				 * Time expired then cancel the command
1485 				 */
1486 				if (st_reset(un, RESET_LUN) == 0) {
1487 					if (un->un_last_throttle) {
1488 						un->un_throttle =
1489 						    un->un_last_throttle;
1490 					}
1491 					mutex_exit(ST_MUTEX);
1492 					return (DDI_FAILURE);
1493 				} else {
1494 					break;
1495 				}
1496 			}
1497 		}
1498 
1499 		/*
1500 		 * DDI_SUSPEND says that the system "may" power down, we
1501 		 * remember the file and block number before rewinding.
1502 		 * we also need to save state before issuing
1503 		 * any WRITE_FILE_MARK command.
1504 		 */
1505 		(void) st_update_block_pos(un, st_cmd, 0);
1506 		COPY_POS(&un->un_suspend_pos, &un->un_pos);
1507 
1508 
1509 		/*
1510 		 * Issue a zero write file fmk command to tell the drive to
1511 		 * flush any buffered tape marks
1512 		 */
1513 		(void) st_cmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD);
1514 
1515 		/*
1516 		 * Because not all tape drives correctly implement buffer
1517 		 * flushing with the zero write file fmk command, issue a
1518 		 * synchronous rewind command to force data flushing.
1519 		 * st_validate_tapemarks() will do a rewind during DDI_RESUME
1520 		 * anyway.
1521 		 */
1522 		(void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD);
1523 
1524 		/* stop any new operations */
1525 		un->un_pwr_mgmt = ST_PWR_SUSPENDED;
1526 		un->un_throttle = 0;
1527 
1528 		/*
1529 		 * cancel any outstanding timeouts
1530 		 */
1531 		if (un->un_delay_tid) {
1532 			timeout_id_t temp_id = un->un_delay_tid;
1533 			un->un_delay_tid = 0;
1534 			un->un_tids_at_suspend |= ST_DELAY_TID;
1535 			mutex_exit(ST_MUTEX);
1536 			(void) untimeout(temp_id);
1537 			mutex_enter(ST_MUTEX);
1538 		}
1539 
1540 		if (un->un_hib_tid) {
1541 			timeout_id_t temp_id = un->un_hib_tid;
1542 			un->un_hib_tid = 0;
1543 			un->un_tids_at_suspend |= ST_HIB_TID;
1544 			mutex_exit(ST_MUTEX);
1545 			(void) untimeout(temp_id);
1546 			mutex_enter(ST_MUTEX);
1547 		}
1548 
1549 		/*
1550 		 * Suspend the scsi_watch_thread
1551 		 */
1552 		if (un->un_swr_token) {
1553 			opaque_t temp_token = un->un_swr_token;
1554 			mutex_exit(ST_MUTEX);
1555 			scsi_watch_suspend(temp_token);
1556 		} else {
1557 			mutex_exit(ST_MUTEX);
1558 		}
1559 
1560 		return (DDI_SUCCESS);
1561 
1562 	default:
1563 		ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach failed\n");
1564 		return (DDI_FAILURE);
1565 	}
1566 }
1567 
1568 
1569 /* ARGSUSED */
1570 static int
1571 st_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
1572 {
1573 	dev_t dev;
1574 	struct scsi_tape *un;
1575 	int instance, error;
1576 
1577 	ST_ENTR(dip, st_info);
1578 
1579 	switch (infocmd) {
1580 	case DDI_INFO_DEVT2DEVINFO:
1581 		dev = (dev_t)arg;
1582 		instance = MTUNIT(dev);
1583 		if ((un = ddi_get_soft_state(st_state, instance)) == NULL)
1584 			return (DDI_FAILURE);
1585 		*result = (void *) ST_DEVINFO;
1586 		error = DDI_SUCCESS;
1587 		break;
1588 	case DDI_INFO_DEVT2INSTANCE:
1589 		dev = (dev_t)arg;
1590 		instance = MTUNIT(dev);
1591 		*result = (void *)(uintptr_t)instance;
1592 		error = DDI_SUCCESS;
1593 		break;
1594 	default:
1595 		error = DDI_FAILURE;
1596 	}
1597 	return (error);
1598 }
1599 
1600 static int
1601 st_doattach(struct scsi_device *devp, int (*canwait)())
1602 {
1603 	struct scsi_tape *un = NULL;
1604 	recov_info *ri;
1605 	int km_flags = (canwait != NULL_FUNC) ? KM_SLEEP : KM_NOSLEEP;
1606 	int instance;
1607 	size_t rlen;
1608 
1609 	ST_FUNC(devp->sd_dev, st_doattach);
1610 	/*
1611 	 * Call the routine scsi_probe to do some of the dirty work.
1612 	 * If the INQUIRY command succeeds, the field sd_inq in the
1613 	 * device structure will be filled in.
1614 	 */
1615 	ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1616 	    "st_doattach(): probing\n");
1617 
1618 	if (scsi_probe(devp, canwait) == SCSIPROBE_EXISTS) {
1619 
1620 		/*
1621 		 * In checking the whole inq_dtype byte we are looking at both
1622 		 * the Peripheral Qualifier and the Peripheral Device Type.
1623 		 * For this driver we are only interested in sequential devices
1624 		 * that are connected or capable if connecting to this logical
1625 		 * unit.
1626 		 */
1627 		if (devp->sd_inq->inq_dtype ==
1628 		    (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) {
1629 			ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1630 			    "probe exists\n");
1631 		} else {
1632 			/* Something there but not a tape device */
1633 			scsi_unprobe(devp);
1634 			return (DDI_FAILURE);
1635 		}
1636 	} else {
1637 		/* Nothing there */
1638 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1639 		    "probe failure: nothing there\n");
1640 		scsi_unprobe(devp);
1641 		return (DDI_FAILURE);
1642 	}
1643 
1644 
1645 	/*
1646 	 * The actual unit is present.
1647 	 * Now is the time to fill in the rest of our info..
1648 	 */
1649 	instance = ddi_get_instance(devp->sd_dev);
1650 
1651 	if (ddi_soft_state_zalloc(st_state, instance) != DDI_SUCCESS) {
1652 		goto error;
1653 	}
1654 	un = ddi_get_soft_state(st_state, instance);
1655 
1656 	ASSERT(un != NULL);
1657 
1658 	un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL,
1659 	    MAX_SENSE_LENGTH, B_READ, canwait, NULL);
1660 	if (un->un_rqs_bp == NULL) {
1661 		goto error;
1662 	}
1663 	un->un_rqs = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp,
1664 	    CDB_GROUP0, 1, st_recov_sz, PKT_CONSISTENT, canwait, NULL);
1665 	if (!un->un_rqs) {
1666 		goto error;
1667 	}
1668 	ASSERT(un->un_rqs->pkt_resid == 0);
1669 	devp->sd_sense =
1670 	    (struct scsi_extended_sense *)un->un_rqs_bp->b_un.b_addr;
1671 	ASSERT(geterror(un->un_rqs_bp) == NULL);
1672 
1673 	(void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs->pkt_cdbp,
1674 	    SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0);
1675 	FILL_SCSI1_LUN(devp, un->un_rqs);
1676 	un->un_rqs->pkt_flags |= (FLAG_SENSING | FLAG_HEAD | FLAG_NODISCON);
1677 	un->un_rqs->pkt_time = st_io_time;
1678 	un->un_rqs->pkt_comp = st_intr;
1679 	ri = (recov_info *)un->un_rqs->pkt_private;
1680 	if (st_recov_sz == sizeof (recov_info)) {
1681 		ri->privatelen = sizeof (recov_info);
1682 	} else {
1683 		ri->privatelen = sizeof (pkt_info);
1684 	}
1685 
1686 	un->un_sbufp = getrbuf(km_flags);
1687 	un->un_recov_buf = getrbuf(km_flags);
1688 
1689 	un->un_uscsi_rqs_buf = kmem_alloc(SENSE_LENGTH, KM_SLEEP);
1690 
1691 	/*
1692 	 * use i_ddi_mem_alloc() for now until we have an interface to allocate
1693 	 * memory for DMA which doesn't require a DMA handle.
1694 	 */
1695 	(void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr,
1696 	    sizeof (struct seq_mode), ((km_flags == KM_SLEEP) ? 1 : 0), 0,
1697 	    NULL, (caddr_t *)&un->un_mspl, &rlen, NULL);
1698 
1699 	(void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr,
1700 	    sizeof (read_pos_data_t), ((km_flags == KM_SLEEP) ? 1 : 0), 0,
1701 	    NULL, (caddr_t *)&un->un_read_pos_data, &rlen, NULL);
1702 
1703 	if (!un->un_sbufp || !un->un_mspl || !un->un_read_pos_data) {
1704 		ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG,
1705 		    "probe partial failure: no space\n");
1706 		goto error;
1707 	}
1708 
1709 	bzero(un->un_mspl, sizeof (struct seq_mode));
1710 
1711 	cv_init(&un->un_sbuf_cv, NULL, CV_DRIVER, NULL);
1712 	cv_init(&un->un_queue_cv, NULL, CV_DRIVER, NULL);
1713 	cv_init(&un->un_clscv, NULL, CV_DRIVER, NULL);
1714 	cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL);
1715 #ifdef	__x86
1716 	cv_init(&un->un_contig_mem_cv, NULL, CV_DRIVER, NULL);
1717 #endif
1718 
1719 	/* Initialize power managemnet condition variable */
1720 	cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL);
1721 	cv_init(&un->un_tape_busy_cv, NULL, CV_DRIVER, NULL);
1722 	cv_init(&un->un_recov_buf_cv, NULL, CV_DRIVER, NULL);
1723 
1724 	un->un_recov_taskq = ddi_taskq_create(devp->sd_dev,
1725 	    "un_recov_taskq", 1, TASKQ_DEFAULTPRI, km_flags);
1726 
1727 	ASSERT(un->un_recov_taskq != NULL);
1728 
1729 	un->un_pos.pmode = invalid;
1730 	un->un_sd	= devp;
1731 	un->un_swr_token = (opaque_t)NULL;
1732 	un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE;
1733 	un->un_wormable = st_is_drive_worm;
1734 	un->un_media_id_method = st_get_media_identification;
1735 	/*
1736 	 * setting long a initial as it contains logical file info.
1737 	 * support for long format is mandatory but many drive don't do it.
1738 	 */
1739 	un->un_read_pos_type = LONG_POS;
1740 
1741 	un->un_suspend_pos.pmode = invalid;
1742 
1743 	st_add_recovery_info_to_pkt(un, un->un_rqs_bp, un->un_rqs);
1744 
1745 #ifdef	__x86
1746 	if (ddi_dma_alloc_handle(ST_DEVINFO, &st_contig_mem_dma_attr,
1747 	    DDI_DMA_SLEEP, NULL, &un->un_contig_mem_hdl) != DDI_SUCCESS) {
1748 		ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG,
1749 		    "allocation of contiguous memory dma handle failed!");
1750 		un->un_contig_mem_hdl = NULL;
1751 		goto error;
1752 	}
1753 #endif
1754 
1755 	/*
1756 	 * Since this driver manages devices with "remote" hardware,
1757 	 * i.e. the devices themselves have no "reg" properties,
1758 	 * the SUSPEND/RESUME commands in detach/attach will not be
1759 	 * called by the power management framework unless we request
1760 	 * it by creating a "pm-hardware-state" property and setting it
1761 	 * to value "needs-suspend-resume".
1762 	 */
1763 	if (ddi_prop_update_string(DDI_DEV_T_NONE, devp->sd_dev,
1764 	    "pm-hardware-state", "needs-suspend-resume") !=
1765 	    DDI_PROP_SUCCESS) {
1766 
1767 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1768 		    "ddi_prop_update(\"pm-hardware-state\") failed\n");
1769 		goto error;
1770 	}
1771 
1772 	if (ddi_prop_create(DDI_DEV_T_NONE, devp->sd_dev, DDI_PROP_CANSLEEP,
1773 	    "no-involuntary-power-cycles", NULL, 0) != DDI_PROP_SUCCESS) {
1774 
1775 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1776 		    "ddi_prop_create(\"no-involuntary-power-cycles\") "
1777 		    "failed\n");
1778 		goto error;
1779 	}
1780 
1781 	(void) scsi_reset_notify(ROUTE, SCSI_RESET_NOTIFY,
1782 	    st_reset_notification, (caddr_t)un);
1783 
1784 	ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, "attach success\n");
1785 	return (DDI_SUCCESS);
1786 
1787 error:
1788 	devp->sd_sense = NULL;
1789 
1790 	ddi_remove_minor_node(devp->sd_dev, NULL);
1791 	if (un) {
1792 		if (un->un_mspl) {
1793 			i_ddi_mem_free((caddr_t)un->un_mspl, NULL);
1794 		}
1795 		if (un->un_read_pos_data) {
1796 			i_ddi_mem_free((caddr_t)un->un_read_pos_data, 0);
1797 		}
1798 		if (un->un_sbufp) {
1799 			freerbuf(un->un_sbufp);
1800 		}
1801 		if (un->un_recov_buf) {
1802 			freerbuf(un->un_recov_buf);
1803 		}
1804 		if (un->un_uscsi_rqs_buf) {
1805 			kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
1806 		}
1807 #ifdef	__x86
1808 		if (un->un_contig_mem_hdl != NULL) {
1809 			ddi_dma_free_handle(&un->un_contig_mem_hdl);
1810 		}
1811 #endif
1812 		if (un->un_rqs) {
1813 			scsi_destroy_pkt(un->un_rqs);
1814 		}
1815 
1816 		if (un->un_rqs_bp) {
1817 			scsi_free_consistent_buf(un->un_rqs_bp);
1818 		}
1819 
1820 		ddi_soft_state_free(st_state, instance);
1821 		devp->sd_private = NULL;
1822 	}
1823 
1824 	if (devp->sd_inq) {
1825 		scsi_unprobe(devp);
1826 	}
1827 	return (DDI_FAILURE);
1828 }
1829 
1830 typedef int
1831 (*cfg_functp)(struct scsi_tape *, char *vidpid, struct st_drivetype *);
1832 
1833 static cfg_functp config_functs[] = {
1834 	st_get_conf_from_st_dot_conf,
1835 	st_get_conf_from_st_conf_dot_c,
1836 	st_get_conf_from_tape_drive,
1837 	st_get_default_conf
1838 };
1839 
1840 
1841 /*
1842  * determine tape type, using tape-config-list or built-in table or
1843  * use a generic tape config entry
1844  */
1845 static void
1846 st_known_tape_type(struct scsi_tape *un)
1847 {
1848 	struct st_drivetype *dp;
1849 	cfg_functp *config_funct;
1850 	uchar_t reserved;
1851 
1852 	ST_FUNC(ST_DEVINFO, st_known_tape_type);
1853 
1854 	reserved = (un->un_rsvd_status & ST_RESERVE) ? ST_RESERVE
1855 	    : ST_RELEASE;
1856 
1857 	/*
1858 	 * XXX:  Emulex MT-02 (and emulators) predates SCSI-1 and has
1859 	 *	 no vid & pid inquiry data.  So, we provide one.
1860 	 */
1861 	if (ST_INQUIRY->inq_len == 0 ||
1862 	    (bcmp("\0\0\0\0\0\0\0\0", ST_INQUIRY->inq_vid, 8) == 0)) {
1863 		(void) strcpy((char *)ST_INQUIRY->inq_vid, ST_MT02_NAME);
1864 	}
1865 
1866 	if (un->un_dp_size == 0) {
1867 		un->un_dp_size = sizeof (struct st_drivetype);
1868 		dp = kmem_zalloc((size_t)un->un_dp_size, KM_SLEEP);
1869 		un->un_dp = dp;
1870 	} else {
1871 		dp = un->un_dp;
1872 	}
1873 
1874 	un->un_dp->non_motion_timeout = st_io_time;
1875 	/*
1876 	 * Loop through the configuration methods till one works.
1877 	 */
1878 	for (config_funct = &config_functs[0]; ; config_funct++) {
1879 		if ((*config_funct)(un, ST_INQUIRY->inq_vid, dp)) {
1880 			break;
1881 		}
1882 	}
1883 
1884 	/*
1885 	 * If we didn't just make up this configuration and
1886 	 * all the density codes are the same..
1887 	 * Set Auto Density over ride.
1888 	 */
1889 	if (*config_funct != st_get_default_conf) {
1890 		/*
1891 		 * If this device is one that is configured and all
1892 		 * densities are the same, This saves doing gets and set
1893 		 * that yield nothing.
1894 		 */
1895 		if ((dp->densities[0]) == (dp->densities[1]) &&
1896 		    (dp->densities[0]) == (dp->densities[2]) &&
1897 		    (dp->densities[0]) == (dp->densities[3])) {
1898 
1899 			dp->options |= ST_AUTODEN_OVERRIDE;
1900 		}
1901 	}
1902 
1903 
1904 	/*
1905 	 * Store tape drive characteristics.
1906 	 */
1907 	un->un_status = 0;
1908 	un->un_attached = 1;
1909 	un->un_init_options = dp->options;
1910 
1911 	/* setup operation time-outs based on options */
1912 	st_calculate_timeouts(un);
1913 
1914 	/* TLR support */
1915 	if (un->un_dp->type != ST_TYPE_INVALID) {
1916 		int result;
1917 
1918 		/* try and enable TLR */
1919 		un->un_tlr_flag = TLR_SAS_ONE_DEVICE;
1920 		result = st_set_target_TLR_mode(un, st_uscsi_cmd);
1921 		if (result == EACCES) {
1922 			/*
1923 			 * From attach command failed.
1924 			 * Set dp type so is run again on open.
1925 			 */
1926 			un->un_dp->type = ST_TYPE_INVALID;
1927 			un->un_tlr_flag = TLR_NOT_KNOWN;
1928 		} else if (result == 0) {
1929 			if (scsi_ifgetcap(&un->un_sd->sd_address,
1930 			    "tran-layer-retries", 1) == -1) {
1931 				un->un_tlr_flag = TLR_NOT_SUPPORTED;
1932 				(void) st_set_target_TLR_mode(un, st_uscsi_cmd);
1933 			} else {
1934 				un->un_tlr_flag = TLR_SAS_ONE_DEVICE;
1935 			}
1936 		} else {
1937 			un->un_tlr_flag = TLR_NOT_SUPPORTED;
1938 		}
1939 	}
1940 
1941 	/* make sure if we are supposed to be variable, make it variable */
1942 	if (dp->options & ST_VARIABLE) {
1943 		dp->bsize = 0;
1944 	}
1945 
1946 	if (reserved != ((un->un_rsvd_status & ST_RESERVE) ? ST_RESERVE
1947 	    : ST_RELEASE)) {
1948 		(void) st_reserve_release(un, reserved, st_uscsi_cmd);
1949 	}
1950 
1951 	un->un_unit_attention_flags |= 1;
1952 
1953 	scsi_log(ST_DEVINFO, st_label, CE_NOTE, "?<%s>\n", dp->name);
1954 
1955 }
1956 
1957 
1958 typedef struct {
1959 	int mask;
1960 	int bottom;
1961 	int top;
1962 	char *name;
1963 } conf_limit;
1964 
1965 static const conf_limit conf_limits[] = {
1966 
1967 	-1,		1,		2,		"conf version",
1968 	-1,		MT_ISTS,	ST_LAST_TYPE,	"drive type",
1969 	-1,		0,		0xffffff,	"block size",
1970 	ST_VALID_OPTS,	0,		ST_VALID_OPTS,	"options",
1971 	-1,		0,		4,		"number of densities",
1972 	-1,		0,		UINT8_MAX,	"density code",
1973 	-1,		0,		3,		"default density",
1974 	-1,		0,		UINT16_MAX,	"non motion timeout",
1975 	-1,		0,		UINT16_MAX,	"I/O timeout",
1976 	-1,		0,		UINT16_MAX,	"space timeout",
1977 	-1,		0,		UINT16_MAX,	"load timeout",
1978 	-1,		0,		UINT16_MAX,	"unload timeout",
1979 	-1,		0,		UINT16_MAX,	"erase timeout",
1980 	0,		0,		0,		NULL
1981 };
1982 
1983 static int
1984 st_validate_conf_data(struct scsi_tape *un, int *list, int list_len,
1985     const char *conf_name)
1986 {
1987 	int dens;
1988 	int ndens;
1989 	int value;
1990 	int type;
1991 	int count;
1992 	const conf_limit *limit = &conf_limits[0];
1993 
1994 	ST_FUNC(ST_DEVINFO, st_validate_conf_data);
1995 
1996 	ST_DEBUG3(ST_DEVINFO, st_label, CE_NOTE,
1997 	    "Checking %d entrys total with %d densities\n", list_len, list[4]);
1998 
1999 	count = list_len;
2000 	type = *list;
2001 	for (;  count && limit->name; count--, list++, limit++) {
2002 
2003 		value = *list;
2004 		if (value & ~limit->mask) {
2005 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2006 			    "%s %s value invalid bits set: 0x%X\n",
2007 			    conf_name, limit->name, value & ~limit->mask);
2008 			*list &= limit->mask;
2009 		} else if (value < limit->bottom) {
2010 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2011 			    "%s %s value too low: value = %d limit %d\n",
2012 			    conf_name, limit->name, value, limit->bottom);
2013 		} else if (value > limit->top) {
2014 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2015 			    "%s %s value too high: value = %d limit %d\n",
2016 			    conf_name, limit->name, value, limit->top);
2017 		} else {
2018 			ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT,
2019 			    "%s %s value = 0x%X\n",
2020 			    conf_name, limit->name, value);
2021 		}
2022 
2023 		/* If not the number of densities continue */
2024 		if (limit != &conf_limits[4]) {
2025 			continue;
2026 		}
2027 
2028 		/* If number of densities is not in range can't use config */
2029 		if (value < limit->bottom || value > limit->top) {
2030 			return (-1);
2031 		}
2032 
2033 		ndens = min(value, NDENSITIES);
2034 		if ((type == 1) && (list_len - ndens) != 6) {
2035 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2036 			    "%s conf version 1 with %d densities has %d items"
2037 			    " should have %d",
2038 			    conf_name, ndens, list_len, 6 + ndens);
2039 		} else if ((type == 2) && (list_len - ndens) != 13) {
2040 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2041 			    "%s conf version 2 with %d densities has %d items"
2042 			    " should have %d",
2043 			    conf_name, ndens, list_len, 13 + ndens);
2044 		}
2045 
2046 		limit++;
2047 		for (dens = 0; dens < ndens && count; dens++) {
2048 			count--;
2049 			list++;
2050 			value = *list;
2051 			if (value < limit->bottom) {
2052 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2053 				    "%s density[%d] value too low: value ="
2054 				    " 0x%X limit 0x%X\n",
2055 				    conf_name, dens, value, limit->bottom);
2056 			} else if (value > limit->top) {
2057 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2058 				    "%s density[%d] value too high: value ="
2059 				    " 0x%X limit 0x%X\n",
2060 				    conf_name, dens, value, limit->top);
2061 			} else {
2062 				ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT,
2063 				    "%s density[%d] value = 0x%X\n",
2064 				    conf_name, dens, value);
2065 			}
2066 		}
2067 	}
2068 
2069 	return (0);
2070 }
2071 
2072 static int
2073 st_get_conf_from_st_dot_conf(struct scsi_tape *un, char *vidpid,
2074     struct st_drivetype *dp)
2075 {
2076 	caddr_t config_list = NULL;
2077 	caddr_t data_list = NULL;
2078 	int	*data_ptr;
2079 	caddr_t vidptr, prettyptr, datanameptr;
2080 	size_t	vidlen, prettylen, datanamelen, tripletlen = 0;
2081 	int config_list_len, data_list_len, len, i;
2082 	int version;
2083 	int found = 0;
2084 
2085 	ST_FUNC(ST_DEVINFO, st_get_conf_from_st_dot_conf);
2086 
2087 	/*
2088 	 * Determine type of tape controller. Type is determined by
2089 	 * checking the vendor ids of the earlier inquiry command and
2090 	 * comparing those with vids in tape-config-list defined in st.conf
2091 	 */
2092 	if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, DDI_PROP_DONTPASS,
2093 	    "tape-config-list", (caddr_t)&config_list, &config_list_len)
2094 	    != DDI_PROP_SUCCESS) {
2095 		return (found);
2096 	}
2097 
2098 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2099 	    "st_get_conf_from_st_dot_conf(): st.conf has tape-config-list\n");
2100 
2101 	/*
2102 	 * Compare vids in each triplet - if it matches, get value for
2103 	 * data_name and contruct a st_drivetype struct
2104 	 * tripletlen is not set yet!
2105 	 */
2106 	for (len = config_list_len, vidptr = config_list;
2107 	    len > 0;
2108 	    vidptr += tripletlen, len -= tripletlen) {
2109 
2110 		vidlen = strlen(vidptr);
2111 		prettyptr = vidptr + vidlen + 1;
2112 		prettylen = strlen(prettyptr);
2113 		datanameptr = prettyptr + prettylen + 1;
2114 		datanamelen = strlen(datanameptr);
2115 		tripletlen = vidlen + prettylen + datanamelen + 3;
2116 
2117 		if (vidlen == 0) {
2118 			continue;
2119 		}
2120 
2121 		/*
2122 		 * If inquiry vid dosen't match this triplets vid,
2123 		 * try the next.
2124 		 */
2125 		if (strncasecmp(vidpid, vidptr, vidlen)) {
2126 			continue;
2127 		}
2128 
2129 		/*
2130 		 * if prettylen is zero then use the vid string
2131 		 */
2132 		if (prettylen == 0) {
2133 			prettyptr = vidptr;
2134 			prettylen = vidlen;
2135 		}
2136 
2137 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2138 		    "vid = %s, pretty=%s, dataname = %s\n",
2139 		    vidptr, prettyptr, datanameptr);
2140 
2141 		/*
2142 		 * get the data list
2143 		 */
2144 		if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, 0,
2145 		    datanameptr, (caddr_t)&data_list,
2146 		    &data_list_len) != DDI_PROP_SUCCESS) {
2147 			/*
2148 			 * Error in getting property value
2149 			 * print warning!
2150 			 */
2151 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
2152 			    "data property (%s) has no value\n",
2153 			    datanameptr);
2154 			continue;
2155 		}
2156 
2157 		/*
2158 		 * now initialize the st_drivetype struct
2159 		 */
2160 		(void) strncpy(dp->name, prettyptr, ST_NAMESIZE - 1);
2161 		dp->length = (int)min(vidlen, (VIDPIDLEN - 1));
2162 		(void) strncpy(dp->vid, vidptr, dp->length);
2163 		data_ptr = (int *)data_list;
2164 		/*
2165 		 * check if data is enough for version, type,
2166 		 * bsize, options, # of densities, density1,
2167 		 * density2, ..., default_density
2168 		 */
2169 		if ((data_list_len < 5 * sizeof (int)) ||
2170 		    (data_list_len < 6 * sizeof (int) +
2171 		    *(data_ptr + 4) * sizeof (int))) {
2172 			/*
2173 			 * print warning and skip to next triplet.
2174 			 */
2175 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
2176 			    "data property (%s) incomplete\n",
2177 			    datanameptr);
2178 			kmem_free(data_list, data_list_len);
2179 			continue;
2180 		}
2181 
2182 		if (st_validate_conf_data(un, data_ptr,
2183 		    data_list_len / sizeof (int), datanameptr)) {
2184 			kmem_free(data_list, data_list_len);
2185 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
2186 			    "data property (%s) rejected\n",
2187 			    datanameptr);
2188 			continue;
2189 		}
2190 
2191 		/*
2192 		 * check version
2193 		 */
2194 		version = *data_ptr++;
2195 		if (version != 1 && version != 2) {
2196 			/* print warning but accept it */
2197 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
2198 			    "Version # for data property (%s) "
2199 			    "not set to 1 or 2\n", datanameptr);
2200 		}
2201 
2202 		dp->type    = *data_ptr++;
2203 		dp->bsize   = *data_ptr++;
2204 		dp->options = *data_ptr++;
2205 		dp->options |= ST_DYNAMIC;
2206 		len = *data_ptr++;
2207 		for (i = 0; i < NDENSITIES; i++) {
2208 			if (i < len) {
2209 				dp->densities[i] = *data_ptr++;
2210 			}
2211 		}
2212 		dp->default_density = *data_ptr << 3;
2213 		if (version == 2 &&
2214 		    data_list_len >= (13 + len) * sizeof (int)) {
2215 			data_ptr++;
2216 			dp->non_motion_timeout	= *data_ptr++;
2217 			dp->io_timeout		= *data_ptr++;
2218 			dp->rewind_timeout	= *data_ptr++;
2219 			dp->space_timeout	= *data_ptr++;
2220 			dp->load_timeout	= *data_ptr++;
2221 			dp->unload_timeout	= *data_ptr++;
2222 			dp->erase_timeout	= *data_ptr++;
2223 		}
2224 		kmem_free(data_list, data_list_len);
2225 		found = 1;
2226 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2227 		    "found in st.conf: vid = %s, pretty=%s\n",
2228 		    dp->vid, dp->name);
2229 		break;
2230 	}
2231 
2232 	/*
2233 	 * free up the memory allocated by ddi_getlongprop
2234 	 */
2235 	if (config_list) {
2236 		kmem_free(config_list, config_list_len);
2237 	}
2238 	return (found);
2239 }
2240 
2241 static int
2242 st_get_conf_from_st_conf_dot_c(struct scsi_tape *un, char *vidpid,
2243     struct st_drivetype *dp)
2244 {
2245 	int i;
2246 
2247 	ST_FUNC(ST_DEVINFO, st_get_conf_from_st_conf_dot_c);
2248 	/*
2249 	 * Determine type of tape controller.  Type is determined by
2250 	 * checking the result of the earlier inquiry command and
2251 	 * comparing vendor ids with strings in a table declared in st_conf.c.
2252 	 */
2253 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2254 	    "st_get_conf_from_st_conf_dot_c(): looking at st_drivetypes\n");
2255 
2256 	for (i = 0; i < st_ndrivetypes; i++) {
2257 		if (st_drivetypes[i].length == 0) {
2258 			continue;
2259 		}
2260 		if (strncasecmp(vidpid, st_drivetypes[i].vid,
2261 		    st_drivetypes[i].length)) {
2262 			continue;
2263 		}
2264 		bcopy(&st_drivetypes[i], dp, sizeof (st_drivetypes[i]));
2265 		return (1);
2266 	}
2267 	return (0);
2268 }
2269 
2270 static int
2271 st_get_conf_from_tape_drive(struct scsi_tape *un, char *vidpid,
2272     struct st_drivetype *dp)
2273 {
2274 	int bsize;
2275 	ulong_t maxbsize;
2276 	caddr_t buf;
2277 	struct st_drivetype *tem_dp;
2278 	struct read_blklim *blklim;
2279 	int rval;
2280 	int i;
2281 
2282 	ST_FUNC(ST_DEVINFO, st_get_conf_from_tape_drive);
2283 
2284 	/*
2285 	 * Determine the type of tape controller. Type is determined by
2286 	 * sending SCSI commands to tape drive and deriving the type from
2287 	 * the returned data.
2288 	 */
2289 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2290 	    "st_get_conf_from_tape_drive(): asking tape drive\n");
2291 
2292 	tem_dp = kmem_zalloc(sizeof (struct st_drivetype), KM_SLEEP);
2293 
2294 	/*
2295 	 * Make up a name
2296 	 */
2297 	bcopy(vidpid, tem_dp->name, VIDPIDLEN);
2298 	tem_dp->name[VIDPIDLEN] = '\0';
2299 	tem_dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1));
2300 	(void) strncpy(tem_dp->vid, ST_INQUIRY->inq_vid, tem_dp->length);
2301 	/*
2302 	 * 'clean' vendor and product strings of non-printing chars
2303 	 */
2304 	for (i = 0; i < VIDPIDLEN - 1; i ++) {
2305 		if (tem_dp->name[i] < ' ' || tem_dp->name[i] > '~') {
2306 			tem_dp->name[i] = '.';
2307 		}
2308 	}
2309 
2310 	/*
2311 	 * MODE SENSE to determine block size.
2312 	 */
2313 	un->un_dp->options |= ST_MODE_SEL_COMP | ST_UNLOADABLE;
2314 	rval = st_modesense(un);
2315 	if (rval) {
2316 		if (rval == EACCES) {
2317 			un->un_dp->type = ST_TYPE_INVALID;
2318 			rval = 1;
2319 		} else {
2320 			un->un_dp->options &= ~ST_MODE_SEL_COMP;
2321 			rval = 0;
2322 		}
2323 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2324 		    "st_get_conf_from_tape_drive(): fail to mode sense\n");
2325 		goto exit;
2326 	}
2327 
2328 	/* Can mode sense page 0x10 or 0xf */
2329 	tem_dp->options |= ST_MODE_SEL_COMP;
2330 	bsize = (un->un_mspl->high_bl << 16)	|
2331 	    (un->un_mspl->mid_bl << 8)		|
2332 	    (un->un_mspl->low_bl);
2333 
2334 	if (bsize == 0) {
2335 		tem_dp->options |= ST_VARIABLE;
2336 		tem_dp->bsize = 0;
2337 	} else if (bsize > ST_MAXRECSIZE_FIXED) {
2338 		rval = st_change_block_size(un, 0);
2339 		if (rval) {
2340 			if (rval == EACCES) {
2341 				un->un_dp->type = ST_TYPE_INVALID;
2342 				rval = 1;
2343 			} else {
2344 				rval = 0;
2345 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2346 				    "st_get_conf_from_tape_drive(): "
2347 				    "Fixed record size is too large and"
2348 				    "cannot switch to variable record size");
2349 			}
2350 			goto exit;
2351 		}
2352 		tem_dp->options |= ST_VARIABLE;
2353 	} else {
2354 		rval = st_change_block_size(un, 0);
2355 		if (rval == 0) {
2356 			tem_dp->options |= ST_VARIABLE;
2357 			tem_dp->bsize = 0;
2358 		} else if (rval != EACCES) {
2359 			tem_dp->bsize = bsize;
2360 		} else {
2361 			un->un_dp->type = ST_TYPE_INVALID;
2362 			rval = 1;
2363 			goto exit;
2364 		}
2365 	}
2366 
2367 	/*
2368 	 * If READ BLOCk LIMITS works and upper block size limit is
2369 	 * more than 64K, ST_NO_RECSIZE_LIMIT is supported.
2370 	 */
2371 	blklim = kmem_zalloc(sizeof (struct read_blklim), KM_SLEEP);
2372 	rval = st_read_block_limits(un, blklim);
2373 	if (rval) {
2374 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2375 		    "st_get_conf_from_tape_drive(): "
2376 		    "fail to read block limits.\n");
2377 		rval = 0;
2378 		kmem_free(blklim, sizeof (struct read_blklim));
2379 		goto exit;
2380 	}
2381 	maxbsize = (blklim->max_hi << 16) +
2382 	    (blklim->max_mid << 8) + blklim->max_lo;
2383 	if (maxbsize > ST_MAXRECSIZE_VARIABLE) {
2384 		tem_dp->options |= ST_NO_RECSIZE_LIMIT;
2385 	}
2386 	kmem_free(blklim, sizeof (struct read_blklim));
2387 
2388 	/*
2389 	 * Inquiry VPD page 0xb0 to see if the tape drive supports WORM
2390 	 */
2391 	buf = kmem_zalloc(6, KM_SLEEP);
2392 	rval = st_get_special_inquiry(un, 6, buf, 0xb0);
2393 	if (rval) {
2394 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2395 		    "st_get_conf_from_tape_drive(): "
2396 		    "fail to read vitial inquiry.\n");
2397 		rval = 0;
2398 		kmem_free(buf, 6);
2399 		goto exit;
2400 	}
2401 	if (buf[4] & 1) {
2402 		tem_dp->options |= ST_WORMABLE;
2403 	}
2404 	kmem_free(buf, 6);
2405 
2406 	/* Assume BSD BSR KNOWS_EOD */
2407 	tem_dp->options |= ST_BSF | ST_BSR | ST_KNOWS_EOD | ST_UNLOADABLE;
2408 	tem_dp->max_rretries = -1;
2409 	tem_dp->max_wretries = -1;
2410 
2411 	/*
2412 	 * Decide the densities supported by tape drive by sending
2413 	 * REPORT DENSITY SUPPORT command.
2414 	 */
2415 	if (st_get_densities_from_tape_drive(un, tem_dp) == 0) {
2416 		goto exit;
2417 	}
2418 
2419 	/*
2420 	 * Decide the timeout values for several commands by sending
2421 	 * REPORT SUPPORTED OPERATION CODES command.
2422 	 */
2423 	rval = st_get_timeout_values_from_tape_drive(un, tem_dp);
2424 	if (rval == 0 || ((rval == 1) && (tem_dp->type == ST_TYPE_INVALID))) {
2425 		goto exit;
2426 	}
2427 
2428 	bcopy(tem_dp, dp, sizeof (struct st_drivetype));
2429 	rval = 1;
2430 
2431 exit:
2432 	un->un_status = KEY_NO_SENSE;
2433 	kmem_free(tem_dp, sizeof (struct st_drivetype));
2434 	return (rval);
2435 }
2436 
2437 static int
2438 st_get_densities_from_tape_drive(struct scsi_tape *un,
2439     struct st_drivetype *dp)
2440 {
2441 	int i, p;
2442 	size_t buflen;
2443 	ushort_t des_len;
2444 	uchar_t *den_header;
2445 	uchar_t num_den;
2446 	uchar_t den[NDENSITIES];
2447 	uchar_t deflt[NDENSITIES];
2448 	struct report_density_desc *den_desc;
2449 
2450 	ST_FUNC(ST_DEVINFO, st_get_densities_from_type_drive);
2451 
2452 	/*
2453 	 * Since we have no idea how many densitiy support entries
2454 	 * will be returned, we send the command firstly assuming
2455 	 * there is only one. Then we can decide the number of
2456 	 * entries by available density support length. If multiple
2457 	 * entries exist, we will resend the command with enough
2458 	 * buffer size.
2459 	 */
2460 	buflen = sizeof (struct report_density_header) +
2461 	    sizeof (struct report_density_desc);
2462 	den_header = kmem_zalloc(buflen, KM_SLEEP);
2463 	if (st_report_density_support(un, den_header, buflen) != 0) {
2464 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2465 		    "st_get_conf_from_tape_drive(): fail to report density.\n");
2466 		kmem_free(den_header, buflen);
2467 		return (0);
2468 	}
2469 	des_len =
2470 	    BE_16(((struct report_density_header *)den_header)->ava_dens_len);
2471 	num_den = (des_len - 2) / sizeof (struct report_density_desc);
2472 
2473 	if (num_den > 1) {
2474 		kmem_free(den_header, buflen);
2475 		buflen = sizeof (struct report_density_header) +
2476 		    sizeof (struct report_density_desc) * num_den;
2477 		den_header = kmem_zalloc(buflen, KM_SLEEP);
2478 		if (st_report_density_support(un, den_header, buflen) != 0) {
2479 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2480 			    "st_get_conf_from_tape_drive(): "
2481 			    "fail to report density.\n");
2482 			kmem_free(den_header, buflen);
2483 			return (0);
2484 		}
2485 	}
2486 
2487 	den_desc = (struct report_density_desc *)(den_header
2488 	    + sizeof (struct report_density_header));
2489 
2490 	/*
2491 	 * Decide the drive type by assigning organization
2492 	 */
2493 	for (i = 0; i < ST_NUM_MEMBERS(st_vid_dt); i ++) {
2494 		if (strncmp(st_vid_dt[i].vid, (char *)(den_desc->ass_org),
2495 		    8) == 0) {
2496 			dp->type = st_vid_dt[i].type;
2497 			break;
2498 		}
2499 	}
2500 	if (i == ST_NUM_MEMBERS(st_vid_dt)) {
2501 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2502 		    "st_get_conf_from_tape_drive(): "
2503 		    "can't find match of assigned ort.\n");
2504 		kmem_free(den_header, buflen);
2505 		return (0);
2506 	}
2507 
2508 	/*
2509 	 * The tape drive may support many tape formats, but the st driver
2510 	 * supports only the four highest densities. Since density code
2511 	 * values are returned by ascending sequence, we start from the
2512 	 * last entry of density support data block descriptor.
2513 	 */
2514 	p = 0;
2515 	den_desc += num_den - 1;
2516 	for (i = 0; i < num_den && p < NDENSITIES; i ++, den_desc --) {
2517 		if ((den_desc->pri_den != 0) && (den_desc->wrtok)) {
2518 			if (p != 0) {
2519 				if (den_desc->pri_den >= den[p - 1]) {
2520 					continue;
2521 				}
2522 			}
2523 			den[p] = den_desc->pri_den;
2524 			deflt[p] = den_desc->deflt;
2525 			p ++;
2526 		}
2527 	}
2528 
2529 	switch (p) {
2530 	case 0:
2531 		bzero(dp->densities, NDENSITIES);
2532 		dp->options |= ST_AUTODEN_OVERRIDE;
2533 		dp->default_density = MT_DENSITY4;
2534 		break;
2535 
2536 	case 1:
2537 		(void) memset(dp->densities, den[0], NDENSITIES);
2538 		dp->options |= ST_AUTODEN_OVERRIDE;
2539 		dp->default_density = MT_DENSITY4;
2540 		break;
2541 
2542 	case 2:
2543 		dp->densities[0] = den[1];
2544 		dp->densities[1] = den[1];
2545 		dp->densities[2] = den[0];
2546 		dp->densities[3] = den[0];
2547 		if (deflt[0]) {
2548 			dp->default_density = MT_DENSITY4;
2549 		} else {
2550 			dp->default_density = MT_DENSITY2;
2551 		}
2552 		break;
2553 
2554 	case 3:
2555 		dp->densities[0] = den[2];
2556 		dp->densities[1] = den[1];
2557 		dp->densities[2] = den[0];
2558 		dp->densities[3] = den[0];
2559 		if (deflt[0]) {
2560 			dp->default_density = MT_DENSITY4;
2561 		} else if (deflt[1]) {
2562 			dp->default_density = MT_DENSITY2;
2563 		} else {
2564 			dp->default_density = MT_DENSITY1;
2565 		}
2566 		break;
2567 
2568 	default:
2569 		for (i = p; i > p - NDENSITIES; i --) {
2570 			dp->densities[i - 1] = den[p - i];
2571 		}
2572 		if (deflt[0]) {
2573 			dp->default_density = MT_DENSITY4;
2574 		} else if (deflt[1]) {
2575 			dp->default_density = MT_DENSITY3;
2576 		} else if (deflt[2]) {
2577 			dp->default_density = MT_DENSITY2;
2578 		} else {
2579 			dp->default_density = MT_DENSITY1;
2580 		}
2581 		break;
2582 	}
2583 
2584 	bzero(dp->mediatype, NDENSITIES);
2585 
2586 	kmem_free(den_header, buflen);
2587 	return (1);
2588 }
2589 
2590 static int
2591 st_get_timeout_values_from_tape_drive(struct scsi_tape *un,
2592     struct st_drivetype *dp)
2593 {
2594 	ushort_t timeout;
2595 	int rval;
2596 
2597 	ST_FUNC(ST_DEVINFO, st_get_timeout_values_from_type_drive);
2598 
2599 	rval = st_get_timeouts_value(un, SCMD_ERASE, &timeout, 0);
2600 	if (rval) {
2601 		if (rval == EACCES) {
2602 			un->un_dp->type = ST_TYPE_INVALID;
2603 			dp->type = ST_TYPE_INVALID;
2604 			return (1);
2605 		}
2606 		return (0);
2607 	}
2608 	dp->erase_timeout = timeout;
2609 
2610 	rval = st_get_timeouts_value(un, SCMD_READ, &timeout, 0);
2611 	if (rval) {
2612 		if (rval == EACCES) {
2613 			un->un_dp->type = ST_TYPE_INVALID;
2614 			dp->type = ST_TYPE_INVALID;
2615 			return (1);
2616 		}
2617 		return (0);
2618 	}
2619 	dp->io_timeout = timeout;
2620 
2621 	rval = st_get_timeouts_value(un, SCMD_WRITE, &timeout, 0);
2622 	if (rval) {
2623 		if (rval == EACCES) {
2624 			un->un_dp->type = ST_TYPE_INVALID;
2625 			dp->type = ST_TYPE_INVALID;
2626 			return (1);
2627 		}
2628 		return (0);
2629 	}
2630 	dp->io_timeout = max(dp->io_timeout, timeout);
2631 
2632 	rval = st_get_timeouts_value(un, SCMD_SPACE, &timeout, 0);
2633 	if (rval) {
2634 		if (rval == EACCES) {
2635 			un->un_dp->type = ST_TYPE_INVALID;
2636 			dp->type = ST_TYPE_INVALID;
2637 			return (1);
2638 		}
2639 		return (0);
2640 	}
2641 	dp->space_timeout = timeout;
2642 
2643 	rval = st_get_timeouts_value(un, SCMD_LOAD, &timeout, 0);
2644 	if (rval) {
2645 		if (rval == EACCES) {
2646 			un->un_dp->type = ST_TYPE_INVALID;
2647 			dp->type = ST_TYPE_INVALID;
2648 			return (1);
2649 		}
2650 		return (0);
2651 	}
2652 	dp->load_timeout = timeout;
2653 	dp->unload_timeout = timeout;
2654 
2655 	rval = st_get_timeouts_value(un, SCMD_REWIND, &timeout, 0);
2656 	if (rval) {
2657 		if (rval == EACCES) {
2658 			un->un_dp->type = ST_TYPE_INVALID;
2659 			dp->type = ST_TYPE_INVALID;
2660 			return (1);
2661 		}
2662 		return (0);
2663 	}
2664 	dp->rewind_timeout = timeout;
2665 
2666 	rval = st_get_timeouts_value(un, SCMD_INQUIRY, &timeout, 0);
2667 	if (rval) {
2668 		if (rval == EACCES) {
2669 			un->un_dp->type = ST_TYPE_INVALID;
2670 			dp->type = ST_TYPE_INVALID;
2671 			return (1);
2672 		}
2673 		return (0);
2674 	}
2675 	dp->non_motion_timeout = timeout;
2676 
2677 	return (1);
2678 }
2679 
2680 static int
2681 st_get_timeouts_value(struct scsi_tape *un, uchar_t option_code,
2682     ushort_t *timeout_value, ushort_t service_action)
2683 {
2684 	uchar_t *timeouts;
2685 	uchar_t *oper;
2686 	uchar_t support;
2687 	uchar_t cdbsize;
2688 	uchar_t ctdp;
2689 	size_t buflen;
2690 	int rval;
2691 
2692 	ST_FUNC(ST_DEVINFO, st_get_timeouts_value);
2693 
2694 	buflen = sizeof (struct one_com_des) +
2695 	    sizeof (struct com_timeout_des);
2696 	oper = kmem_zalloc(buflen, KM_SLEEP);
2697 	rval = st_report_supported_operation(un, oper, option_code,
2698 	    service_action);
2699 
2700 	if (rval) {
2701 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2702 		    "st_get_timeouts_value(): "
2703 		    "fail to timeouts value for command %d.\n", option_code);
2704 		kmem_free(oper, buflen);
2705 		return (rval);
2706 	}
2707 
2708 	support = ((struct one_com_des *)oper)->support;
2709 	if ((support != SUPPORT_VALUES_SUPPORT_SCSI) &&
2710 	    (support != SUPPORT_VALUES_SUPPORT_VENDOR)) {
2711 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2712 		    "st_get_timeouts_value(): "
2713 		    "command %d is not supported.\n", option_code);
2714 		kmem_free(oper, buflen);
2715 		return (ENOTSUP);
2716 	}
2717 
2718 	ctdp = ((struct one_com_des *)oper)->ctdp;
2719 	if (!ctdp) {
2720 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2721 		    "st_get_timeouts_value(): "
2722 		    "command timeout is not included.\n");
2723 		kmem_free(oper, buflen);
2724 		return (ENOTSUP);
2725 	}
2726 
2727 	cdbsize = BE_16(((struct one_com_des *)oper)->cdb_size);
2728 	timeouts = (uchar_t *)(oper + cdbsize + 4);
2729 
2730 	/*
2731 	 * Timeout value in seconds is 4 bytes, but we only support the lower 2
2732 	 * bytes. If the higher 2 bytes are not zero, the timeout value is set
2733 	 * to 0xFFFF.
2734 	 */
2735 	if (*(timeouts + 8) != 0 || *(timeouts + 9) != 0) {
2736 		*timeout_value = USHRT_MAX;
2737 	} else {
2738 		*timeout_value = ((*(timeouts + 10)) << 8) |
2739 		    (*(timeouts + 11));
2740 	}
2741 
2742 	kmem_free(oper, buflen);
2743 	return (0);
2744 }
2745 
2746 static int
2747 st_get_default_conf(struct scsi_tape *un, char *vidpid, struct st_drivetype *dp)
2748 {
2749 	int i;
2750 
2751 	ST_FUNC(ST_DEVINFO, st_get_default_conf);
2752 
2753 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2754 	    "st_get_default_conf(): making drivetype from INQ cmd\n");
2755 
2756 	/*
2757 	 * Make up a name
2758 	 */
2759 	bcopy("Vendor '", dp->name, 8);
2760 	bcopy(vidpid, &dp->name[8], VIDLEN);
2761 	bcopy("' Product '", &dp->name[16], 11);
2762 	bcopy(&vidpid[8], &dp->name[27], PIDLEN);
2763 	dp->name[ST_NAMESIZE - 2] = '\'';
2764 	dp->name[ST_NAMESIZE - 1] = '\0';
2765 	dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1));
2766 	(void) strncpy(dp->vid, ST_INQUIRY->inq_vid, dp->length);
2767 	/*
2768 	 * 'clean' vendor and product strings of non-printing chars
2769 	 */
2770 	for (i = 0; i < ST_NAMESIZE - 2; i++) {
2771 		if (dp->name[i] < ' ' || dp->name[i] > '~') {
2772 			dp->name[i] = '.';
2773 		}
2774 	}
2775 	dp->type = ST_TYPE_INVALID;
2776 	dp->options |= (ST_DYNAMIC | ST_UNLOADABLE | ST_MODE_SEL_COMP);
2777 
2778 	return (1); /* Can Not Fail */
2779 }
2780 
2781 /*
2782  * Regular Unix Entry points
2783  */
2784 
2785 
2786 
2787 /* ARGSUSED */
2788 static int
2789 st_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
2790 {
2791 	dev_t dev = *dev_p;
2792 	int rval = 0;
2793 
2794 	GET_SOFT_STATE(dev);
2795 
2796 	ST_ENTR(ST_DEVINFO, st_open);
2797 
2798 	/*
2799 	 * validate that we are addressing a sensible unit
2800 	 */
2801 	mutex_enter(ST_MUTEX);
2802 
2803 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2804 	    "st_open(node = %s dev = 0x%lx, flag = %d, otyp = %d)\n",
2805 	    st_dev_name(dev), *dev_p, flag, otyp);
2806 
2807 	/*
2808 	 * All device accesss go thru st_strategy() where we check
2809 	 * suspend status
2810 	 */
2811 
2812 	if (!un->un_attached) {
2813 		st_known_tape_type(un);
2814 		if (!un->un_attached) {
2815 			rval = ENXIO;
2816 			goto exit;
2817 		}
2818 
2819 	}
2820 
2821 	/*
2822 	 * Check for the case of the tape in the middle of closing.
2823 	 * This isn't simply a check of the current state, because
2824 	 * we could be in state of sensing with the previous state
2825 	 * that of closing.
2826 	 *
2827 	 * And don't allow multiple opens.
2828 	 */
2829 	if (!(flag & (FNDELAY | FNONBLOCK)) && IS_CLOSING(un)) {
2830 		un->un_laststate = un->un_state;
2831 		un->un_state = ST_STATE_CLOSE_PENDING_OPEN;
2832 		while (IS_CLOSING(un) ||
2833 		    un->un_state == ST_STATE_CLOSE_PENDING_OPEN) {
2834 			if (cv_wait_sig(&un->un_clscv, ST_MUTEX) == 0) {
2835 				rval = EINTR;
2836 				un->un_state = un->un_laststate;
2837 				goto exit;
2838 			}
2839 		}
2840 	} else if (un->un_state != ST_STATE_CLOSED) {
2841 		rval = EBUSY;
2842 		goto busy;
2843 	}
2844 
2845 	/*
2846 	 * record current dev
2847 	 */
2848 	un->un_dev = dev;
2849 	un->un_oflags = flag;	/* save for use in st_tape_init() */
2850 	un->un_errno = 0;	/* no errors yet */
2851 	un->un_restore_pos = 0;
2852 	un->un_rqs_state = 0;
2853 
2854 	/*
2855 	 * If we are opening O_NDELAY, or O_NONBLOCK, we don't check for
2856 	 * anything, leave internal states alone, if fileno >= 0
2857 	 */
2858 	if (flag & (FNDELAY | FNONBLOCK)) {
2859 		switch (un->un_pos.pmode) {
2860 
2861 		case invalid:
2862 			un->un_state = ST_STATE_OFFLINE;
2863 			break;
2864 
2865 		case legacy:
2866 			/*
2867 			 * If position is anything other than rewound.
2868 			 */
2869 			if (un->un_pos.fileno != 0 || un->un_pos.blkno != 0) {
2870 				/*
2871 				 * set un_read_only/write-protect status.
2872 				 *
2873 				 * If the tape is not bot we can assume
2874 				 * that mspl->wp_status is set properly.
2875 				 * else
2876 				 * we need to do a mode sense/Tur once
2877 				 * again to get the actual tape status.(since
2878 				 * user might have replaced the tape)
2879 				 * Hence make the st state OFFLINE so that
2880 				 * we re-intialize the tape once again.
2881 				 */
2882 				un->un_read_only =
2883 				    (un->un_oflags & FWRITE) ? RDWR : RDONLY;
2884 				un->un_state = ST_STATE_OPEN_PENDING_IO;
2885 			} else {
2886 				un->un_state = ST_STATE_OFFLINE;
2887 			}
2888 			break;
2889 		case logical:
2890 			if (un->un_pos.lgclblkno == 0) {
2891 				un->un_state = ST_STATE_OFFLINE;
2892 			} else {
2893 				un->un_read_only =
2894 				    (un->un_oflags & FWRITE) ? RDWR : RDONLY;
2895 				un->un_state = ST_STATE_OPEN_PENDING_IO;
2896 			}
2897 			break;
2898 		}
2899 		rval = 0;
2900 	} else {
2901 		/*
2902 		 * Not opening O_NDELAY.
2903 		 */
2904 		un->un_state = ST_STATE_OPENING;
2905 
2906 		/*
2907 		 * Clear error entry stack
2908 		 */
2909 		st_empty_error_stack(un);
2910 
2911 		rval = st_tape_init(un);
2912 		if ((rval == EACCES) && (un->un_read_only & WORM)) {
2913 			un->un_state = ST_STATE_OPEN_PENDING_IO;
2914 			rval = 0; /* so open doesn't fail */
2915 		} else if (rval) {
2916 			/*
2917 			 * Release the tape unit, if reserved and not
2918 			 * preserve reserve.
2919 			 */
2920 			if ((un->un_rsvd_status &
2921 			    (ST_RESERVE | ST_PRESERVE_RESERVE)) == ST_RESERVE) {
2922 				(void) st_reserve_release(un, ST_RELEASE,
2923 				    st_uscsi_cmd);
2924 			}
2925 		} else {
2926 			un->un_state = ST_STATE_OPEN_PENDING_IO;
2927 		}
2928 	}
2929 
2930 exit:
2931 	/*
2932 	 * we don't want any uninvited guests scrogging our data when we're
2933 	 * busy with something, so for successful opens or failed opens
2934 	 * (except for EBUSY), reset these counters and state appropriately.
2935 	 */
2936 	if (rval != EBUSY) {
2937 		if (rval) {
2938 			un->un_state = ST_STATE_CLOSED;
2939 		}
2940 		un->un_err_resid = 0;
2941 		un->un_retry_ct = 0;
2942 	}
2943 busy:
2944 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2945 	    "st_open: return val = %x, state = %d\n", rval, un->un_state);
2946 	mutex_exit(ST_MUTEX);
2947 	return (rval);
2948 
2949 }
2950 
2951 static int
2952 st_tape_init(struct scsi_tape *un)
2953 {
2954 	int err;
2955 	int rval = 0;
2956 
2957 	ST_FUNC(ST_DEVINFO, st_tape_init);
2958 
2959 	ASSERT(mutex_owned(ST_MUTEX));
2960 
2961 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2962 	    "st_tape_init(un = 0x%p, oflags = %d)\n", (void*)un, un->un_oflags);
2963 
2964 	/*
2965 	 * Clean up after any errors left by 'last' close.
2966 	 * This also handles the case of the initial open.
2967 	 */
2968 	if (un->un_state != ST_STATE_INITIALIZING) {
2969 		un->un_laststate = un->un_state;
2970 		un->un_state = ST_STATE_OPENING;
2971 	}
2972 
2973 	un->un_kbytes_xferred = 0;
2974 
2975 	/*
2976 	 * do a throw away TUR to clear check condition
2977 	 */
2978 	err = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
2979 
2980 	/*
2981 	 * If test unit ready fails because the drive is reserved
2982 	 * by another host fail the open for no access.
2983 	 */
2984 	if (err) {
2985 		if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) {
2986 			un->un_state = ST_STATE_CLOSED;
2987 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2988 			    "st_tape_init: RESERVATION CONFLICT\n");
2989 			rval = EACCES;
2990 			goto exit;
2991 		} else if ((un->un_rsvd_status &
2992 		    ST_APPLICATION_RESERVATIONS) != 0) {
2993 			if ((ST_RQSENSE != NULL) &&
2994 			    (ST_RQSENSE->es_add_code == 0x2a &&
2995 			    ST_RQSENSE->es_qual_code == 0x03)) {
2996 				un->un_state = ST_STATE_CLOSED;
2997 				rval = EACCES;
2998 				goto exit;
2999 			}
3000 		}
3001 	}
3002 
3003 	/*
3004 	 * Tape self identification could fail if the tape drive is used by
3005 	 * another host during attach time. We try to get the tape type
3006 	 * again. This is also applied to any posponed configuration methods.
3007 	 */
3008 	if (un->un_dp->type == ST_TYPE_INVALID) {
3009 		un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE;
3010 		st_known_tape_type(un);
3011 	}
3012 
3013 	/*
3014 	 * If the tape type is still invalid, try to determine the generic
3015 	 * configuration.
3016 	 */
3017 	if (un->un_dp->type == ST_TYPE_INVALID) {
3018 		rval = st_determine_generic(un);
3019 		if (rval) {
3020 			if (rval != EACCES) {
3021 				rval = EIO;
3022 			}
3023 			un->un_state = ST_STATE_CLOSED;
3024 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3025 			    "st_tape_init: %s invalid type\n",
3026 			    rval == EACCES ? "EACCES" : "EIO");
3027 			goto exit;
3028 		}
3029 		/*
3030 		 * If this is a Unknown Type drive,
3031 		 * Use the READ BLOCK LIMITS to determine if
3032 		 * allow large xfer is approprate if not globally
3033 		 * disabled with st_allow_large_xfer.
3034 		 */
3035 		un->un_allow_large_xfer = (uchar_t)st_allow_large_xfer;
3036 	} else {
3037 
3038 		/*
3039 		 * If we allow_large_xfer (ie >64k) and have not yet found out
3040 		 * the max block size supported by the drive,
3041 		 * find it by issueing a READ_BLKLIM command.
3042 		 * if READ_BLKLIM cmd fails, assume drive doesn't
3043 		 * allow_large_xfer and min/max block sizes as 1 byte and 63k.
3044 		 */
3045 		un->un_allow_large_xfer = st_allow_large_xfer &&
3046 		    (un->un_dp->options & ST_NO_RECSIZE_LIMIT);
3047 	}
3048 	/*
3049 	 * if maxbsize is unknown, set the maximum block size.
3050 	 */
3051 	if (un->un_maxbsize == MAXBSIZE_UNKNOWN) {
3052 
3053 		/*
3054 		 * Get the Block limits of the tape drive.
3055 		 * if un->un_allow_large_xfer = 0 , then make sure
3056 		 * that maxbsize is <= ST_MAXRECSIZE_FIXED.
3057 		 */
3058 		un->un_rbl = kmem_zalloc(RBLSIZE, KM_SLEEP);
3059 
3060 		err = st_cmd(un, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD);
3061 		if (err) {
3062 			/* Retry */
3063 			err = st_cmd(un, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD);
3064 		}
3065 		if (!err) {
3066 
3067 			/*
3068 			 * if cmd successful, use limit returned
3069 			 */
3070 			un->un_maxbsize = (un->un_rbl->max_hi << 16) +
3071 			    (un->un_rbl->max_mid << 8) +
3072 			    un->un_rbl->max_lo;
3073 			un->un_minbsize = (un->un_rbl->min_hi << 8) +
3074 			    un->un_rbl->min_lo;
3075 			un->un_data_mod = 1 << un->un_rbl->granularity;
3076 			if ((un->un_maxbsize == 0) ||
3077 			    (un->un_allow_large_xfer == 0 &&
3078 			    un->un_maxbsize > ST_MAXRECSIZE_FIXED)) {
3079 				un->un_maxbsize = ST_MAXRECSIZE_FIXED;
3080 
3081 			} else if (un->un_dp->type == ST_TYPE_DEFAULT) {
3082 				/*
3083 				 * Drive is not one that is configured, But the
3084 				 * READ BLOCK LIMITS tells us it can do large
3085 				 * xfers.
3086 				 */
3087 				if (un->un_maxbsize > ST_MAXRECSIZE_FIXED) {
3088 					un->un_dp->options |=
3089 					    ST_NO_RECSIZE_LIMIT;
3090 				}
3091 				/*
3092 				 * If max and mimimum block limits are the
3093 				 * same this is a fixed block size device.
3094 				 */
3095 				if (un->un_maxbsize == un->un_minbsize) {
3096 					un->un_dp->options &= ~ST_VARIABLE;
3097 				}
3098 			}
3099 
3100 			if (un->un_minbsize == 0) {
3101 				un->un_minbsize = 1;
3102 			}
3103 
3104 		} else { /* error on read block limits */
3105 
3106 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
3107 			    "!st_tape_init: Error on READ BLOCK LIMITS,"
3108 			    " errno = %d un_rsvd_status = 0x%X\n",
3109 			    err, un->un_rsvd_status);
3110 
3111 			/*
3112 			 * since read block limits cmd failed,
3113 			 * do not allow large xfers.
3114 			 * use old values in st_minphys
3115 			 */
3116 			if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) {
3117 				rval = EACCES;
3118 			} else {
3119 				un->un_allow_large_xfer = 0;
3120 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
3121 				    "!Disabling large transfers\n");
3122 
3123 				/*
3124 				 * we guess maxbsize and minbsize
3125 				 */
3126 				if (un->un_bsize) {
3127 					un->un_maxbsize = un->un_minbsize =
3128 					    un->un_bsize;
3129 				} else {
3130 					un->un_maxbsize = ST_MAXRECSIZE_FIXED;
3131 					un->un_minbsize = 1;
3132 				}
3133 				/*
3134 				 * Data Mod must be set,
3135 				 * Even if read block limits fails.
3136 				 * Prevents Divide By Zero in st_rw().
3137 				 */
3138 				un->un_data_mod = 1;
3139 			}
3140 		}
3141 		if (un->un_rbl) {
3142 			kmem_free(un->un_rbl, RBLSIZE);
3143 			un->un_rbl = NULL;
3144 		}
3145 
3146 		if (rval) {
3147 			goto exit;
3148 		}
3149 	}
3150 
3151 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3152 	    "maxdma = %d, maxbsize = %d, minbsize = %d, %s large xfer\n",
3153 	    un->un_maxdma, un->un_maxbsize, un->un_minbsize,
3154 	    (un->un_allow_large_xfer ? "ALLOW": "DON'T ALLOW"));
3155 
3156 	err = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
3157 
3158 	if (err != 0) {
3159 		if (err == EINTR) {
3160 			un->un_laststate = un->un_state;
3161 			un->un_state = ST_STATE_CLOSED;
3162 			rval = EINTR;
3163 			goto exit;
3164 		}
3165 		/*
3166 		 * Make sure the tape is ready
3167 		 */
3168 		un->un_pos.pmode = invalid;
3169 		if (un->un_status != KEY_UNIT_ATTENTION) {
3170 			/*
3171 			 * allow open no media.  Subsequent MTIOCSTATE
3172 			 * with media present will complete the open
3173 			 * logic.
3174 			 */
3175 			un->un_laststate = un->un_state;
3176 			if (un->un_oflags & (FNONBLOCK|FNDELAY)) {
3177 				un->un_mediastate = MTIO_EJECTED;
3178 				un->un_state = ST_STATE_OFFLINE;
3179 				rval = 0;
3180 				goto exit;
3181 			} else {
3182 				un->un_state = ST_STATE_CLOSED;
3183 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3184 				    "st_tape_init EIO no media, not opened "
3185 				    "O_NONBLOCK|O_EXCL\n");
3186 				rval = EIO;
3187 				goto exit;
3188 			}
3189 		}
3190 	}
3191 
3192 	/*
3193 	 * On each open, initialize block size from drivetype struct,
3194 	 * as it could have been changed by MTSRSZ ioctl.
3195 	 * Now, ST_VARIABLE simply means drive is capable of variable
3196 	 * mode. All drives are assumed to support fixed records.
3197 	 * Hence, un_bsize tells what mode the drive is in.
3198 	 *	un_bsize	= 0	- variable record length
3199 	 *			= x	- fixed record length is x
3200 	 */
3201 	un->un_bsize = un->un_dp->bsize;
3202 
3203 	/*
3204 	 * If saved position is valid go there
3205 	 */
3206 	if (un->un_restore_pos) {
3207 		un->un_restore_pos = 0;
3208 		un->un_pos.fileno = un->un_save_fileno;
3209 		un->un_pos.blkno = un->un_save_blkno;
3210 		rval = st_validate_tapemarks(un, st_uscsi_cmd, &un->un_pos);
3211 		if (rval != 0) {
3212 			if (rval != EACCES) {
3213 				rval = EIO;
3214 			}
3215 			un->un_laststate = un->un_state;
3216 			un->un_state = ST_STATE_CLOSED;
3217 			goto exit;
3218 		}
3219 	}
3220 
3221 	if (un->un_pos.pmode == invalid) {
3222 		rval = st_loadtape(un);
3223 		if (rval) {
3224 			if (rval != EACCES) {
3225 				rval = EIO;
3226 			}
3227 			un->un_laststate = un->un_state;
3228 			un->un_state = ST_STATE_CLOSED;
3229 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3230 			    "st_tape_init: %s can't open tape\n",
3231 			    rval == EACCES ? "EACCES" : "EIO");
3232 			goto exit;
3233 		}
3234 	}
3235 
3236 	/*
3237 	 * do a mode sense to pick up state of current write-protect,
3238 	 * Could cause reserve and fail due to conflict.
3239 	 */
3240 	if (un->un_unit_attention_flags) {
3241 		rval = st_modesense(un);
3242 		if (rval == EACCES) {
3243 			goto exit;
3244 		}
3245 	}
3246 
3247 	/*
3248 	 * If we are opening the tape for writing, check
3249 	 * to make sure that the tape can be written.
3250 	 */
3251 	if (un->un_oflags & FWRITE) {
3252 		err = 0;
3253 		if (un->un_mspl->wp) {
3254 			un->un_status = KEY_WRITE_PROTECT;
3255 			un->un_laststate = un->un_state;
3256 			un->un_state = ST_STATE_CLOSED;
3257 			rval = EACCES;
3258 			/*
3259 			 * STK sets the wp bit if volsafe tape is loaded.
3260 			 */
3261 			if ((un->un_dp->type == MT_ISSTK9840) &&
3262 			    (un->un_dp->options & ST_WORMABLE)) {
3263 				un->un_read_only = RDONLY;
3264 			} else {
3265 				goto exit;
3266 			}
3267 		} else {
3268 			un->un_read_only = RDWR;
3269 		}
3270 	} else {
3271 		un->un_read_only = RDONLY;
3272 	}
3273 
3274 	if (un->un_dp->options & ST_WORMABLE &&
3275 	    un->un_unit_attention_flags) {
3276 		un->un_read_only |= un->un_wormable(un);
3277 
3278 		if (((un->un_read_only == WORM) ||
3279 		    (un->un_read_only == RDWORM)) &&
3280 		    ((un->un_oflags & FWRITE) == FWRITE)) {
3281 			un->un_status = KEY_DATA_PROTECT;
3282 			rval = EACCES;
3283 			ST_DEBUG4(ST_DEVINFO, st_label, CE_NOTE,
3284 			    "read_only = %d eof = %d oflag = %d\n",
3285 			    un->un_read_only, un->un_pos.eof, un->un_oflags);
3286 		}
3287 	}
3288 
3289 	/*
3290 	 * If we're opening the tape write-only, we need to
3291 	 * write 2 filemarks on the HP 1/2 inch drive, to
3292 	 * create a null file.
3293 	 */
3294 	if ((un->un_read_only == RDWR) ||
3295 	    (un->un_read_only == WORM) && (un->un_oflags & FWRITE)) {
3296 		if (un->un_dp->options & ST_REEL) {
3297 			un->un_fmneeded = 2;
3298 		} else {
3299 			un->un_fmneeded = 1;
3300 		}
3301 	} else {
3302 		un->un_fmneeded = 0;
3303 	}
3304 
3305 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3306 	    "fmneeded = %x\n", un->un_fmneeded);
3307 
3308 	/*
3309 	 * Make sure the density can be selected correctly.
3310 	 * If WORM can only write at the append point which in most cases
3311 	 * isn't BOP. st_determine_density() with a B_WRITE only attempts
3312 	 * to set and try densities if a BOP.
3313 	 */
3314 	if (st_determine_density(un,
3315 	    un->un_read_only == RDWR ? B_WRITE : B_READ)) {
3316 		un->un_status = KEY_ILLEGAL_REQUEST;
3317 		un->un_laststate = un->un_state;
3318 		un->un_state = ST_STATE_CLOSED;
3319 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
3320 		    "st_tape_init: EIO can't determine density\n");
3321 		rval = EIO;
3322 		goto exit;
3323 	}
3324 
3325 	/*
3326 	 * Destroy the knowledge that we have 'determined'
3327 	 * density so that a later read at BOT comes along
3328 	 * does the right density determination.
3329 	 */
3330 
3331 	un->un_density_known = 0;
3332 
3333 
3334 	/*
3335 	 * Okay, the tape is loaded and either at BOT or somewhere past.
3336 	 * Mark the state such that any I/O or tape space operations
3337 	 * will get/set the right density, etc..
3338 	 */
3339 	un->un_laststate = un->un_state;
3340 	un->un_lastop = ST_OP_NIL;
3341 	un->un_mediastate = MTIO_INSERTED;
3342 	cv_broadcast(&un->un_state_cv);
3343 
3344 	/*
3345 	 *  Set test append flag if writing.
3346 	 *  First write must check that tape is positioned correctly.
3347 	 */
3348 	un->un_test_append = (un->un_oflags & FWRITE);
3349 
3350 	/*
3351 	 * if there are pending unit attention flags.
3352 	 * Check that the media has not changed.
3353 	 */
3354 	if (un->un_unit_attention_flags) {
3355 		rval = st_get_media_identification(un, st_uscsi_cmd);
3356 		if (rval != 0 && rval != EACCES) {
3357 			rval = EIO;
3358 		}
3359 		un->un_unit_attention_flags = 0;
3360 	}
3361 
3362 exit:
3363 	un->un_err_resid = 0;
3364 	un->un_last_resid = 0;
3365 	un->un_last_count = 0;
3366 
3367 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3368 	    "st_tape_init: return val = %x\n", rval);
3369 	return (rval);
3370 
3371 }
3372 
3373 
3374 
3375 /* ARGSUSED */
3376 static int
3377 st_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
3378 {
3379 	int err = 0;
3380 	int count, last_state;
3381 	minor_t minor = getminor(dev);
3382 #ifdef	__x86
3383 	struct contig_mem *cp, *cp_temp;
3384 #endif
3385 
3386 	GET_SOFT_STATE(dev);
3387 
3388 	ST_ENTR(ST_DEVINFO, st_close);
3389 
3390 	/*
3391 	 * wait till all cmds in the pipeline have been completed
3392 	 */
3393 	mutex_enter(ST_MUTEX);
3394 
3395 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3396 	    "st_close(dev = 0x%lx, flag = %d, otyp = %d)\n", dev, flag, otyp);
3397 
3398 	st_wait_for_io(un);
3399 
3400 	/* turn off persistent errors on close, as we want close to succeed */
3401 	st_turn_pe_off(un);
3402 
3403 	/*
3404 	 * set state to indicate that we are in process of closing
3405 	 */
3406 	last_state = un->un_laststate = un->un_state;
3407 	un->un_state = ST_STATE_CLOSING;
3408 
3409 	ST_POS(ST_DEVINFO, "st_close1:", &un->un_pos);
3410 
3411 	/*
3412 	 * BSD behavior:
3413 	 * a close always causes a silent span to the next file if we've hit
3414 	 * an EOF (but not yet read across it).
3415 	 */
3416 	if ((minor & MT_BSD) && (un->un_pos.eof == ST_EOF)) {
3417 		if (un->un_pos.pmode != invalid) {
3418 			un->un_pos.fileno++;
3419 			un->un_pos.blkno = 0;
3420 		}
3421 		un->un_pos.eof = ST_NO_EOF;
3422 	}
3423 
3424 	/*
3425 	 * SVR4 behavior for skipping to next file:
3426 	 *
3427 	 * If we have not seen a filemark, space to the next file
3428 	 *
3429 	 * If we have already seen the filemark we are physically in the next
3430 	 * file and we only increment the filenumber
3431 	 */
3432 	if (((minor & (MT_BSD | MT_NOREWIND)) == MT_NOREWIND) &&
3433 	    (flag & FREAD) &&		/* reading or at least asked to */
3434 	    (un->un_mediastate == MTIO_INSERTED) &&	/* tape loaded */
3435 	    (un->un_pos.pmode != invalid) &&		/* XXX position known */
3436 	    ((un->un_pos.blkno != 0) && 		/* inside a file */
3437 	    (un->un_lastop != ST_OP_WRITE) &&		/* Didn't just write */
3438 	    (un->un_lastop != ST_OP_WEOF))) {		/* or write filemarks */
3439 		switch (un->un_pos.eof) {
3440 		case ST_NO_EOF:
3441 			/*
3442 			 * if we were reading and did not read the complete file
3443 			 * skip to the next file, leaving the tape correctly
3444 			 * positioned to read the first record of the next file
3445 			 * Check first for REEL if we are at EOT by trying to
3446 			 * read a block
3447 			 */
3448 			if ((un->un_dp->options & ST_REEL) &&
3449 			    (!(un->un_dp->options & ST_READ_IGNORE_EOFS)) &&
3450 			    (un->un_pos.blkno == 0)) {
3451 				if (st_cmd(un, SCMD_SPACE, Blk(1), SYNC_CMD)) {
3452 					ST_DEBUG2(ST_DEVINFO, st_label,
3453 					    SCSI_DEBUG,
3454 					    "st_close : EIO can't space\n");
3455 					err = EIO;
3456 					goto error_out;
3457 				}
3458 				if (un->un_pos.eof >= ST_EOF_PENDING) {
3459 					un->un_pos.eof = ST_EOT_PENDING;
3460 					un->un_pos.fileno += 1;
3461 					un->un_pos.blkno   = 0;
3462 					break;
3463 				}
3464 			}
3465 			if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) {
3466 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3467 				    "st_close: EIO can't space #2\n");
3468 				err = EIO;
3469 				goto error_out;
3470 			} else {
3471 				ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3472 				    "st_close2: fileno=%x,blkno=%x,eof=%x\n",
3473 				    un->un_pos.fileno, un->un_pos.blkno,
3474 				    un->un_pos.eof);
3475 				un->un_pos.eof = ST_NO_EOF;
3476 			}
3477 			break;
3478 
3479 		case ST_EOF_PENDING:
3480 		case ST_EOF:
3481 			un->un_pos.fileno += 1;
3482 			un->un_pos.lgclblkno += 1;
3483 			un->un_pos.blkno   = 0;
3484 			un->un_pos.eof = ST_NO_EOF;
3485 			break;
3486 
3487 		case ST_EOT:
3488 		case ST_EOT_PENDING:
3489 		case ST_EOM:
3490 			/* nothing to do */
3491 			break;
3492 		default:
3493 			ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
3494 			    "Undefined state 0x%x", un->un_pos.eof);
3495 
3496 		}
3497 	}
3498 
3499 
3500 	/*
3501 	 * For performance reasons (HP 88780), the driver should
3502 	 * postpone writing the second tape mark until just before a file
3503 	 * positioning ioctl is issued (e.g., rewind).	This means that
3504 	 * the user must not manually rewind the tape because the tape will
3505 	 * be missing the second tape mark which marks EOM.
3506 	 * However, this small performance improvement is not worth the risk.
3507 	 */
3508 
3509 	/*
3510 	 * We need to back up over the filemark we inadvertently popped
3511 	 * over doing a read in between the two filemarks that constitute
3512 	 * logical eot for 1/2" tapes. Note that ST_EOT_PENDING is only
3513 	 * set while reading.
3514 	 *
3515 	 * If we happen to be at physical eot (ST_EOM) (writing case),
3516 	 * the writing of filemark(s) will clear the ST_EOM state, which
3517 	 * we don't want, so we save this state and restore it later.
3518 	 */
3519 
3520 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3521 	    "flag=%x, fmneeded=%x, lastop=%x, eof=%x\n",
3522 	    flag, un->un_fmneeded, un->un_lastop, un->un_pos.eof);
3523 
3524 	if (un->un_pos.eof == ST_EOT_PENDING) {
3525 		if (minor & MT_NOREWIND) {
3526 			if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) {
3527 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3528 				    "st_close: EIO can't space #3\n");
3529 				err = EIO;
3530 				goto error_out;
3531 			} else {
3532 				un->un_pos.blkno = 0;
3533 				un->un_pos.eof = ST_EOT;
3534 			}
3535 		} else {
3536 			un->un_pos.eof = ST_NO_EOF;
3537 		}
3538 
3539 	/*
3540 	 * Do we need to write a file mark?
3541 	 *
3542 	 * only write filemarks if there are fmks to be written and
3543 	 *   - open for write (possibly read/write)
3544 	 *   - the last operation was a write
3545 	 * or:
3546 	 *   -	opened for wronly
3547 	 *   -	no data was written
3548 	 */
3549 	} else if ((un->un_pos.pmode != invalid) &&
3550 	    (un->un_fmneeded > 0) &&
3551 	    (((flag & FWRITE) &&
3552 	    ((un->un_lastop == ST_OP_WRITE)||(un->un_lastop == ST_OP_WEOF))) ||
3553 	    ((flag == FWRITE) && (un->un_lastop == ST_OP_NIL)))) {
3554 
3555 		/* save ST_EOM state */
3556 		int was_at_eom = (un->un_pos.eof == ST_EOM) ? 1 : 0;
3557 
3558 		/*
3559 		 * Note that we will write a filemark if we had opened
3560 		 * the tape write only and no data was written, thus
3561 		 * creating a null file.
3562 		 *
3563 		 * If the user already wrote one, we only have to write 1 more.
3564 		 * If they wrote two, we don't have to write any.
3565 		 */
3566 
3567 		count = un->un_fmneeded;
3568 		if (count > 0) {
3569 			if (st_cmd(un, SCMD_WRITE_FILE_MARK, count, SYNC_CMD)) {
3570 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3571 				    "st_close : EIO can't wfm\n");
3572 				err = EIO;
3573 				goto error_out;
3574 			}
3575 			if ((un->un_dp->options & ST_REEL) &&
3576 			    (minor & MT_NOREWIND)) {
3577 				if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) {
3578 					ST_DEBUG2(ST_DEVINFO, st_label,
3579 					    SCSI_DEBUG,
3580 					    "st_close : EIO space fmk(-1)\n");
3581 					err = EIO;
3582 					goto error_out;
3583 				}
3584 				un->un_pos.eof = ST_NO_EOF;
3585 				/* fix up block number */
3586 				un->un_pos.blkno = 0;
3587 			}
3588 		}
3589 
3590 		/*
3591 		 * If we aren't going to be rewinding, and we were at
3592 		 * physical eot, restore the state that indicates we
3593 		 * are at physical eot. Once you have reached physical
3594 		 * eot, and you close the tape, the only thing you can
3595 		 * do on the next open is to rewind. Access to trailer
3596 		 * records is only allowed without closing the device.
3597 		 */
3598 		if ((minor & MT_NOREWIND) == 0 && was_at_eom) {
3599 			un->un_pos.eof = ST_EOM;
3600 		}
3601 	}
3602 
3603 	/*
3604 	 * report soft errors if enabled and available, if we never accessed
3605 	 * the drive, don't get errors. This will prevent some DAT error
3606 	 * messages upon LOG SENSE.
3607 	 */
3608 	if (st_report_soft_errors_on_close &&
3609 	    (un->un_dp->options & ST_SOFT_ERROR_REPORTING) &&
3610 	    (last_state != ST_STATE_OFFLINE)) {
3611 		if (st_report_soft_errors(dev, flag)) {
3612 			err = EIO;
3613 			goto error_out;
3614 		}
3615 	}
3616 
3617 
3618 	/*
3619 	 * Do we need to rewind? Can we rewind?
3620 	 */
3621 	if ((minor & MT_NOREWIND) == 0 &&
3622 	    un->un_pos.pmode != invalid && err == 0) {
3623 		/*
3624 		 * We'd like to rewind with the
3625 		 * 'immediate' bit set, but this
3626 		 * causes problems on some drives
3627 		 * where subsequent opens get a
3628 		 * 'NOT READY' error condition
3629 		 * back while the tape is rewinding,
3630 		 * which is impossible to distinguish
3631 		 * from the condition of 'no tape loaded'.
3632 		 *
3633 		 * Also, for some targets, if you disconnect
3634 		 * with the 'immediate' bit set, you don't
3635 		 * actually return right away, i.e., the
3636 		 * target ignores your request for immediate
3637 		 * return.
3638 		 *
3639 		 * Instead, we'll fire off an async rewind
3640 		 * command. We'll mark the device as closed,
3641 		 * and any subsequent open will stall on
3642 		 * the first TEST_UNIT_READY until the rewind
3643 		 * completes.
3644 		 */
3645 
3646 		/*
3647 		 * Used to be if reserve was not supported we'd send an
3648 		 * asynchronious rewind. Comments above may be slightly invalid
3649 		 * as the immediate bit was never set. Doing an immedate rewind
3650 		 * makes sense, I think fixes to not ready status might handle
3651 		 * the problems described above.
3652 		 */
3653 		if (un->un_sd->sd_inq->inq_ansi < 2) {
3654 			if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) {
3655 				err = EIO;
3656 			}
3657 		} else {
3658 			/* flush data for older drives per scsi spec. */
3659 			if (st_cmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD)) {
3660 				err = EIO;
3661 			} else {
3662 				/* release the drive before rewind immediate */
3663 				if ((un->un_rsvd_status &
3664 				    (ST_RESERVE | ST_PRESERVE_RESERVE)) ==
3665 				    ST_RESERVE) {
3666 					if (st_reserve_release(un, ST_RELEASE,
3667 					    st_uscsi_cmd)) {
3668 						err = EIO;
3669 					}
3670 				}
3671 
3672 				/* send rewind with immediate bit set */
3673 				if (st_cmd(un, SCMD_REWIND, 1, ASYNC_CMD)) {
3674 					err = EIO;
3675 				}
3676 			}
3677 		}
3678 		/*
3679 		 * Setting positions invalid in case the rewind doesn't
3680 		 * happen. Drives don't like to rewind if resets happen
3681 		 * they will tend to move back to where the rewind was
3682 		 * issued if a reset or something happens so that if a
3683 		 * write happens the data doesn't get clobbered.
3684 		 *
3685 		 * Not a big deal if the position is invalid when the
3686 		 * open occures it will do a read position.
3687 		 */
3688 		un->un_pos.pmode = invalid;
3689 		un->un_running.pmode = invalid;
3690 
3691 		if (err == EIO) {
3692 			goto error_out;
3693 		}
3694 	}
3695 
3696 	/*
3697 	 * eject tape if necessary
3698 	 */
3699 	if (un->un_eject_tape_on_failure) {
3700 		un->un_eject_tape_on_failure = 0;
3701 		if (st_cmd(un, SCMD_LOAD, LD_UNLOAD, SYNC_CMD)) {
3702 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3703 			    "st_close : can't unload tape\n");
3704 			err = EIO;
3705 			goto error_out;
3706 		} else {
3707 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3708 			    "st_close : tape unloaded \n");
3709 			un->un_pos.eof = ST_NO_EOF;
3710 			un->un_mediastate = MTIO_EJECTED;
3711 		}
3712 	}
3713 	/*
3714 	 * Release the tape unit, if default reserve/release
3715 	 * behaviour.
3716 	 */
3717 	if ((un->un_rsvd_status &
3718 	    (ST_RESERVE | ST_PRESERVE_RESERVE |
3719 	    ST_APPLICATION_RESERVATIONS)) == ST_RESERVE) {
3720 		(void) st_reserve_release(un, ST_RELEASE, st_uscsi_cmd);
3721 	}
3722 error_out:
3723 	/*
3724 	 * clear up state
3725 	 */
3726 	un->un_laststate = un->un_state;
3727 	un->un_state = ST_STATE_CLOSED;
3728 	un->un_lastop = ST_OP_NIL;
3729 	un->un_throttle = 1;	/* assume one request at time, for now */
3730 	un->un_retry_ct = 0;
3731 	un->un_errno = 0;
3732 	un->un_swr_token = (opaque_t)NULL;
3733 	un->un_rsvd_status &= ~(ST_INIT_RESERVE);
3734 
3735 	/* Restore the options to the init time settings */
3736 	if (un->un_init_options & ST_READ_IGNORE_ILI) {
3737 		un->un_dp->options |= ST_READ_IGNORE_ILI;
3738 	} else {
3739 		un->un_dp->options &= ~ST_READ_IGNORE_ILI;
3740 	}
3741 
3742 	if (un->un_init_options & ST_READ_IGNORE_EOFS) {
3743 		un->un_dp->options |= ST_READ_IGNORE_EOFS;
3744 	} else {
3745 		un->un_dp->options &= ~ST_READ_IGNORE_EOFS;
3746 	}
3747 
3748 	if (un->un_init_options & ST_SHORT_FILEMARKS) {
3749 		un->un_dp->options |= ST_SHORT_FILEMARKS;
3750 	} else {
3751 		un->un_dp->options &= ~ST_SHORT_FILEMARKS;
3752 	}
3753 
3754 	ASSERT(mutex_owned(ST_MUTEX));
3755 
3756 	/*
3757 	 * Signal anyone awaiting a close operation to complete.
3758 	 */
3759 	cv_signal(&un->un_clscv);
3760 
3761 	/*
3762 	 * any kind of error on closing causes all state to be tossed
3763 	 */
3764 	if (err && un->un_status != KEY_ILLEGAL_REQUEST) {
3765 		/*
3766 		 * note that st_intr has already set
3767 		 * un_pos.pmode to invalid.
3768 		 */
3769 		un->un_density_known = 0;
3770 	}
3771 
3772 #ifdef	__x86
3773 	/*
3774 	 * free any contiguous mem alloc'ed for big block I/O
3775 	 */
3776 	cp = un->un_contig_mem;
3777 	while (cp) {
3778 		if (cp->cm_addr) {
3779 			ddi_dma_mem_free(&cp->cm_acc_hdl);
3780 		}
3781 		cp_temp = cp;
3782 		cp = cp->cm_next;
3783 		kmem_free(cp_temp,
3784 		    sizeof (struct contig_mem) + biosize());
3785 	}
3786 	un->un_contig_mem_total_num = 0;
3787 	un->un_contig_mem_available_num = 0;
3788 	un->un_contig_mem = NULL;
3789 	un->un_max_contig_mem_len = 0;
3790 #endif
3791 
3792 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
3793 	    "st_close3: return val = %x, fileno=%x, blkno=%x, eof=%x\n",
3794 	    err, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof);
3795 
3796 	mutex_exit(ST_MUTEX);
3797 	return (err);
3798 }
3799 
3800 /*
3801  * These routines perform raw i/o operations.
3802  */
3803 
3804 /* ARGSUSED2 */
3805 static int
3806 st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p)
3807 {
3808 #ifdef STDEBUG
3809 	GET_SOFT_STATE(dev);
3810 	ST_ENTR(ST_DEVINFO, st_aread);
3811 #endif
3812 	return (st_arw(dev, aio, B_READ));
3813 }
3814 
3815 
3816 /* ARGSUSED2 */
3817 static int
3818 st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p)
3819 {
3820 #ifdef STDEBUG
3821 	GET_SOFT_STATE(dev);
3822 	ST_ENTR(ST_DEVINFO, st_awrite);
3823 #endif
3824 	return (st_arw(dev, aio, B_WRITE));
3825 }
3826 
3827 
3828 
3829 /* ARGSUSED */
3830 static int
3831 st_read(dev_t dev, struct uio *uiop, cred_t *cred_p)
3832 {
3833 #ifdef STDEBUG
3834 	GET_SOFT_STATE(dev);
3835 	ST_ENTR(ST_DEVINFO, st_read);
3836 #endif
3837 	return (st_rw(dev, uiop, B_READ));
3838 }
3839 
3840 /* ARGSUSED */
3841 static int
3842 st_write(dev_t dev, struct uio *uiop, cred_t *cred_p)
3843 {
3844 #ifdef STDEBUG
3845 	GET_SOFT_STATE(dev);
3846 	ST_ENTR(ST_DEVINFO, st_write);
3847 #endif
3848 	return (st_rw(dev, uiop, B_WRITE));
3849 }
3850 
3851 /*
3852  * Due to historical reasons, old limits are: For variable-length devices:
3853  * if greater than 64KB - 1 (ST_MAXRECSIZE_VARIABLE), block into 64 KB - 2
3854  * ST_MAXRECSIZE_VARIABLE_LIMIT) requests; otherwise,
3855  * (let it through unmodified. For fixed-length record devices:
3856  * 63K (ST_MAXRECSIZE_FIXED) is max (default minphys).
3857  *
3858  * The new limits used are un_maxdma (retrieved using scsi_ifgetcap()
3859  * from the HBA) and un_maxbsize (retrieved by sending SCMD_READ_BLKLIM
3860  * command to the drive).
3861  *
3862  */
3863 static void
3864 st_minphys(struct buf *bp)
3865 {
3866 	struct scsi_tape *un;
3867 
3868 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
3869 
3870 	ST_FUNC(ST_DEVINFO, st_minphys);
3871 
3872 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3873 	    "st_minphys(bp = 0x%p): b_bcount = 0x%lx\n", (void *)bp,
3874 	    bp->b_bcount);
3875 
3876 	if (un->un_allow_large_xfer) {
3877 
3878 		/*
3879 		 * check un_maxbsize for variable length devices only
3880 		 */
3881 		if (un->un_bsize == 0 && bp->b_bcount > un->un_maxbsize) {
3882 			bp->b_bcount = un->un_maxbsize;
3883 		}
3884 		/*
3885 		 * can't go more that HBA maxdma limit in either fixed-length
3886 		 * or variable-length tape drives.
3887 		 */
3888 		if (bp->b_bcount > un->un_maxdma) {
3889 			bp->b_bcount = un->un_maxdma;
3890 		}
3891 	} else {
3892 
3893 		/*
3894 		 *  use old fixed limits
3895 		 */
3896 		if (un->un_bsize == 0) {
3897 			if (bp->b_bcount > ST_MAXRECSIZE_VARIABLE) {
3898 				bp->b_bcount = ST_MAXRECSIZE_VARIABLE_LIMIT;
3899 			}
3900 		} else {
3901 			if (bp->b_bcount > ST_MAXRECSIZE_FIXED) {
3902 				bp->b_bcount = ST_MAXRECSIZE_FIXED;
3903 			}
3904 		}
3905 	}
3906 
3907 	/*
3908 	 * For regular raw I/O and Fixed Block length devices, make sure
3909 	 * the adjusted block count is a whole multiple of the device
3910 	 * block size.
3911 	 */
3912 	if (bp != un->un_sbufp && un->un_bsize) {
3913 		bp->b_bcount -= (bp->b_bcount % un->un_bsize);
3914 	}
3915 }
3916 
3917 static int
3918 st_rw(dev_t dev, struct uio *uio, int flag)
3919 {
3920 	int rval = 0;
3921 	long len;
3922 
3923 	GET_SOFT_STATE(dev);
3924 
3925 	ST_FUNC(ST_DEVINFO, st_rw);
3926 
3927 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3928 	    "st_rw(dev = 0x%lx, flag = %s)\n", dev,
3929 	    (flag == B_READ ? rd_str: wr_str));
3930 
3931 	/* get local copy of transfer length */
3932 	len = uio->uio_iov->iov_len;
3933 
3934 	mutex_enter(ST_MUTEX);
3935 
3936 	/*
3937 	 * Clear error entry stack
3938 	 */
3939 	st_empty_error_stack(un);
3940 
3941 	/*
3942 	 * If in fixed block size mode and requested read or write
3943 	 * is not an even multiple of that block size.
3944 	 */
3945 	if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) {
3946 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
3947 		    "%s: not modulo %d block size\n",
3948 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize);
3949 		rval = EINVAL;
3950 	}
3951 
3952 	/* If device has set granularity in the READ_BLKLIM we honor it. */
3953 	if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) {
3954 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
3955 		    "%s: not modulo %d device granularity\n",
3956 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod);
3957 		rval = EINVAL;
3958 	}
3959 
3960 	if (st_recov_sz != sizeof (recov_info) && un->un_multipath) {
3961 		scsi_log(ST_DEVINFO, st_label, CE_WARN, mp_misconf);
3962 		rval = EFAULT;
3963 	}
3964 
3965 	if (rval != 0) {
3966 		un->un_errno = rval;
3967 		mutex_exit(ST_MUTEX);
3968 		return (rval);
3969 	}
3970 
3971 	/*
3972 	 * Reset this so it can be set if Berkeley and read over a filemark.
3973 	 */
3974 	un->un_silent_skip = 0;
3975 	mutex_exit(ST_MUTEX);
3976 
3977 	len = uio->uio_resid;
3978 
3979 	rval = physio(st_queued_strategy, (struct buf *)NULL,
3980 	    dev, flag, st_minphys, uio);
3981 	/*
3982 	 * if we have hit logical EOT during this xfer and there is not a
3983 	 * full residue, then set eof back  to ST_EOM to make sure that
3984 	 * the user will see at least one zero write
3985 	 * after this short write
3986 	 */
3987 	mutex_enter(ST_MUTEX);
3988 	if (un->un_pos.eof > ST_NO_EOF) {
3989 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3990 		"eof=%d resid=%lx\n", un->un_pos.eof, uio->uio_resid);
3991 	}
3992 	if (un->un_pos.eof >= ST_EOM && (flag == B_WRITE)) {
3993 		if ((uio->uio_resid != len) && (uio->uio_resid != 0)) {
3994 			un->un_pos.eof = ST_EOM;
3995 		} else if (uio->uio_resid == len) {
3996 			un->un_pos.eof = ST_NO_EOF;
3997 		}
3998 	}
3999 
4000 	if (un->un_silent_skip && uio->uio_resid != len) {
4001 		un->un_pos.eof = ST_EOF;
4002 		un->un_pos.blkno = un->un_save_blkno;
4003 		un->un_pos.fileno--;
4004 	}
4005 
4006 	un->un_errno = rval;
4007 
4008 	mutex_exit(ST_MUTEX);
4009 
4010 	return (rval);
4011 }
4012 
4013 static int
4014 st_arw(dev_t dev, struct aio_req *aio, int flag)
4015 {
4016 	struct uio *uio = aio->aio_uio;
4017 	int rval = 0;
4018 	long len;
4019 
4020 	GET_SOFT_STATE(dev);
4021 
4022 	ST_FUNC(ST_DEVINFO, st_arw);
4023 
4024 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4025 	    "st_arw(dev = 0x%lx, flag = %s)\n", dev,
4026 	    (flag == B_READ ? rd_str: wr_str));
4027 
4028 	/* get local copy of transfer length */
4029 	len = uio->uio_iov->iov_len;
4030 
4031 	mutex_enter(ST_MUTEX);
4032 
4033 	/*
4034 	 * If in fixed block size mode and requested read or write
4035 	 * is not an even multiple of that block size.
4036 	 */
4037 	if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) {
4038 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
4039 		    "%s: not modulo %d block size\n",
4040 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize);
4041 		rval = EINVAL;
4042 	}
4043 
4044 	/* If device has set granularity in the READ_BLKLIM we honor it. */
4045 	if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) {
4046 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
4047 		    "%s: not modulo %d device granularity\n",
4048 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod);
4049 		rval = EINVAL;
4050 	}
4051 
4052 	if (st_recov_sz != sizeof (recov_info) && un->un_multipath) {
4053 		scsi_log(ST_DEVINFO, st_label, CE_WARN, mp_misconf);
4054 		rval = EFAULT;
4055 	}
4056 
4057 	if (rval != 0) {
4058 		un->un_errno = rval;
4059 		mutex_exit(ST_MUTEX);
4060 		return (rval);
4061 	}
4062 
4063 	mutex_exit(ST_MUTEX);
4064 
4065 	len = uio->uio_resid;
4066 
4067 	rval =
4068 	    aphysio(st_queued_strategy, anocancel, dev, flag, st_minphys, aio);
4069 
4070 	/*
4071 	 * if we have hit logical EOT during this xfer and there is not a
4072 	 * full residue, then set eof back  to ST_EOM to make sure that
4073 	 * the user will see at least one zero write
4074 	 * after this short write
4075 	 *
4076 	 * we keep this here just in case the application is not using
4077 	 * persistent errors
4078 	 */
4079 	mutex_enter(ST_MUTEX);
4080 	if (un->un_pos.eof > ST_NO_EOF) {
4081 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4082 		    "eof=%d resid=%lx\n", un->un_pos.eof, uio->uio_resid);
4083 	}
4084 	if (un->un_pos.eof >= ST_EOM && (flag == B_WRITE)) {
4085 		if ((uio->uio_resid != len) && (uio->uio_resid != 0)) {
4086 			un->un_pos.eof = ST_EOM;
4087 		} else if (uio->uio_resid == len &&
4088 		    !(un->un_persistence && un->un_persist_errors)) {
4089 			un->un_pos.eof = ST_NO_EOF;
4090 		}
4091 	}
4092 	un->un_errno = rval;
4093 	mutex_exit(ST_MUTEX);
4094 
4095 	return (rval);
4096 }
4097 
4098 
4099 
4100 static int
4101 st_queued_strategy(buf_t *bp)
4102 {
4103 	struct scsi_tape *un;
4104 	char reading = bp->b_flags & B_READ;
4105 	int wasopening = 0;
4106 
4107 	/*
4108 	 * validate arguments
4109 	 */
4110 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
4111 	if (un == NULL) {
4112 		bp->b_resid = bp->b_bcount;
4113 		bioerror(bp, ENXIO);
4114 		ST_DEBUG6(NULL, st_label, SCSI_DEBUG,
4115 		    "st_queued_strategy: ENXIO error exit\n");
4116 		biodone(bp);
4117 		return (0);
4118 	}
4119 
4120 	ST_ENTR(ST_DEVINFO, st_queued_strategy);
4121 
4122 	mutex_enter(ST_MUTEX);
4123 
4124 	while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
4125 		cv_wait(&un->un_suspend_cv, ST_MUTEX);
4126 	}
4127 
4128 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4129 	    "st_queued_strategy(): bcount=0x%lx, fileno=%d, blkno=%x, eof=%d\n",
4130 	    bp->b_bcount, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof);
4131 
4132 	/*
4133 	 * If persistent errors have been flagged, just nix this one. We wait
4134 	 * for any outstanding I/O's below, so we will be in order.
4135 	 */
4136 	if (un->un_persistence && un->un_persist_errors) {
4137 		goto exit;
4138 	}
4139 
4140 	/*
4141 	 * If last command was non queued, wait till it finishes.
4142 	 */
4143 	while (un->un_sbuf_busy) {
4144 		cv_wait(&un->un_sbuf_cv, ST_MUTEX);
4145 		/* woke up because of an error */
4146 		if (un->un_persistence && un->un_persist_errors) {
4147 			goto exit;
4148 		}
4149 	}
4150 
4151 	/*
4152 	 * s_buf and recovery commands shouldn't come here.
4153 	 */
4154 	ASSERT(bp != un->un_recov_buf);
4155 	ASSERT(bp != un->un_sbufp);
4156 
4157 	/*
4158 	 * If we haven't done/checked reservation on the tape unit
4159 	 * do it now.
4160 	 */
4161 	if ((un->un_rsvd_status &
4162 	    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) {
4163 		if ((un->un_dp->options & ST_NO_RESERVE_RELEASE) == 0) {
4164 			if (st_reserve_release(un, ST_RESERVE, st_uscsi_cmd)) {
4165 				st_bioerror(bp, un->un_errno);
4166 				goto exit;
4167 			}
4168 		} else if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
4169 			/*
4170 			 * Enter here to restore position for possible
4171 			 * resets when the device was closed and opened
4172 			 * in O_NDELAY mode subsequently
4173 			 */
4174 			un->un_state = ST_STATE_INITIALIZING;
4175 			(void) st_cmd(un, SCMD_TEST_UNIT_READY,
4176 			    0, SYNC_CMD);
4177 			un->un_state = ST_STATE_OPEN_PENDING_IO;
4178 		}
4179 		un->un_rsvd_status |= ST_INIT_RESERVE;
4180 	}
4181 
4182 	/*
4183 	 * If we are offline, we have to initialize everything first.
4184 	 * This is to handle either when opened with O_NDELAY, or
4185 	 * we just got a new tape in the drive, after an offline.
4186 	 * We don't observe O_NDELAY past the open,
4187 	 * as it will not make sense for tapes.
4188 	 */
4189 	if (un->un_state == ST_STATE_OFFLINE || un->un_restore_pos) {
4190 		/*
4191 		 * reset state to avoid recursion
4192 		 */
4193 		un->un_laststate = un->un_state;
4194 		un->un_state = ST_STATE_INITIALIZING;
4195 		if (st_tape_init(un)) {
4196 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4197 			    "stioctl : OFFLINE init failure ");
4198 			un->un_state = ST_STATE_OFFLINE;
4199 			un->un_pos.pmode = invalid;
4200 			goto b_done_err;
4201 		}
4202 		/* un_restore_pos make invalid */
4203 		un->un_state = ST_STATE_OPEN_PENDING_IO;
4204 		un->un_restore_pos = 0;
4205 	}
4206 	/*
4207 	 * Check for legal operations
4208 	 */
4209 	if (un->un_pos.pmode == invalid) {
4210 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4211 		    "strategy with un->un_pos.pmode invalid\n");
4212 		goto b_done_err;
4213 	}
4214 
4215 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4216 	    "st_queued_strategy(): regular io\n");
4217 
4218 	/*
4219 	 * Process this first. If we were reading, and we're pending
4220 	 * logical eot, that means we've bumped one file mark too far.
4221 	 */
4222 
4223 	/*
4224 	 * Recursion warning: st_cmd will route back through here.
4225 	 * Not anymore st_cmd will go through st_strategy()!
4226 	 */
4227 	if (un->un_pos.eof == ST_EOT_PENDING) {
4228 		if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) {
4229 			un->un_pos.pmode = invalid;
4230 			un->un_density_known = 0;
4231 			goto b_done_err;
4232 		}
4233 		un->un_pos.blkno = 0; /* fix up block number.. */
4234 		un->un_pos.eof = ST_EOT;
4235 	}
4236 
4237 	/*
4238 	 * If we are in the process of opening, we may have to
4239 	 * determine/set the correct density. We also may have
4240 	 * to do a test_append (if QIC) to see whether we are
4241 	 * in a position to append to the end of the tape.
4242 	 *
4243 	 * If we're already at logical eot, we transition
4244 	 * to ST_NO_EOF. If we're at physical eot, we punt
4245 	 * to the switch statement below to handle.
4246 	 */
4247 	if ((un->un_state == ST_STATE_OPEN_PENDING_IO) ||
4248 	    (un->un_test_append && (un->un_dp->options & ST_QIC))) {
4249 
4250 		if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
4251 			if (st_determine_density(un, (int)reading)) {
4252 				goto b_done_err;
4253 			}
4254 		}
4255 
4256 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4257 		    "pending_io@fileno %d rw %d qic %d eof %d\n",
4258 		    un->un_pos.fileno, (int)reading,
4259 		    (un->un_dp->options & ST_QIC) ? 1 : 0,
4260 		    un->un_pos.eof);
4261 
4262 		if (!reading && un->un_pos.eof != ST_EOM) {
4263 			if (un->un_pos.eof == ST_EOT) {
4264 				un->un_pos.eof = ST_NO_EOF;
4265 			} else if (un->un_pos.pmode != invalid &&
4266 			    (un->un_dp->options & ST_QIC)) {
4267 				/*
4268 				 * st_test_append() will do it all
4269 				 */
4270 				st_test_append(bp);
4271 				mutex_exit(ST_MUTEX);
4272 				return (0);
4273 			}
4274 		}
4275 		if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
4276 			wasopening = 1;
4277 		}
4278 		un->un_laststate = un->un_state;
4279 		un->un_state = ST_STATE_OPEN;
4280 	}
4281 
4282 
4283 	/*
4284 	 * Process rest of END OF FILE and END OF TAPE conditions
4285 	 */
4286 
4287 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4288 	    "eof=%x, wasopening=%x\n",
4289 	    un->un_pos.eof, wasopening);
4290 
4291 	switch (un->un_pos.eof) {
4292 	case ST_EOM:
4293 		/*
4294 		 * This allows writes to proceed past physical
4295 		 * eot. We'll *really* be in trouble if the
4296 		 * user continues blindly writing data too
4297 		 * much past this point (unwind the tape).
4298 		 * Physical eot really means 'early warning
4299 		 * eot' in this context.
4300 		 *
4301 		 * Every other write from now on will succeed
4302 		 * (if sufficient  tape left).
4303 		 * This write will return with resid == count
4304 		 * but the next one should be successful
4305 		 *
4306 		 * Note that we only transition to logical EOT
4307 		 * if the last state wasn't the OPENING state.
4308 		 * We explicitly prohibit running up to physical
4309 		 * eot, closing the device, and then re-opening
4310 		 * to proceed. Trailer records may only be gotten
4311 		 * at by keeping the tape open after hitting eot.
4312 		 *
4313 		 * Also note that ST_EOM cannot be set by reading-
4314 		 * this can only be set during writing. Reading
4315 		 * up to the end of the tape gets a blank check
4316 		 * or a double-filemark indication (ST_EOT_PENDING),
4317 		 * and we prohibit reading after that point.
4318 		 *
4319 		 */
4320 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOM\n");
4321 		if (wasopening == 0) {
4322 			/*
4323 			 * this allows st_rw() to reset it back to
4324 			 * will see a zero write
4325 			 */
4326 			un->un_pos.eof = ST_WRITE_AFTER_EOM;
4327 		}
4328 		un->un_status = SUN_KEY_EOT;
4329 		goto b_done;
4330 
4331 	case ST_WRITE_AFTER_EOM:
4332 	case ST_EOT:
4333 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOT\n");
4334 		un->un_status = SUN_KEY_EOT;
4335 		if (SVR4_BEHAVIOR && reading) {
4336 			goto b_done_err;
4337 		}
4338 
4339 		if (reading) {
4340 			goto b_done;
4341 		}
4342 		un->un_pos.eof = ST_NO_EOF;
4343 		break;
4344 
4345 	case ST_EOF_PENDING:
4346 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4347 		    "EOF PENDING\n");
4348 		un->un_status = SUN_KEY_EOF;
4349 		if (SVR4_BEHAVIOR) {
4350 			un->un_pos.eof = ST_EOF;
4351 			goto b_done;
4352 		}
4353 		/* FALLTHROUGH */
4354 	case ST_EOF:
4355 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOF\n");
4356 		un->un_status = SUN_KEY_EOF;
4357 		if (SVR4_BEHAVIOR) {
4358 			goto b_done_err;
4359 		}
4360 
4361 		if (BSD_BEHAVIOR) {
4362 			un->un_pos.eof = ST_NO_EOF;
4363 			un->un_pos.fileno += 1;
4364 			un->un_pos.blkno   = 0;
4365 		}
4366 
4367 		if (reading) {
4368 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4369 			    "now file %d (read)\n",
4370 			    un->un_pos.fileno);
4371 			goto b_done;
4372 		}
4373 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4374 		    "now file %d (write)\n", un->un_pos.fileno);
4375 		break;
4376 	default:
4377 		un->un_status = 0;
4378 		break;
4379 	}
4380 
4381 	bp->b_flags &= ~(B_DONE);
4382 	st_bioerror(bp, 0);
4383 	bp->av_forw = NULL;
4384 	bp->b_resid = 0;
4385 	SET_BP_PKT(bp, 0);
4386 
4387 
4388 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4389 	    "st_queued_strategy: cmd=0x%p  count=%ld  resid=%ld flags=0x%x"
4390 	    " pkt=0x%p\n",
4391 	    (void *)bp->b_forw, bp->b_bcount,
4392 	    bp->b_resid, bp->b_flags, (void *)BP_PKT(bp));
4393 
4394 #ifdef	__x86
4395 	/*
4396 	 * We will replace bp with a new bp that can do big blk xfer
4397 	 * if the requested xfer size is bigger than un->un_maxdma_arch
4398 	 *
4399 	 * Also, we need to make sure that we're handling real I/O
4400 	 * by checking group 0/1 SCSI I/O commands, if needed
4401 	 */
4402 	if (bp->b_bcount > un->un_maxdma_arch &&
4403 	    ((uchar_t)(uintptr_t)bp->b_forw == SCMD_READ ||
4404 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_READ_G4 ||
4405 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE ||
4406 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE_G4)) {
4407 		mutex_exit(ST_MUTEX);
4408 		bp = st_get_bigblk_bp(bp);
4409 		mutex_enter(ST_MUTEX);
4410 	}
4411 #endif
4412 
4413 	/* put on wait queue */
4414 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4415 	    "st_queued_strategy: un->un_quef = 0x%p, bp = 0x%p\n",
4416 	    (void *)un->un_quef, (void *)bp);
4417 
4418 	st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quel, bp);
4419 
4420 	ST_DO_KSTATS(bp, kstat_waitq_enter);
4421 
4422 	st_start(un);
4423 
4424 	mutex_exit(ST_MUTEX);
4425 	return (0);
4426 
4427 b_done_err:
4428 	st_bioerror(bp, EIO);
4429 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4430 	    "st_queued_strategy : EIO b_done_err\n");
4431 
4432 b_done:
4433 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4434 	    "st_queued_strategy: b_done\n");
4435 
4436 exit:
4437 	/*
4438 	 * make sure no commands are outstanding or waiting before closing,
4439 	 * so we can guarantee order
4440 	 */
4441 	st_wait_for_io(un);
4442 	un->un_err_resid = bp->b_resid = bp->b_bcount;
4443 
4444 	/* override errno here, if persistent errors were flagged */
4445 	if (un->un_persistence && un->un_persist_errors)
4446 		bioerror(bp, un->un_errno);
4447 
4448 	mutex_exit(ST_MUTEX);
4449 
4450 	biodone(bp);
4451 	ASSERT(mutex_owned(ST_MUTEX) == 0);
4452 	return (0);
4453 }
4454 
4455 
4456 static int
4457 st_strategy(struct buf *bp)
4458 {
4459 	struct scsi_tape *un;
4460 
4461 	/*
4462 	 * validate arguments
4463 	 */
4464 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
4465 	if (un == NULL) {
4466 		bp->b_resid = bp->b_bcount;
4467 		bioerror(bp, ENXIO);
4468 		ST_DEBUG6(NULL, st_label, SCSI_DEBUG,
4469 		    "st_strategy: ENXIO error exit\n");
4470 
4471 		biodone(bp);
4472 		return (0);
4473 
4474 	}
4475 
4476 	ST_ENTR(ST_DEVINFO, st_strategy);
4477 
4478 	mutex_enter(ST_MUTEX);
4479 
4480 	while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
4481 		cv_wait(&un->un_suspend_cv, ST_MUTEX);
4482 	}
4483 
4484 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4485 	    "st_strategy(): bcount=0x%lx, fileno=%d, blkno=%x, eof=%d\n",
4486 	    bp->b_bcount, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof);
4487 
4488 	ASSERT((bp == un->un_recov_buf) || (bp == un->un_sbufp));
4489 
4490 	bp->b_flags &= ~(B_DONE);
4491 	st_bioerror(bp, 0);
4492 	bp->av_forw = NULL;
4493 	bp->b_resid = 0;
4494 	SET_BP_PKT(bp, 0);
4495 
4496 
4497 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4498 	    "st_strategy: cmd=0x%x  count=%ld  resid=%ld flags=0x%x"
4499 	    " pkt=0x%p\n",
4500 	    (unsigned char)(uintptr_t)bp->b_forw, bp->b_bcount,
4501 	    bp->b_resid, bp->b_flags, (void *)BP_PKT(bp));
4502 	ST_DO_KSTATS(bp, kstat_waitq_enter);
4503 
4504 	st_start(un);
4505 
4506 	mutex_exit(ST_MUTEX);
4507 	return (0);
4508 }
4509 
4510 /*
4511  * this routine spaces forward over filemarks
4512  */
4513 static int
4514 st_space_fmks(struct scsi_tape *un, int64_t count)
4515 {
4516 	int rval = 0;
4517 
4518 	ST_FUNC(ST_DEVINFO, st_space_fmks);
4519 
4520 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4521 	    "st_space_fmks(dev = 0x%lx, count = %"PRIx64")\n",
4522 	    un->un_dev, count);
4523 
4524 	ASSERT(mutex_owned(ST_MUTEX));
4525 
4526 	/*
4527 	 * the risk with doing only one space operation is that we
4528 	 * may accidentily jump in old data
4529 	 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
4530 	 * because the 8200 does not append a marker; in order not to
4531 	 * sacrifice the fast file skip, we do a slow skip if the low
4532 	 * density device has been opened
4533 	 */
4534 
4535 	if ((un->un_dp->options & ST_KNOWS_EOD) &&
4536 	    !((un->un_dp->type == ST_TYPE_EXB8500 &&
4537 	    MT_DENSITY(un->un_dev) == 0))) {
4538 		if (st_cmd(un, SCMD_SPACE, Fmk(count), SYNC_CMD)) {
4539 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4540 			    "space_fmks : EIO can't do space cmd #1\n");
4541 			rval = EIO;
4542 		}
4543 	} else {
4544 		while (count > 0) {
4545 			if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) {
4546 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4547 				    "space_fmks : EIO can't do space cmd #2\n");
4548 				rval = EIO;
4549 				break;
4550 			}
4551 			count -= 1;
4552 			/*
4553 			 * read a block to see if we have reached
4554 			 * end of medium (double filemark for reel or
4555 			 * medium error for others)
4556 			 */
4557 			if (count > 0) {
4558 				if (st_cmd(un, SCMD_SPACE, Blk(1), SYNC_CMD)) {
4559 					ST_DEBUG2(ST_DEVINFO, st_label,
4560 					    SCSI_DEBUG,
4561 					    "space_fmks : EIO can't do "
4562 					    "space cmd #3\n");
4563 					rval = EIO;
4564 					break;
4565 				}
4566 				if ((un->un_pos.eof >= ST_EOF_PENDING) &&
4567 				    (un->un_dp->options & ST_REEL)) {
4568 					un->un_status = SUN_KEY_EOT;
4569 					ST_DEBUG2(ST_DEVINFO, st_label,
4570 					    SCSI_DEBUG,
4571 					    "space_fmks : EIO ST_REEL\n");
4572 					rval = EIO;
4573 					break;
4574 				} else if (IN_EOF(un->un_pos)) {
4575 					un->un_pos.eof = ST_NO_EOF;
4576 					un->un_pos.fileno++;
4577 					un->un_pos.blkno = 0;
4578 					count--;
4579 				} else if (un->un_pos.eof > ST_EOF) {
4580 					ST_DEBUG2(ST_DEVINFO, st_label,
4581 					    SCSI_DEBUG,
4582 					    "space_fmks, EIO > ST_EOF\n");
4583 					rval = EIO;
4584 					break;
4585 				}
4586 
4587 			}
4588 		}
4589 		un->un_err_resid = count;
4590 		COPY_POS(&un->un_pos, &un->un_err_pos);
4591 	}
4592 	ASSERT(mutex_owned(ST_MUTEX));
4593 	return (rval);
4594 }
4595 
4596 /*
4597  * this routine spaces to EOD
4598  *
4599  * it keeps track of the current filenumber and returns the filenumber after
4600  * the last successful space operation, we keep the number high because as
4601  * tapes are getting larger, the possibility of more and more files exist,
4602  * 0x100000 (1 Meg of files) probably will never have to be changed any time
4603  * soon
4604  */
4605 #define	MAX_SKIP	0x100000 /* somewhat arbitrary */
4606 
4607 static int
4608 st_find_eod(struct scsi_tape *un)
4609 {
4610 	tapepos_t savepos;
4611 	int64_t sp_type;
4612 	int result;
4613 
4614 	if (un == NULL) {
4615 		return (-1);
4616 	}
4617 
4618 	ST_FUNC(ST_DEVINFO, st_find_eod);
4619 
4620 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4621 	    "st_find_eod(dev = 0x%lx): fileno = %d\n", un->un_dev,
4622 	    un->un_pos.fileno);
4623 
4624 	ASSERT(mutex_owned(ST_MUTEX));
4625 
4626 	COPY_POS(&savepos, &un->un_pos);
4627 
4628 	/*
4629 	 * see if the drive is smart enough to do the skips in
4630 	 * one operation; 1/2" use two filemarks
4631 	 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
4632 	 * because the 8200 does not append a marker; in order not to
4633 	 * sacrifice the fast file skip, we do a slow skip if the low
4634 	 * density device has been opened
4635 	 */
4636 	if ((un->un_dp->options & ST_KNOWS_EOD) != 0) {
4637 		if ((un->un_dp->type == ST_TYPE_EXB8500) &&
4638 		    (MT_DENSITY(un->un_dev) == 0)) {
4639 			sp_type = Fmk(1);
4640 		} else if (un->un_pos.pmode == logical) {
4641 			sp_type = SPACE(SP_EOD, 0);
4642 		} else {
4643 			sp_type = Fmk(MAX_SKIP);
4644 		}
4645 	} else {
4646 		sp_type = Fmk(1);
4647 	}
4648 
4649 	for (;;) {
4650 		result = st_cmd(un, SCMD_SPACE, sp_type, SYNC_CMD);
4651 
4652 		if (result == 0) {
4653 			COPY_POS(&savepos, &un->un_pos);
4654 		}
4655 
4656 		if (sp_type == SPACE(SP_EOD, 0)) {
4657 			if (result != 0) {
4658 				sp_type = Fmk(MAX_SKIP);
4659 				continue;
4660 			}
4661 
4662 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4663 			    "st_find_eod: 0x%"PRIx64"\n",
4664 			    savepos.lgclblkno);
4665 			/*
4666 			 * What we return will become the current file position.
4667 			 * After completing the space command with the position
4668 			 * mode that is not invalid a read position command will
4669 			 * be automaticly issued. If the drive support the long
4670 			 * read position format a valid file position can be
4671 			 * returned.
4672 			 */
4673 			return (un->un_pos.fileno);
4674 		}
4675 
4676 		if (result != 0) {
4677 			break;
4678 		}
4679 
4680 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4681 		    "count=%"PRIx64", eof=%x, status=%x\n",
4682 		    SPACE_CNT(sp_type),  un->un_pos.eof, un->un_status);
4683 
4684 		/*
4685 		 * If we're not EOM smart,  space a record
4686 		 * to see whether we're now in the slot between
4687 		 * the two sequential filemarks that logical
4688 		 * EOM consists of (REEL) or hit nowhere land
4689 		 * (8mm).
4690 		 */
4691 		if (sp_type == Fmk(1)) {
4692 			/*
4693 			 * no fast skipping, check a record
4694 			 */
4695 			if (st_cmd(un, SCMD_SPACE, Blk((1)), SYNC_CMD)) {
4696 				break;
4697 			}
4698 			if ((un->un_pos.eof >= ST_EOF_PENDING) &&
4699 			    (un->un_dp->options & ST_REEL)) {
4700 				un->un_status = KEY_BLANK_CHECK;
4701 				un->un_pos.fileno++;
4702 				un->un_pos.blkno = 0;
4703 				break;
4704 			}
4705 			if (IN_EOF(un->un_pos)) {
4706 				un->un_pos.eof = ST_NO_EOF;
4707 				un->un_pos.fileno++;
4708 				un->un_pos.blkno = 0;
4709 			}
4710 			if (un->un_pos.eof > ST_EOF) {
4711 				break;
4712 			}
4713 		} else {
4714 			if (un->un_pos.eof > ST_EOF) {
4715 				break;
4716 			}
4717 		}
4718 	}
4719 
4720 	if (un->un_dp->options & ST_KNOWS_EOD) {
4721 		COPY_POS(&savepos, &un->un_pos);
4722 	}
4723 
4724 	ASSERT(mutex_owned(ST_MUTEX));
4725 
4726 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
4727 	    "st_find_eod: %x\n", savepos.fileno);
4728 	return (savepos.fileno);
4729 }
4730 
4731 
4732 /*
4733  * this routine is frequently used in ioctls below;
4734  * it determines whether we know the density and if not will
4735  * determine it
4736  * if we have written the tape before, one or more filemarks are written
4737  *
4738  * depending on the stepflag, the head is repositioned to where it was before
4739  * the filemarks were written in order not to confuse step counts
4740  */
4741 #define	STEPBACK    0
4742 #define	NO_STEPBACK 1
4743 
4744 static int
4745 st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag)
4746 {
4747 
4748 	GET_SOFT_STATE(dev);
4749 
4750 	ST_FUNC(ST_DEVINFO, st_check_density_or_wfm);
4751 
4752 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4753 	    "st_check_density_or_wfm(dev= 0x%lx, wfm= %d, mode= %d, stpflg= %d)"
4754 	    "\n", dev, wfm, mode, stepflag);
4755 
4756 	ASSERT(mutex_owned(ST_MUTEX));
4757 
4758 	/*
4759 	 * If we don't yet know the density of the tape we have inserted,
4760 	 * we have to either unconditionally set it (if we're 'writing'),
4761 	 * or we have to determine it. As side effects, check for any
4762 	 * write-protect errors, and for the need to put out any file-marks
4763 	 * before positioning a tape.
4764 	 *
4765 	 * If we are going to be spacing forward, and we haven't determined
4766 	 * the tape density yet, we have to do so now...
4767 	 */
4768 	if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
4769 		if (st_determine_density(un, mode)) {
4770 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4771 			    "check_density_or_wfm : EIO can't determine "
4772 			    "density\n");
4773 			un->un_errno = EIO;
4774 			return (EIO);
4775 		}
4776 		/*
4777 		 * Presumably we are at BOT. If we attempt to write, it will
4778 		 * either work okay, or bomb. We don't do a st_test_append
4779 		 * unless we're past BOT.
4780 		 */
4781 		un->un_laststate = un->un_state;
4782 		un->un_state = ST_STATE_OPEN;
4783 
4784 	} else if (un->un_pos.pmode != invalid && un->un_fmneeded > 0 &&
4785 	    ((un->un_lastop == ST_OP_WEOF && wfm) ||
4786 	    (un->un_lastop == ST_OP_WRITE && wfm))) {
4787 
4788 		tapepos_t spos;
4789 
4790 		COPY_POS(&spos, &un->un_pos);
4791 
4792 		/*
4793 		 * We need to write one or two filemarks.
4794 		 * In the case of the HP, we need to
4795 		 * position the head between the two
4796 		 * marks.
4797 		 */
4798 		if ((un->un_fmneeded > 0) || (un->un_lastop == ST_OP_WEOF)) {
4799 			wfm = un->un_fmneeded;
4800 			un->un_fmneeded = 0;
4801 		}
4802 
4803 		if (st_write_fm(dev, wfm)) {
4804 			un->un_pos.pmode = invalid;
4805 			un->un_density_known = 0;
4806 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4807 			    "check_density_or_wfm : EIO can't write fm\n");
4808 			un->un_errno = EIO;
4809 			return (EIO);
4810 		}
4811 
4812 		if (stepflag == STEPBACK) {
4813 			if (st_cmd(un, SCMD_SPACE, Fmk(-wfm), SYNC_CMD)) {
4814 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4815 				    "check_density_or_wfm : EIO can't space "
4816 				    "(-wfm)\n");
4817 				un->un_errno = EIO;
4818 				return (EIO);
4819 			}
4820 			COPY_POS(&un->un_pos, &spos);
4821 		}
4822 	}
4823 
4824 	/*
4825 	 * Whatever we do at this point clears the state of the eof flag.
4826 	 */
4827 
4828 	un->un_pos.eof = ST_NO_EOF;
4829 
4830 	/*
4831 	 * If writing, let's check that we're positioned correctly
4832 	 * at the end of tape before issuing the next write.
4833 	 */
4834 	if (un->un_read_only == RDWR) {
4835 		un->un_test_append = 1;
4836 	}
4837 
4838 	ASSERT(mutex_owned(ST_MUTEX));
4839 	return (0);
4840 }
4841 
4842 
4843 /*
4844  * Wait for all outstaning I/O's to complete
4845  *
4846  * we wait on both ncmds and the wait queue for times when we are flushing
4847  * after persistent errors are flagged, which is when ncmds can be 0, and the
4848  * queue can still have I/O's.  This way we preserve order of biodone's.
4849  */
4850 static void
4851 st_wait_for_io(struct scsi_tape *un)
4852 {
4853 	ST_FUNC(ST_DEVINFO, st_wait_for_io);
4854 	ASSERT(mutex_owned(ST_MUTEX));
4855 	while ((un->un_ncmds) || (un->un_quef) || (un->un_runqf)) {
4856 		cv_wait(&un->un_queue_cv, ST_MUTEX);
4857 	}
4858 }
4859 
4860 /*
4861  * This routine implements the ioctl calls.  It is called
4862  * from the device switch at normal priority.
4863  */
4864 /*ARGSUSED*/
4865 static int
4866 st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p,
4867     int *rval_p)
4868 {
4869 	int tmp, rval = 0;
4870 
4871 	GET_SOFT_STATE(dev);
4872 
4873 	ST_ENTR(ST_DEVINFO, st_ioctl);
4874 
4875 	mutex_enter(ST_MUTEX);
4876 
4877 	ASSERT(un->un_recov_buf_busy == 0);
4878 
4879 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4880 	    "st_ioctl(): fileno=%x, blkno=%x, eof=%x, state = %d, "
4881 	    "pe_flag = %d\n",
4882 	    un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof, un->un_state,
4883 	    un->un_persistence && un->un_persist_errors);
4884 
4885 	/*
4886 	 * We don't want to block on these, so let them through
4887 	 * and we don't care about setting driver states here.
4888 	 */
4889 	if ((cmd == MTIOCGETDRIVETYPE) ||
4890 	    (cmd == MTIOCGUARANTEEDORDER) ||
4891 	    (cmd == MTIOCPERSISTENTSTATUS)) {
4892 		goto check_commands;
4893 	}
4894 
4895 	/*
4896 	 * We clear error entry stack except command
4897 	 * MTIOCGETERROR and MTIOCGET
4898 	 */
4899 	if ((cmd != MTIOCGETERROR) &&
4900 	    (cmd != MTIOCGET)) {
4901 		st_empty_error_stack(un);
4902 	}
4903 
4904 	/*
4905 	 * wait for all outstanding commands to complete, or be dequeued.
4906 	 * And because ioctl's are synchronous commands, any return value
4907 	 * after this,  will be in order
4908 	 */
4909 	st_wait_for_io(un);
4910 
4911 	/*
4912 	 * allow only a through clear errors and persistent status, and
4913 	 * status
4914 	 */
4915 	if (un->un_persistence && un->un_persist_errors) {
4916 		if ((cmd == MTIOCLRERR) ||
4917 		    (cmd == MTIOCPERSISTENT) ||
4918 		    (cmd == MTIOCGET)) {
4919 			goto check_commands;
4920 		} else {
4921 			rval = un->un_errno;
4922 			goto exit;
4923 		}
4924 	}
4925 
4926 	ASSERT(un->un_throttle != 0);
4927 	un->un_throttle = 1;	/* > 1 will never happen here */
4928 	un->un_errno = 0;	/* start clean from here */
4929 
4930 	/*
4931 	 * first and foremost, handle any ST_EOT_PENDING cases.
4932 	 * That is, if a logical eot is pending notice, notice it.
4933 	 */
4934 	if (un->un_pos.eof == ST_EOT_PENDING) {
4935 		int resid = un->un_err_resid;
4936 		uchar_t status = un->un_status;
4937 		uchar_t lastop = un->un_lastop;
4938 
4939 		if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) {
4940 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4941 			    "stioctl : EIO can't space fmk(-1)\n");
4942 			rval = EIO;
4943 			goto exit;
4944 		}
4945 		un->un_lastop = lastop; /* restore last operation */
4946 		if (status == SUN_KEY_EOF) {
4947 			un->un_status = SUN_KEY_EOT;
4948 		} else {
4949 			un->un_status = status;
4950 		}
4951 		un->un_err_resid  = resid;
4952 		/* fix up block number */
4953 		un->un_err_pos.blkno = un->un_pos.blkno = 0;
4954 		/* now we're at logical eot */
4955 		un->un_pos.eof = ST_EOT;
4956 	}
4957 
4958 	/*
4959 	 * now, handle the rest of the situations
4960 	 */
4961 check_commands:
4962 	switch (cmd) {
4963 	case MTIOCGET:
4964 	{
4965 #ifdef _MULTI_DATAMODEL
4966 		/*
4967 		 * For use when a 32 bit app makes a call into a
4968 		 * 64 bit ioctl
4969 		 */
4970 		struct mtget32		mtg_local32;
4971 		struct mtget32 		*mtget_32 = &mtg_local32;
4972 #endif /* _MULTI_DATAMODEL */
4973 
4974 			/* Get tape status */
4975 		struct mtget mtg_local;
4976 		struct mtget *mtget = &mtg_local;
4977 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4978 		    "st_ioctl: MTIOCGET\n");
4979 
4980 		bzero((caddr_t)mtget, sizeof (struct mtget));
4981 		mtget->mt_erreg = un->un_status;
4982 		mtget->mt_resid = un->un_err_resid;
4983 		mtget->mt_dsreg = un->un_retry_ct;
4984 		if (un->un_err_pos.pmode == legacy) {
4985 			mtget->mt_fileno = un->un_err_pos.fileno;
4986 		} else {
4987 			mtget->mt_fileno = -1;
4988 		}
4989 		/*
4990 		 * If the value is positive fine.
4991 		 * If its negative we need to return a value based on the
4992 		 * old way if counting backwards from INF (1,000,000,000).
4993 		 */
4994 		if (un->un_err_pos.blkno >= 0) {
4995 			mtget->mt_blkno = un->un_err_pos.blkno;
4996 		} else {
4997 			mtget->mt_blkno = INF + 1 - (-un->un_err_pos.blkno);
4998 		}
4999 		mtget->mt_type = un->un_dp->type;
5000 		mtget->mt_flags = MTF_SCSI | MTF_ASF;
5001 		if (un->un_read_pos_type != NO_POS) {
5002 			mtget->mt_flags |= MTF_LOGICAL_BLOCK;
5003 		}
5004 		if (un->un_dp->options & ST_REEL) {
5005 			mtget->mt_flags |= MTF_REEL;
5006 			mtget->mt_bf = 20;
5007 		} else {		/* 1/4" cartridges */
5008 			switch (mtget->mt_type) {
5009 			/* Emulex cartridge tape */
5010 			case MT_ISMT02:
5011 				mtget->mt_bf = 40;
5012 				break;
5013 			default:
5014 				mtget->mt_bf = 126;
5015 				break;
5016 			}
5017 		}
5018 
5019 		/*
5020 		 * If large transfers are allowed and drive options
5021 		 * has no record size limit set. Calculate blocking
5022 		 * factor from the lesser of maxbsize and maxdma.
5023 		 */
5024 		if ((un->un_allow_large_xfer) &&
5025 		    (un->un_dp->options & ST_NO_RECSIZE_LIMIT)) {
5026 			mtget->mt_bf = min(un->un_maxbsize,
5027 			    un->un_maxdma) / SECSIZE;
5028 		}
5029 
5030 		if (un->un_read_only == WORM ||
5031 		    un->un_read_only == RDWORM) {
5032 			mtget->mt_flags |= MTF_WORM_MEDIA;
5033 		}
5034 
5035 		/*
5036 		 * In persistent error mode sending a non-queued can hang
5037 		 * because this ioctl gets to be run without turning off
5038 		 * persistense. Fake the answer based on previous info.
5039 		 */
5040 		if (un->un_persistence) {
5041 			rval = 0;
5042 		} else {
5043 			rval = st_check_clean_bit(un);
5044 		}
5045 		if (rval == 0) {
5046 			/*
5047 			 * If zero is returned or in persistent mode,
5048 			 * use the old data.
5049 			 */
5050 			if ((un->un_HeadClean & (TAPE_ALERT_SUPPORTED |
5051 			    TAPE_SEQUENTIAL_SUPPORTED|TAPE_ALERT_NOT_SUPPORTED))
5052 			    != TAPE_ALERT_NOT_SUPPORTED) {
5053 				mtget->mt_flags |= MTF_TAPE_CLN_SUPPORTED;
5054 			}
5055 			if (un->un_HeadClean & (TAPE_PREVIOUSLY_DIRTY |
5056 			    TAPE_ALERT_STILL_DIRTY)) {
5057 				mtget->mt_flags |= MTF_TAPE_HEAD_DIRTY;
5058 			}
5059 		} else {
5060 			mtget->mt_flags |= (ushort_t)rval;
5061 			rval = 0;
5062 		}
5063 
5064 		un->un_status = 0;		/* Reset status */
5065 		un->un_err_resid = 0;
5066 		tmp = sizeof (struct mtget);
5067 
5068 #ifdef _MULTI_DATAMODEL
5069 
5070 		switch (ddi_model_convert_from(flag & FMODELS)) {
5071 		case DDI_MODEL_ILP32:
5072 			/*
5073 			 * Convert 64 bit back to 32 bit before doing
5074 			 * copyout. This is what the ILP32 app expects.
5075 			 */
5076 			mtget_32->mt_erreg = 	mtget->mt_erreg;
5077 			mtget_32->mt_resid = 	mtget->mt_resid;
5078 			mtget_32->mt_dsreg = 	mtget->mt_dsreg;
5079 			mtget_32->mt_fileno = 	(daddr32_t)mtget->mt_fileno;
5080 			mtget_32->mt_blkno = 	(daddr32_t)mtget->mt_blkno;
5081 			mtget_32->mt_type =  	mtget->mt_type;
5082 			mtget_32->mt_flags = 	mtget->mt_flags;
5083 			mtget_32->mt_bf = 	mtget->mt_bf;
5084 
5085 			if (ddi_copyout(mtget_32, (void *)arg,
5086 			    sizeof (struct mtget32), flag)) {
5087 				rval = EFAULT;
5088 			}
5089 			break;
5090 
5091 		case DDI_MODEL_NONE:
5092 			if (ddi_copyout(mtget, (void *)arg, tmp, flag)) {
5093 				rval = EFAULT;
5094 			}
5095 			break;
5096 		}
5097 #else /* ! _MULTI_DATAMODE */
5098 		if (ddi_copyout(mtget, (void *)arg, tmp, flag)) {
5099 			rval = EFAULT;
5100 		}
5101 #endif /* _MULTI_DATAMODE */
5102 
5103 		break;
5104 	}
5105 	case MTIOCGETERROR:
5106 			/*
5107 			 * get error entry from error stack
5108 			 */
5109 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5110 			    "st_ioctl: MTIOCGETERROR\n");
5111 
5112 			rval = st_get_error_entry(un, arg, flag);
5113 
5114 			break;
5115 
5116 	case MTIOCSTATE:
5117 		{
5118 			/*
5119 			 * return when media presence matches state
5120 			 */
5121 			enum mtio_state state;
5122 
5123 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5124 			    "st_ioctl: MTIOCSTATE\n");
5125 
5126 			if (ddi_copyin((void *)arg, &state, sizeof (int), flag))
5127 				rval = EFAULT;
5128 
5129 			mutex_exit(ST_MUTEX);
5130 
5131 			rval = st_check_media(dev, state);
5132 
5133 			mutex_enter(ST_MUTEX);
5134 
5135 			if (rval != 0) {
5136 				break;
5137 			}
5138 
5139 			if (ddi_copyout(&un->un_mediastate, (void *)arg,
5140 			    sizeof (int), flag))
5141 				rval = EFAULT;
5142 			break;
5143 
5144 		}
5145 
5146 	case MTIOCGETDRIVETYPE:
5147 		{
5148 #ifdef _MULTI_DATAMODEL
5149 		/*
5150 		 * For use when a 32 bit app makes a call into a
5151 		 * 64 bit ioctl
5152 		 */
5153 		struct mtdrivetype_request32	mtdtrq32;
5154 #endif /* _MULTI_DATAMODEL */
5155 
5156 			/*
5157 			 * return mtdrivetype
5158 			 */
5159 			struct mtdrivetype_request mtdtrq;
5160 			struct mtdrivetype mtdrtyp;
5161 			struct mtdrivetype *mtdt = &mtdrtyp;
5162 			struct st_drivetype *stdt = un->un_dp;
5163 
5164 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5165 			    "st_ioctl: MTIOCGETDRIVETYPE\n");
5166 
5167 #ifdef _MULTI_DATAMODEL
5168 		switch (ddi_model_convert_from(flag & FMODELS)) {
5169 		case DDI_MODEL_ILP32:
5170 		{
5171 			if (ddi_copyin((void *)arg, &mtdtrq32,
5172 			    sizeof (struct mtdrivetype_request32), flag)) {
5173 				rval = EFAULT;
5174 				break;
5175 			}
5176 			mtdtrq.size = mtdtrq32.size;
5177 			mtdtrq.mtdtp =
5178 			    (struct  mtdrivetype *)(uintptr_t)mtdtrq32.mtdtp;
5179 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5180 			    "st_ioctl: size 0x%x\n", mtdtrq.size);
5181 			break;
5182 		}
5183 		case DDI_MODEL_NONE:
5184 			if (ddi_copyin((void *)arg, &mtdtrq,
5185 			    sizeof (struct mtdrivetype_request), flag)) {
5186 				rval = EFAULT;
5187 				break;
5188 			}
5189 			break;
5190 		}
5191 
5192 #else /* ! _MULTI_DATAMODEL */
5193 		if (ddi_copyin((void *)arg, &mtdtrq,
5194 		    sizeof (struct mtdrivetype_request), flag)) {
5195 			rval = EFAULT;
5196 			break;
5197 		}
5198 #endif /* _MULTI_DATAMODEL */
5199 
5200 			/*
5201 			 * if requested size is < 0 then return
5202 			 * error.
5203 			 */
5204 			if (mtdtrq.size < 0) {
5205 				rval = EINVAL;
5206 				break;
5207 			}
5208 			bzero(mtdt, sizeof (struct mtdrivetype));
5209 			(void) strncpy(mtdt->name, stdt->name, ST_NAMESIZE);
5210 			(void) strncpy(mtdt->vid, stdt->vid, VIDPIDLEN - 1);
5211 			mtdt->type = stdt->type;
5212 			mtdt->bsize = stdt->bsize;
5213 			mtdt->options = stdt->options;
5214 			mtdt->max_rretries = stdt->max_rretries;
5215 			mtdt->max_wretries = stdt->max_wretries;
5216 			for (tmp = 0; tmp < NDENSITIES; tmp++) {
5217 				mtdt->densities[tmp] = stdt->densities[tmp];
5218 			}
5219 			mtdt->default_density = stdt->default_density;
5220 			/*
5221 			 * Speed hasn't been used since the hayday of reel tape.
5222 			 * For all drives not setting the option ST_KNOWS_MEDIA
5223 			 * the speed member renamed to mediatype are zeros.
5224 			 * Those drives that have ST_KNOWS_MEDIA set use the
5225 			 * new mediatype member which is used to figure the
5226 			 * type of media loaded.
5227 			 *
5228 			 * So as to not break applications speed in the
5229 			 * mtdrivetype structure is not renamed.
5230 			 */
5231 			for (tmp = 0; tmp < NDENSITIES; tmp++) {
5232 				mtdt->speeds[tmp] = stdt->mediatype[tmp];
5233 			}
5234 			mtdt->non_motion_timeout = stdt->non_motion_timeout;
5235 			mtdt->io_timeout = stdt->io_timeout;
5236 			mtdt->rewind_timeout = stdt->rewind_timeout;
5237 			mtdt->space_timeout = stdt->space_timeout;
5238 			mtdt->load_timeout = stdt->load_timeout;
5239 			mtdt->unload_timeout = stdt->unload_timeout;
5240 			mtdt->erase_timeout = stdt->erase_timeout;
5241 
5242 			/*
5243 			 * Limit the maximum length of the result to
5244 			 * sizeof (struct mtdrivetype).
5245 			 */
5246 			tmp = sizeof (struct mtdrivetype);
5247 			if (mtdtrq.size < tmp)
5248 				tmp = mtdtrq.size;
5249 			if (ddi_copyout(mtdt, mtdtrq.mtdtp, tmp, flag)) {
5250 				rval = EFAULT;
5251 			}
5252 			break;
5253 		}
5254 	case MTIOCPERSISTENT:
5255 
5256 		if (ddi_copyin((void *)arg, &tmp, sizeof (tmp), flag)) {
5257 			rval = EFAULT;
5258 			break;
5259 		}
5260 
5261 		if (tmp) {
5262 			st_turn_pe_on(un);
5263 		} else {
5264 			st_turn_pe_off(un);
5265 		}
5266 
5267 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5268 		    "st_ioctl: MTIOCPERSISTENT : persistence = %d\n",
5269 		    un->un_persistence);
5270 
5271 		break;
5272 
5273 	case MTIOCPERSISTENTSTATUS:
5274 		tmp = (int)un->un_persistence;
5275 
5276 		if (ddi_copyout(&tmp, (void *)arg, sizeof (tmp), flag)) {
5277 			rval = EFAULT;
5278 		}
5279 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5280 		    "st_ioctl: MTIOCPERSISTENTSTATUS:persistence = %d\n",
5281 		    un->un_persistence);
5282 
5283 		break;
5284 
5285 	case MTIOCLRERR:
5286 		{
5287 			/* clear persistent errors */
5288 
5289 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5290 			    "st_ioctl: MTIOCLRERR\n");
5291 
5292 			st_clear_pe(un);
5293 
5294 			break;
5295 		}
5296 
5297 	case MTIOCGUARANTEEDORDER:
5298 		{
5299 			/*
5300 			 * this is just a holder to make a valid ioctl and
5301 			 * it won't be in any earlier release
5302 			 */
5303 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5304 			    "st_ioctl: MTIOCGUARANTEEDORDER\n");
5305 
5306 			break;
5307 		}
5308 
5309 	case MTIOCRESERVE:
5310 		{
5311 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5312 			    "st_ioctl: MTIOCRESERVE\n");
5313 
5314 			/*
5315 			 * Check if Reserve/Release is supported.
5316 			 */
5317 			if (un->un_dp->options & ST_NO_RESERVE_RELEASE) {
5318 				rval = ENOTTY;
5319 				break;
5320 			}
5321 
5322 			rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd);
5323 
5324 			if (rval == 0) {
5325 				un->un_rsvd_status |= ST_PRESERVE_RESERVE;
5326 			}
5327 			break;
5328 		}
5329 
5330 	case MTIOCRELEASE:
5331 		{
5332 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5333 			    "st_ioctl: MTIOCRELEASE\n");
5334 
5335 			/*
5336 			 * Check if Reserve/Release is supported.
5337 			 */
5338 			if (un->un_dp->options & ST_NO_RESERVE_RELEASE) {
5339 				rval = ENOTTY;
5340 				break;
5341 			}
5342 
5343 			/*
5344 			 * Used to just clear ST_PRESERVE_RESERVE which
5345 			 * made the reservation release at next close.
5346 			 * As the user may have opened and then done a
5347 			 * persistant reservation we now need to drop
5348 			 * the reservation without closing if the user
5349 			 * attempts to do this.
5350 			 */
5351 			rval = st_reserve_release(un, ST_RELEASE, st_uscsi_cmd);
5352 
5353 			un->un_rsvd_status &= ~ST_PRESERVE_RESERVE;
5354 
5355 			break;
5356 		}
5357 
5358 	case MTIOCFORCERESERVE:
5359 	{
5360 		ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5361 		    "st_ioctl: MTIOCFORCERESERVE\n");
5362 
5363 		/*
5364 		 * Check if Reserve/Release is supported.
5365 		 */
5366 		if (un->un_dp->options & ST_NO_RESERVE_RELEASE) {
5367 			rval = ENOTTY;
5368 			break;
5369 		}
5370 		/*
5371 		 * allow only super user to run this.
5372 		 */
5373 		if (drv_priv(cred_p) != 0) {
5374 			rval = EPERM;
5375 			break;
5376 		}
5377 		/*
5378 		 * Throw away reserve,
5379 		 * not using test-unit-ready
5380 		 * since reserve can succeed without tape being
5381 		 * present in the drive.
5382 		 */
5383 		(void) st_reserve_release(un, ST_RESERVE, st_uscsi_cmd);
5384 
5385 		rval = st_take_ownership(un, st_uscsi_cmd);
5386 
5387 		break;
5388 	}
5389 
5390 	case USCSICMD:
5391 	{
5392 		cred_t	*cr;
5393 
5394 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5395 		    "st_ioctl: USCSICMD\n");
5396 
5397 		cr = ddi_get_cred();
5398 		if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) {
5399 			rval = EPERM;
5400 		} else {
5401 			rval = st_uscsi_cmd(un, (struct uscsi_cmd *)arg, flag);
5402 		}
5403 		break;
5404 	}
5405 	case MTIOCTOP:
5406 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5407 		    "st_ioctl: MTIOCTOP\n");
5408 		rval = st_mtioctop(un, arg, flag);
5409 		break;
5410 
5411 	case MTIOCLTOP:
5412 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5413 		    "st_ioctl: MTIOLCTOP\n");
5414 		rval = st_mtiocltop(un, arg, flag);
5415 		break;
5416 
5417 	case MTIOCREADIGNOREILI:
5418 		{
5419 			int set_ili;
5420 
5421 			if (ddi_copyin((void *)arg, &set_ili,
5422 			    sizeof (set_ili), flag)) {
5423 				rval = EFAULT;
5424 				break;
5425 			}
5426 
5427 			if (un->un_bsize) {
5428 				rval = ENOTTY;
5429 				break;
5430 			}
5431 
5432 			switch (set_ili) {
5433 			case 0:
5434 				un->un_dp->options &= ~ST_READ_IGNORE_ILI;
5435 				break;
5436 
5437 			case 1:
5438 				un->un_dp->options |= ST_READ_IGNORE_ILI;
5439 				break;
5440 
5441 			default:
5442 				rval = EINVAL;
5443 				break;
5444 			}
5445 			break;
5446 		}
5447 
5448 	case MTIOCREADIGNOREEOFS:
5449 		{
5450 			int ignore_eof;
5451 
5452 			if (ddi_copyin((void *)arg, &ignore_eof,
5453 			    sizeof (ignore_eof), flag)) {
5454 				rval = EFAULT;
5455 				break;
5456 			}
5457 
5458 			if (!(un->un_dp->options & ST_REEL)) {
5459 				rval = ENOTTY;
5460 				break;
5461 			}
5462 
5463 			switch (ignore_eof) {
5464 			case 0:
5465 				un->un_dp->options &= ~ST_READ_IGNORE_EOFS;
5466 				break;
5467 
5468 			case 1:
5469 				un->un_dp->options |= ST_READ_IGNORE_EOFS;
5470 				break;
5471 
5472 			default:
5473 				rval = EINVAL;
5474 				break;
5475 			}
5476 			break;
5477 		}
5478 
5479 	case MTIOCSHORTFMK:
5480 	{
5481 		int short_fmk;
5482 
5483 		if (ddi_copyin((void *)arg, &short_fmk,
5484 		    sizeof (short_fmk), flag)) {
5485 			rval = EFAULT;
5486 			break;
5487 		}
5488 
5489 		switch (un->un_dp->type) {
5490 		case ST_TYPE_EXB8500:
5491 		case ST_TYPE_EXABYTE:
5492 			if (!short_fmk) {
5493 				un->un_dp->options &= ~ST_SHORT_FILEMARKS;
5494 			} else if (short_fmk == 1) {
5495 				un->un_dp->options |= ST_SHORT_FILEMARKS;
5496 			} else {
5497 				rval = EINVAL;
5498 			}
5499 			break;
5500 
5501 		default:
5502 			rval = ENOTTY;
5503 			break;
5504 		}
5505 		break;
5506 	}
5507 
5508 	case MTIOCGETPOS:
5509 		rval = st_update_block_pos(un, st_cmd, 0);
5510 		if (rval == 0) {
5511 			if (ddi_copyout((void *)&un->un_pos, (void *)arg,
5512 			    sizeof (tapepos_t), flag)) {
5513 				scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
5514 				    "MTIOCGETPOS copy out failed\n");
5515 				rval = EFAULT;
5516 			}
5517 		}
5518 		break;
5519 
5520 	case MTIOCRESTPOS:
5521 	{
5522 		tapepos_t dest;
5523 
5524 		if (ddi_copyin((void *)arg, &dest, sizeof (tapepos_t),
5525 		    flag) != 0) {
5526 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
5527 			    "MTIOCRESTPOS copy in failed\n");
5528 			rval = EFAULT;
5529 			break;
5530 		}
5531 		rval = st_validate_tapemarks(un, st_uscsi_cmd, &dest);
5532 		if (rval != 0) {
5533 			rval = EIO;
5534 		}
5535 		break;
5536 	}
5537 	default:
5538 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5539 		    "st_ioctl: unknown ioctl\n");
5540 		rval = ENOTTY;
5541 	}
5542 
5543 exit:
5544 	if (!(un->un_persistence && un->un_persist_errors)) {
5545 		un->un_errno = rval;
5546 	}
5547 
5548 	mutex_exit(ST_MUTEX);
5549 
5550 	return (rval);
5551 }
5552 
5553 
5554 /*
5555  * do some MTIOCTOP tape operations
5556  */
5557 static int
5558 st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag)
5559 {
5560 #ifdef _MULTI_DATAMODEL
5561 	/*
5562 	 * For use when a 32 bit app makes a call into a
5563 	 * 64 bit ioctl
5564 	 */
5565 	struct mtop32	mtop_32_for_64;
5566 #endif /* _MULTI_DATAMODEL */
5567 	struct mtop passed;
5568 	struct mtlop local;
5569 	int rval = 0;
5570 
5571 	ST_FUNC(ST_DEVINFO, st_mtioctop);
5572 
5573 	ASSERT(mutex_owned(ST_MUTEX));
5574 
5575 #ifdef _MULTI_DATAMODEL
5576 	switch (ddi_model_convert_from(flag & FMODELS)) {
5577 	case DDI_MODEL_ILP32:
5578 		if (ddi_copyin((void *)arg, &mtop_32_for_64,
5579 		    sizeof (struct mtop32), flag)) {
5580 			return (EFAULT);
5581 		}
5582 		local.mt_op = mtop_32_for_64.mt_op;
5583 		local.mt_count =  (int64_t)mtop_32_for_64.mt_count;
5584 		break;
5585 
5586 	case DDI_MODEL_NONE:
5587 		if (ddi_copyin((void *)arg, &passed, sizeof (passed), flag)) {
5588 			return (EFAULT);
5589 		}
5590 		local.mt_op = passed.mt_op;
5591 		/* prevent sign extention */
5592 		local.mt_count = (UINT32_MAX & passed.mt_count);
5593 		break;
5594 	}
5595 
5596 #else /* ! _MULTI_DATAMODEL */
5597 	if (ddi_copyin((void *)arg, &passed, sizeof (passed), flag)) {
5598 		return (EFAULT);
5599 	}
5600 	local.mt_op = passed.mt_op;
5601 	/* prevent sign extention */
5602 	local.mt_count = (UINT32_MAX & passed.mt_count);
5603 #endif /* _MULTI_DATAMODEL */
5604 
5605 	rval = st_do_mtioctop(un, &local);
5606 
5607 #ifdef _MULTI_DATAMODEL
5608 	switch (ddi_model_convert_from(flag & FMODELS)) {
5609 	case DDI_MODEL_ILP32:
5610 		if (((uint64_t)local.mt_count) > UINT32_MAX) {
5611 			rval = ERANGE;
5612 			break;
5613 		}
5614 		/*
5615 		 * Convert 64 bit back to 32 bit before doing
5616 		 * copyout. This is what the ILP32 app expects.
5617 		 */
5618 		mtop_32_for_64.mt_op = local.mt_op;
5619 		mtop_32_for_64.mt_count = local.mt_count;
5620 
5621 		if (ddi_copyout(&mtop_32_for_64, (void *)arg,
5622 		    sizeof (struct mtop32), flag)) {
5623 			rval = EFAULT;
5624 		}
5625 		break;
5626 
5627 	case DDI_MODEL_NONE:
5628 		passed.mt_count = local.mt_count;
5629 		passed.mt_op = local.mt_op;
5630 		if (ddi_copyout(&passed, (void *)arg, sizeof (passed), flag)) {
5631 			rval = EFAULT;
5632 		}
5633 		break;
5634 	}
5635 #else /* ! _MULTI_DATAMODE */
5636 	if (((uint64_t)local.mt_count) > UINT32_MAX) {
5637 		rval = ERANGE;
5638 	} else {
5639 		passed.mt_op = local.mt_op;
5640 		passed.mt_count = local.mt_count;
5641 		if (ddi_copyout(&passed, (void *)arg, sizeof (passed), flag)) {
5642 			rval = EFAULT;
5643 		}
5644 	}
5645 #endif /* _MULTI_DATAMODE */
5646 
5647 
5648 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5649 	    "st_ioctl: fileno=%x, blkno=%x, eof=%x\n", un->un_pos.fileno,
5650 	    un->un_pos.blkno, un->un_pos.eof);
5651 
5652 	if (un->un_pos.pmode == invalid) {
5653 		un->un_density_known = 0;
5654 	}
5655 
5656 	ASSERT(mutex_owned(ST_MUTEX));
5657 	return (rval);
5658 }
5659 
5660 static int
5661 st_mtiocltop(struct scsi_tape *un, intptr_t arg, int flag)
5662 {
5663 	struct mtlop local;
5664 	int rval;
5665 
5666 	ST_FUNC(ST_DEVINFO, st_mtiocltop);
5667 	if (ddi_copyin((void *)arg, &local, sizeof (local), flag)) {
5668 		return (EFAULT);
5669 	}
5670 
5671 	rval = st_do_mtioctop(un, &local);
5672 
5673 	if (ddi_copyout(&local, (void *)arg, sizeof (local), flag)) {
5674 		rval = EFAULT;
5675 	}
5676 	return (rval);
5677 }
5678 
5679 
5680 static int
5681 st_do_mtioctop(struct scsi_tape *un, struct mtlop *mtop)
5682 {
5683 	dev_t dev = un->un_dev;
5684 	int savefile;
5685 	int rval = 0;
5686 
5687 	ST_FUNC(ST_DEVINFO, st_do_mtioctop);
5688 
5689 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5690 	    "st_do_mtioctop(): mt_op=%x\n", mtop->mt_op);
5691 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5692 	    "fileno=%x, blkno=%x, eof=%x\n",
5693 	    un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof);
5694 
5695 	un->un_status = 0;
5696 
5697 	/*
5698 	 * if we are going to mess with a tape, we have to make sure we have
5699 	 * one and are not offline (i.e. no tape is initialized).  We let
5700 	 * commands pass here that don't actually touch the tape, except for
5701 	 * loading and initialization (rewinding).
5702 	 */
5703 	if (un->un_state == ST_STATE_OFFLINE) {
5704 		switch (mtop->mt_op) {
5705 		case MTLOAD:
5706 		case MTNOP:
5707 			/*
5708 			 * We don't want strategy calling st_tape_init here,
5709 			 * so, change state
5710 			 */
5711 			un->un_state = ST_STATE_INITIALIZING;
5712 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5713 			    "st_do_mtioctop : OFFLINE state = %d\n",
5714 			    un->un_state);
5715 			break;
5716 		default:
5717 			/*
5718 			 * reinitialize by normal means
5719 			 */
5720 			rval = st_tape_init(un);
5721 			if (rval) {
5722 				un->un_state = ST_STATE_INITIALIZING;
5723 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5724 				    "st_do_mtioctop : OFFLINE init failure ");
5725 				un->un_state = ST_STATE_OFFLINE;
5726 				un->un_pos.pmode = invalid;
5727 				if (rval != EACCES) {
5728 					rval = EIO;
5729 				}
5730 				return (rval);
5731 			}
5732 			un->un_state = ST_STATE_OPEN_PENDING_IO;
5733 			break;
5734 		}
5735 	}
5736 
5737 	/*
5738 	 * If the file position is invalid, allow only those
5739 	 * commands that properly position the tape and fail
5740 	 * the rest with EIO
5741 	 */
5742 	if (un->un_pos.pmode == invalid) {
5743 		switch (mtop->mt_op) {
5744 		case MTWEOF:
5745 		case MTRETEN:
5746 		case MTERASE:
5747 		case MTEOM:
5748 		case MTFSF:
5749 		case MTFSR:
5750 		case MTBSF:
5751 		case MTNBSF:
5752 		case MTBSR:
5753 		case MTSRSZ:
5754 		case MTGRSZ:
5755 		case MTSEEK:
5756 		case MTBSSF:
5757 		case MTFSSF:
5758 			return (EIO);
5759 			/* NOTREACHED */
5760 		case MTREW:
5761 		case MTLOAD:
5762 		case MTOFFL:
5763 		case MTNOP:
5764 		case MTTELL:
5765 		case MTLOCK:
5766 		case MTUNLOCK:
5767 			break;
5768 
5769 		default:
5770 			return (ENOTTY);
5771 			/* NOTREACHED */
5772 		}
5773 	}
5774 
5775 	switch (mtop->mt_op) {
5776 	case MTERASE:
5777 		/*
5778 		 * MTERASE rewinds the tape, erase it completely, and returns
5779 		 * to the beginning of the tape
5780 		 */
5781 		if (un->un_mspl->wp || un->un_read_only & WORM) {
5782 			un->un_status = KEY_WRITE_PROTECT;
5783 			un->un_err_resid = mtop->mt_count;
5784 			COPY_POS(&un->un_err_pos, &un->un_pos);
5785 			return (EACCES);
5786 		}
5787 		if (un->un_dp->options & ST_REEL) {
5788 			un->un_fmneeded = 2;
5789 		} else {
5790 			un->un_fmneeded = 1;
5791 		}
5792 		mtop->mt_count = mtop->mt_count ? 1 : 0;
5793 		if (st_check_density_or_wfm(dev, 1, B_WRITE, NO_STEPBACK) ||
5794 		    st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) ||
5795 		    st_cmd(un, SCMD_ERASE, mtop->mt_count, SYNC_CMD)) {
5796 			un->un_pos.pmode = invalid;
5797 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5798 			    "st_do_mtioctop : EIO space or erase or "
5799 			    "check den)\n");
5800 			rval = EIO;
5801 		} else {
5802 			/* QIC and helical scan rewind after erase */
5803 			if (un->un_dp->options & ST_REEL) {
5804 				(void) st_cmd(un, SCMD_REWIND, 0, ASYNC_CMD);
5805 			}
5806 		}
5807 		break;
5808 
5809 	case MTWEOF:
5810 		/*
5811 		 * write an end-of-file record
5812 		 */
5813 		if (un->un_mspl->wp || un->un_read_only & RDONLY) {
5814 			un->un_status = KEY_WRITE_PROTECT;
5815 			un->un_err_resid = mtop->mt_count;
5816 			COPY_POS(&un->un_err_pos, &un->un_pos);
5817 			return (EACCES);
5818 		}
5819 
5820 		/*
5821 		 * zero count means just flush buffers
5822 		 * negative count is not permitted
5823 		 */
5824 		if (mtop->mt_count < 0) {
5825 			return (EINVAL);
5826 		}
5827 
5828 		/* Not on worm */
5829 		if (un->un_read_only == RDWR) {
5830 			un->un_test_append = 1;
5831 		}
5832 
5833 		if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
5834 			if (st_determine_density(un, B_WRITE)) {
5835 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5836 				    "st_do_mtioctop : EIO : MTWEOF can't "
5837 				    "determine density");
5838 				return (EIO);
5839 			}
5840 		}
5841 
5842 		rval = st_write_fm(dev, (int)mtop->mt_count);
5843 		if ((rval != 0) && (rval != EACCES)) {
5844 			/*
5845 			 * Failure due to something other than illegal
5846 			 * request results in loss of state (st_intr).
5847 			 */
5848 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5849 			    "st_do_mtioctop : EIO : MTWEOF can't write "
5850 			    "file mark");
5851 			rval = EIO;
5852 		}
5853 		break;
5854 
5855 	case MTRETEN:
5856 		/*
5857 		 * retension the tape
5858 		 */
5859 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK) ||
5860 		    st_cmd(un, SCMD_LOAD, LD_LOAD | LD_RETEN, SYNC_CMD)) {
5861 			un->un_pos.pmode = invalid;
5862 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5863 			    "st_do_mtioctop : EIO : MTRETEN ");
5864 			rval = EIO;
5865 		}
5866 		break;
5867 
5868 	case MTREW:
5869 		/*
5870 		 * rewind  the tape
5871 		 */
5872 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) {
5873 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5874 			    "st_do_mtioctop : EIO:MTREW check "
5875 			    "density/wfm failed");
5876 			return (EIO);
5877 		}
5878 		if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) {
5879 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5880 			    "st_do_mtioctop : EIO : MTREW ");
5881 			rval = EIO;
5882 		}
5883 		break;
5884 
5885 	case MTOFFL:
5886 		/*
5887 		 * rewinds, and, if appropriate, takes the device offline by
5888 		 * unloading the tape
5889 		 */
5890 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) {
5891 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5892 			    "st_do_mtioctop :EIO:MTOFFL check "
5893 			    "density/wfm failed");
5894 			return (EIO);
5895 		}
5896 		(void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD);
5897 		if (st_cmd(un, SCMD_LOAD, LD_UNLOAD, SYNC_CMD)) {
5898 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5899 			    "st_do_mtioctop : EIO : MTOFFL");
5900 			return (EIO);
5901 		}
5902 		un->un_pos.eof = ST_NO_EOF;
5903 		un->un_laststate = un->un_state;
5904 		un->un_state = ST_STATE_OFFLINE;
5905 		un->un_mediastate = MTIO_EJECTED;
5906 		break;
5907 
5908 	case MTLOAD:
5909 		/*
5910 		 * This is to load a tape into the drive
5911 		 * Note that if the tape is not loaded, the device will have
5912 		 * to be opened via O_NDELAY or O_NONBLOCK.
5913 		 */
5914 		/*
5915 		 * Let's try and clean things up, if we are not
5916 		 * initializing, and then send in the load command, no
5917 		 * matter what.
5918 		 *
5919 		 * load after a media change by the user.
5920 		 */
5921 
5922 		if (un->un_state > ST_STATE_INITIALIZING) {
5923 			(void) st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK);
5924 		}
5925 		rval = st_cmd(un, SCMD_LOAD, LD_LOAD, SYNC_CMD);
5926 		/* Load command to a drive that doesn't support load */
5927 		if ((rval == EIO) &&
5928 		    ((un->un_status == KEY_NOT_READY) &&
5929 			/* Medium not present */
5930 		    (un->un_uscsi_rqs_buf->es_add_code == 0x3a) ||
5931 		    ((un->un_status == KEY_ILLEGAL_REQUEST) &&
5932 		    (un->un_dp->type == MT_ISSTK9840) &&
5933 			/* CSL not present */
5934 		    (un->un_uscsi_rqs_buf->es_add_code == 0x80)))) {
5935 			rval = ENOTTY;
5936 			break;
5937 		} else if (rval != EACCES && rval != 0) {
5938 			rval = EIO;
5939 		}
5940 		if (rval) {
5941 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5942 			    "st_do_mtioctop : %s : MTLOAD\n",
5943 			    rval == EACCES ? "EACCES" : "EIO");
5944 			/*
5945 			 * If load tape fails, who knows what happened...
5946 			 */
5947 			un->un_pos.pmode = invalid;
5948 			break;
5949 		}
5950 
5951 		/*
5952 		 * reset all counters appropriately using rewind, as if LOAD
5953 		 * succeeds, we are at BOT
5954 		 */
5955 		un->un_state = ST_STATE_INITIALIZING;
5956 
5957 		rval = st_tape_init(un);
5958 		if ((rval == EACCES) && (un->un_read_only & WORM)) {
5959 			rval = 0;
5960 			break;
5961 		}
5962 
5963 		if (rval != 0) {
5964 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5965 			    "st_do_mtioctop : EIO : MTLOAD calls "
5966 			    "st_tape_init\n");
5967 			rval = EIO;
5968 			un->un_state = ST_STATE_OFFLINE;
5969 		}
5970 
5971 		break;
5972 
5973 	case MTNOP:
5974 		un->un_status = 0;		/* Reset status */
5975 		un->un_err_resid = 0;
5976 		mtop->mt_count = MTUNIT(dev);
5977 		break;
5978 
5979 	case MTEOM:
5980 		/*
5981 		 * positions the tape at a location just after the last file
5982 		 * written on the tape. For cartridge and 8 mm, this after
5983 		 * the last file mark; for reel, this is inbetween the two
5984 		 * last 2 file marks
5985 		 */
5986 		if ((un->un_pos.pmode == legacy && un->un_pos.eof >= ST_EOT) ||
5987 		    (un->un_lastop == ST_OP_WRITE) ||
5988 		    (un->un_lastop == ST_OP_WEOF)) {
5989 			/*
5990 			 * If the command wants to move to logical end
5991 			 * of media, and we're already there, we're done.
5992 			 * If we were at logical eot, we reset the state
5993 			 * to be *not* at logical eot.
5994 			 *
5995 			 * If we're at physical or logical eot, we prohibit
5996 			 * forward space operations (unconditionally).
5997 			 *
5998 			 * Also if the last operation was a write of any
5999 			 * kind the tape is at EOD.
6000 			 */
6001 			return (0);
6002 		}
6003 		/*
6004 		 * physical tape position may not be what we've been
6005 		 * telling the user; adjust the request accordingly
6006 		 */
6007 		if (IN_EOF(un->un_pos)) {
6008 			un->un_pos.fileno++;
6009 			un->un_pos.blkno = 0;
6010 		}
6011 
6012 		if (st_check_density_or_wfm(dev, 1, B_READ, NO_STEPBACK)) {
6013 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6014 			    "st_do_mtioctop : EIO:MTEOM check density/wfm "
6015 			    " failed");
6016 			return (EIO);
6017 		}
6018 
6019 		/*
6020 		 * st_find_eod() returns the last fileno we knew about;
6021 		 */
6022 		savefile = st_find_eod(un);
6023 
6024 		if ((un->un_status != KEY_BLANK_CHECK) &&
6025 		    (un->un_status != SUN_KEY_EOT)) {
6026 			un->un_pos.pmode = invalid;
6027 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6028 			    "st_do_mtioctop : EIO : MTEOM status check failed");
6029 			rval = EIO;
6030 		} else {
6031 			/*
6032 			 * For 1/2" reel tapes assume logical EOT marked
6033 			 * by two file marks or we don't care that we may
6034 			 * be extending the last file on the tape.
6035 			 */
6036 			if (un->un_dp->options & ST_REEL) {
6037 				if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) {
6038 					un->un_pos.pmode = invalid;
6039 					ST_DEBUG2(ST_DEVINFO, st_label,
6040 					    SCSI_DEBUG,
6041 					    "st_do_mtioctop : EIO : MTEOM space"
6042 					    " cmd failed");
6043 					rval = EIO;
6044 					break;
6045 				}
6046 				/*
6047 				 * Fix up the block number.
6048 				 */
6049 				un->un_pos.blkno = 0;
6050 				un->un_err_pos.blkno = 0;
6051 			}
6052 			un->un_err_resid = 0;
6053 			un->un_pos.fileno = savefile;
6054 			un->un_pos.eof = ST_EOT;
6055 		}
6056 		un->un_status = 0;
6057 		break;
6058 
6059 	case MTFSF:
6060 		MAX_SPACE_CNT(mtop->mt_count);
6061 		rval = st_mtfsf_ioctl(un, mtop->mt_count);
6062 		break;
6063 
6064 	case MTFSR:
6065 		MAX_SPACE_CNT(mtop->mt_count);
6066 		rval = st_mtfsr_ioctl(un, mtop->mt_count);
6067 		break;
6068 
6069 	case MTBSF:
6070 		MAX_SPACE_CNT(mtop->mt_count);
6071 		rval = st_mtbsf_ioctl(un, mtop->mt_count);
6072 		break;
6073 
6074 	case MTNBSF:
6075 		MAX_SPACE_CNT(mtop->mt_count);
6076 		rval = st_mtnbsf_ioctl(un, mtop->mt_count);
6077 		break;
6078 
6079 	case MTBSR:
6080 		MAX_SPACE_CNT(mtop->mt_count);
6081 		rval = st_mtbsr_ioctl(un, mtop->mt_count);
6082 		break;
6083 
6084 	case MTBSSF:
6085 		MAX_SPACE_CNT(mtop->mt_count);
6086 		rval = st_mtbsfm_ioctl(un, mtop->mt_count);
6087 		break;
6088 
6089 	case MTFSSF:
6090 		MAX_SPACE_CNT(mtop->mt_count);
6091 		rval = st_mtfsfm_ioctl(un, mtop->mt_count);
6092 		break;
6093 
6094 	case MTSRSZ:
6095 
6096 		/*
6097 		 * Set record-size to that sent by user
6098 		 * Check to see if there is reason that the requested
6099 		 * block size should not be set.
6100 		 */
6101 
6102 		/* If requesting variable block size is it ok? */
6103 		if ((mtop->mt_count == 0) &&
6104 		    ((un->un_dp->options & ST_VARIABLE) == 0)) {
6105 			return (ENOTTY);
6106 		}
6107 
6108 		/*
6109 		 * If requested block size is not variable "0",
6110 		 * is it less then minimum.
6111 		 */
6112 		if ((mtop->mt_count != 0) &&
6113 		    (mtop->mt_count < un->un_minbsize)) {
6114 			return (EINVAL);
6115 		}
6116 
6117 		/* Is the requested block size more then maximum */
6118 		if ((mtop->mt_count > min(un->un_maxbsize, un->un_maxdma)) &&
6119 		    (un->un_maxbsize != 0)) {
6120 			return (EINVAL);
6121 		}
6122 
6123 		/* Is requested block size a modulus the device likes */
6124 		if ((mtop->mt_count % un->un_data_mod) != 0) {
6125 			return (EINVAL);
6126 		}
6127 
6128 		if (st_change_block_size(un, (uint32_t)mtop->mt_count) != 0) {
6129 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6130 			    "st_ioctl : MTSRSZ : EIO : cant set block size");
6131 			return (EIO);
6132 		}
6133 
6134 		return (0);
6135 
6136 	case MTGRSZ:
6137 		/*
6138 		 * Get record-size to the user
6139 		 */
6140 		mtop->mt_count = un->un_bsize;
6141 		rval = 0;
6142 		break;
6143 
6144 	case MTTELL:
6145 		rval = st_update_block_pos(un, st_cmd, 0);
6146 		mtop->mt_count = un->un_pos.lgclblkno;
6147 		break;
6148 
6149 	case MTSEEK:
6150 		rval = st_logical_block_locate(un, st_uscsi_cmd, &un->un_pos,
6151 		    (uint64_t)mtop->mt_count, un->un_pos.partition);
6152 		/*
6153 		 * This bit of magic make mt print the actual position if
6154 		 * the resulting position was not what was asked for.
6155 		 */
6156 		if (rval == ESPIPE) {
6157 			rval = EIO;
6158 			if ((uint64_t)mtop->mt_count != un->un_pos.lgclblkno) {
6159 				mtop->mt_op = MTTELL;
6160 				mtop->mt_count = un->un_pos.lgclblkno;
6161 			}
6162 		}
6163 		break;
6164 
6165 	case MTLOCK:
6166 		if (st_cmd(un, SCMD_DOORLOCK, MR_LOCK, SYNC_CMD)) {
6167 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6168 			    "st_do_mtioctop : EIO : MTLOCK");
6169 			rval = EIO;
6170 		}
6171 		break;
6172 
6173 	case MTUNLOCK:
6174 		if (st_cmd(un, SCMD_DOORLOCK, MR_UNLOCK, SYNC_CMD)) {
6175 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6176 			    "st_do_mtioctop : EIO : MTUNLOCK");
6177 			rval = EIO;
6178 		}
6179 		break;
6180 
6181 	default:
6182 		rval = ENOTTY;
6183 	}
6184 
6185 	return (rval);
6186 }
6187 
6188 
6189 /*
6190  * Run a command for uscsi ioctl.
6191  */
6192 static int
6193 st_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, int flag)
6194 {
6195 	struct uscsi_cmd	*uscmd;
6196 	struct buf	*bp;
6197 	enum uio_seg	uioseg;
6198 	int	offline_state = 0;
6199 	int	err = 0;
6200 	dev_t dev = un->un_dev;
6201 
6202 	ST_FUNC(ST_DEVINFO, st_uscsi_cmd);
6203 
6204 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6205 	    "st_uscsi_cmd(dev = 0x%lx)\n", un->un_dev);
6206 
6207 	ASSERT(mutex_owned(ST_MUTEX));
6208 
6209 	/*
6210 	 * We really don't know what commands are coming in here and
6211 	 * we don't want to limit the commands coming in.
6212 	 *
6213 	 * If st_tape_init() gets called from st_strategy(), then we
6214 	 * will hang the process waiting for un->un_sbuf_busy to be cleared,
6215 	 * which it never will, as we set it below.  To prevent
6216 	 * st_tape_init() from getting called, we have to set state to other
6217 	 * than ST_STATE_OFFLINE, so we choose ST_STATE_INITIALIZING, which
6218 	 * achieves this purpose already.
6219 	 *
6220 	 * We use offline_state to preserve the OFFLINE state, if it exists,
6221 	 * so other entry points to the driver might have the chance to call
6222 	 * st_tape_init().
6223 	 */
6224 	if (un->un_state == ST_STATE_OFFLINE) {
6225 		un->un_laststate = ST_STATE_OFFLINE;
6226 		un->un_state = ST_STATE_INITIALIZING;
6227 		offline_state = 1;
6228 	}
6229 
6230 	mutex_exit(ST_MUTEX);
6231 	err = scsi_uscsi_alloc_and_copyin((intptr_t)ucmd, flag, ROUTE, &uscmd);
6232 	mutex_enter(ST_MUTEX);
6233 	if (err != 0) {
6234 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6235 		    "st_uscsi_cmd: scsi_uscsi_alloc_and_copyin failed\n");
6236 		goto exit;
6237 	}
6238 
6239 	uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE : UIO_USERSPACE;
6240 
6241 	/* check to see if this command requires the drive to be reserved */
6242 	if (uscmd->uscsi_cdb != NULL) {
6243 		err = st_check_cdb_for_need_to_reserve(un,
6244 		    (uchar_t *)uscmd->uscsi_cdb);
6245 		if (err) {
6246 			goto exit_free;
6247 		}
6248 		/*
6249 		 * If this is a space command we need to save the starting
6250 		 * point so we can retry from there if the command fails.
6251 		 */
6252 		if ((uscmd->uscsi_cdb[0] == SCMD_SPACE) ||
6253 		    (uscmd->uscsi_cdb[0] == (char)SCMD_SPACE_G4)) {
6254 			(void) st_update_block_pos(un, st_cmd, 0);
6255 		}
6256 	}
6257 
6258 	/*
6259 	 * Forground should not be doing anything while recovery is active.
6260 	 */
6261 	ASSERT(un->un_recov_buf_busy == 0);
6262 
6263 	/*
6264 	 * Get buffer resources...
6265 	 */
6266 	while (un->un_sbuf_busy)
6267 		cv_wait(&un->un_sbuf_cv, ST_MUTEX);
6268 	un->un_sbuf_busy = 1;
6269 
6270 #ifdef STDEBUG
6271 	if ((uscmd->uscsi_cdb != NULL) && (st_debug & 0x7) > 6) {
6272 		int rw = (uscmd->uscsi_flags & USCSI_READ) ? B_READ : B_WRITE;
6273 		st_print_cdb(ST_DEVINFO, st_label, SCSI_DEBUG,
6274 		    "uscsi cdb", uscmd->uscsi_cdb);
6275 		if (uscmd->uscsi_buflen) {
6276 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6277 			    "uscsi %s of %ld bytes %s %s space\n",
6278 			    (rw == B_READ) ? rd_str : wr_str,
6279 			    uscmd->uscsi_buflen,
6280 			    (rw == B_READ) ? "to" : "from",
6281 			    (uioseg == UIO_SYSSPACE) ? "system" : "user");
6282 		}
6283 	}
6284 #endif /* STDEBUG */
6285 
6286 	/*
6287 	 * Although st_uscsi_cmd() never makes use of these
6288 	 * now, we are just being safe and consistent.
6289 	 */
6290 	uscmd->uscsi_flags &= ~(USCSI_NOINTR | USCSI_NOPARITY |
6291 	    USCSI_OTAG | USCSI_HTAG | USCSI_HEAD);
6292 
6293 	un->un_srqbufp = uscmd->uscsi_rqbuf;
6294 	bp = un->un_sbufp;
6295 	bzero(bp, sizeof (buf_t));
6296 	if (uscmd->uscsi_cdb != NULL) {
6297 		bp->b_forw = (struct buf *)(uintptr_t)uscmd->uscsi_cdb[0];
6298 	}
6299 	bp->b_back = (struct buf *)uscmd;
6300 
6301 	mutex_exit(ST_MUTEX);
6302 	err = scsi_uscsi_handle_cmd(dev, uioseg, uscmd, st_strategy, bp, NULL);
6303 	mutex_enter(ST_MUTEX);
6304 
6305 	/*
6306 	 * If scsi reset successful, don't write any filemarks.
6307 	 */
6308 	if ((err == 0) && (uscmd->uscsi_flags &
6309 	    (USCSI_RESET_LUN | USCSI_RESET_TARGET | USCSI_RESET_ALL))) {
6310 		un->un_fmneeded = 0;
6311 	}
6312 
6313 exit_free:
6314 	/*
6315 	 * Free resources
6316 	 */
6317 	un->un_sbuf_busy = 0;
6318 	un->un_srqbufp = NULL;
6319 
6320 	/*
6321 	 * If was a space command need to update logical block position.
6322 	 * If the command failed such that positioning is invalid, Don't
6323 	 * update the position as the user must do this to validate the
6324 	 * position for data protection.
6325 	 */
6326 	if ((uscmd->uscsi_cdb != NULL) &&
6327 	    ((uscmd->uscsi_cdb[0] == SCMD_SPACE) ||
6328 	    (uscmd->uscsi_cdb[0] == (char)SCMD_SPACE_G4)) &&
6329 	    (un->un_pos.pmode != invalid)) {
6330 		un->un_running.pmode = invalid;
6331 		(void) st_update_block_pos(un, st_cmd, 1);
6332 		/*
6333 		 * Set running position to invalid so it updates on the
6334 		 * next command.
6335 		 */
6336 		un->un_running.pmode = invalid;
6337 	}
6338 	cv_signal(&un->un_sbuf_cv);
6339 	mutex_exit(ST_MUTEX);
6340 	(void) scsi_uscsi_copyout_and_free((intptr_t)ucmd, uscmd);
6341 	mutex_enter(ST_MUTEX);
6342 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6343 	    "st_uscsi_cmd returns 0x%x\n", err);
6344 
6345 exit:
6346 	/* don't lose offline state */
6347 	if (offline_state) {
6348 		un->un_state = ST_STATE_OFFLINE;
6349 	}
6350 
6351 	ASSERT(mutex_owned(ST_MUTEX));
6352 	return (err);
6353 }
6354 
6355 static int
6356 st_write_fm(dev_t dev, int wfm)
6357 {
6358 	int i;
6359 	int rval;
6360 
6361 	GET_SOFT_STATE(dev);
6362 
6363 	ST_FUNC(ST_DEVINFO, st_write_fm);
6364 
6365 	ASSERT(mutex_owned(ST_MUTEX));
6366 
6367 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6368 	    "st_write_fm(dev = 0x%lx, wfm = %d)\n", dev, wfm);
6369 
6370 	/*
6371 	 * write one filemark at the time after EOT
6372 	 */
6373 	if (un->un_pos.eof >= ST_EOT) {
6374 		for (i = 0; i < wfm; i++) {
6375 			rval = st_cmd(un, SCMD_WRITE_FILE_MARK, 1, SYNC_CMD);
6376 			if (rval == EACCES) {
6377 				return (rval);
6378 			}
6379 			if (rval != 0) {
6380 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6381 				    "st_write_fm : EIO : write EOT file mark");
6382 				return (EIO);
6383 			}
6384 		}
6385 	} else {
6386 		rval = st_cmd(un, SCMD_WRITE_FILE_MARK, wfm, SYNC_CMD);
6387 		if (rval == EACCES) {
6388 			return (rval);
6389 		}
6390 		if (rval) {
6391 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6392 			    "st_write_fm : EIO : write file mark");
6393 			return (EIO);
6394 		}
6395 	}
6396 
6397 	ASSERT(mutex_owned(ST_MUTEX));
6398 	return (0);
6399 }
6400 
6401 #ifdef STDEBUG
6402 static void
6403 st_start_dump(struct scsi_tape *un, struct buf *bp)
6404 {
6405 	struct scsi_pkt *pkt = BP_PKT(bp);
6406 	uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp;
6407 
6408 	ST_FUNC(ST_DEVINFO, st_start_dump);
6409 
6410 	if ((st_debug & 0x7) < 6)
6411 		return;
6412 	scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
6413 	    "st_start: cmd=0x%p count=%ld resid=%ld flags=0x%x pkt=0x%p\n",
6414 	    (void *)bp->b_forw, bp->b_bcount,
6415 	    bp->b_resid, bp->b_flags, (void *)BP_PKT(bp));
6416 	st_print_cdb(ST_DEVINFO, st_label, SCSI_DEBUG,
6417 	    "st_start: cdb",  (caddr_t)cdbp);
6418 	scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
6419 	    "st_start: fileno=%d, blk=%d\n",
6420 	    un->un_pos.fileno, un->un_pos.blkno);
6421 }
6422 #endif
6423 
6424 
6425 /*
6426  * Command start && done functions
6427  */
6428 
6429 /*
6430  * st_start()
6431  *
6432  * Called from:
6433  *  st_strategy() to start a command.
6434  *  st_runout() to retry when scsi_pkt allocation fails on previous attempt(s).
6435  *  st_attach() when resuming from power down state.
6436  *  st_start_restart() to retry transport when device was previously busy.
6437  *  st_done_and_mutex_exit() to start the next command when previous is done.
6438  *
6439  * On entry:
6440  *  scsi_pkt may or may not be allocated.
6441  *
6442  */
6443 static void
6444 st_start(struct scsi_tape *un)
6445 {
6446 	struct buf *bp;
6447 	int status;
6448 	int queued;
6449 
6450 	ST_FUNC(ST_DEVINFO, st_start);
6451 	ASSERT(mutex_owned(ST_MUTEX));
6452 
6453 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6454 	    "st_start(): dev = 0x%lx\n", un->un_dev);
6455 
6456 	if (un->un_recov_buf_busy) {
6457 		/* recovery commands can happen anytime */
6458 		bp = un->un_recov_buf;
6459 		queued = 0;
6460 	} else if (un->un_sbuf_busy) {
6461 		/* sbuf commands should only happen with an empty queue. */
6462 		ASSERT(un->un_quef == NULL);
6463 		ASSERT(un->un_runqf == NULL);
6464 		bp = un->un_sbufp;
6465 		queued = 0;
6466 	} else if (un->un_quef != NULL) {
6467 		if (un->un_persistence && un->un_persist_errors) {
6468 			return;
6469 		}
6470 		bp = un->un_quef;
6471 		queued = 1;
6472 	} else {
6473 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
6474 		    "st_start() returning no buf found\n");
6475 		return;
6476 	}
6477 
6478 	ASSERT((bp->b_flags & B_DONE) == 0);
6479 
6480 	/*
6481 	 * Don't send more than un_throttle commands to the HBA
6482 	 */
6483 	if ((un->un_throttle <= 0) || (un->un_ncmds >= un->un_throttle)) {
6484 		/*
6485 		 * if doing recovery we know there is outstanding commands.
6486 		 */
6487 		if (bp != un->un_recov_buf) {
6488 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6489 			    "st_start returning throttle = %d or ncmds = %d\n",
6490 			    un->un_throttle, un->un_ncmds);
6491 			if (un->un_ncmds == 0) {
6492 				typedef void (*func)();
6493 				func fnc = (func)st_runout;
6494 
6495 				scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
6496 				    "Sending delayed start to st_runout()\n");
6497 				mutex_exit(ST_MUTEX);
6498 				(void) timeout(fnc, un, drv_usectohz(1000000));
6499 				mutex_enter(ST_MUTEX);
6500 			}
6501 			return;
6502 		}
6503 	}
6504 
6505 	/*
6506 	 * If the buf has no scsi_pkt call st_make_cmd() to get one and
6507 	 * build the command.
6508 	 */
6509 	if (BP_PKT(bp) == NULL) {
6510 		ASSERT((bp->b_flags & B_DONE) == 0);
6511 		st_make_cmd(un, bp, st_runout);
6512 		ASSERT((bp->b_flags & B_DONE) == 0);
6513 		status = geterror(bp);
6514 
6515 		/*
6516 		 * Some HBA's don't call bioerror() to set an error.
6517 		 * And geterror() returns zero if B_ERROR is not set.
6518 		 * So if we get zero we must check b_error.
6519 		 */
6520 		if (status == 0 && bp->b_error != 0) {
6521 			status = bp->b_error;
6522 			bioerror(bp, status);
6523 		}
6524 
6525 		/*
6526 		 * Some HBA's convert DDI_DMA_NORESOURCES into ENOMEM.
6527 		 * In tape ENOMEM has special meaning so we'll change it.
6528 		 */
6529 		if (status == ENOMEM) {
6530 			status = 0;
6531 			bioerror(bp, status);
6532 		}
6533 
6534 		/*
6535 		 * Did it fail and is it retryable?
6536 		 * If so return and wait for the callback through st_runout.
6537 		 * Also looks like scsi_init_pkt() will setup a callback even
6538 		 * if it isn't retryable.
6539 		 */
6540 		if (BP_PKT(bp) == NULL) {
6541 			if (status == 0) {
6542 				/*
6543 				 * If first attempt save state.
6544 				 */
6545 				if (un->un_state != ST_STATE_RESOURCE_WAIT) {
6546 					un->un_laststate = un->un_state;
6547 					un->un_state = ST_STATE_RESOURCE_WAIT;
6548 				}
6549 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6550 				    "temp no resources for pkt\n");
6551 			} else if (status == EINVAL) {
6552 				scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
6553 				    "scsi_init_pkt rejected pkt as too big\n");
6554 				if (un->un_persistence) {
6555 					st_set_pe_flag(un);
6556 				}
6557 			} else {
6558 				/*
6559 				 * Unlikely that it would be retryable then not.
6560 				 */
6561 				if (un->un_state == ST_STATE_RESOURCE_WAIT) {
6562 					un->un_state = un->un_laststate;
6563 				}
6564 				scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
6565 				    "perm no resources for pkt errno = 0x%x\n",
6566 				    status);
6567 			}
6568 			return;
6569 		}
6570 		/*
6571 		 * Worked this time set the state back.
6572 		 */
6573 		if (un->un_state == ST_STATE_RESOURCE_WAIT) {
6574 			un->un_state = un->un_laststate;
6575 		}
6576 	}
6577 
6578 	if (queued) {
6579 		/*
6580 		 * move from waitq to runq
6581 		 */
6582 		(void) st_remove_from_queue(&un->un_quef, &un->un_quel, bp);
6583 		st_add_to_queue(&un->un_runqf, &un->un_runql, un->un_runql, bp);
6584 	}
6585 
6586 
6587 #ifdef STDEBUG
6588 	st_start_dump(un, bp);
6589 #endif
6590 
6591 	/* could not get here if throttle was zero */
6592 	un->un_last_throttle = un->un_throttle;
6593 	un->un_throttle = 0;	/* so nothing else will come in here */
6594 	un->un_ncmds++;
6595 
6596 	ST_DO_KSTATS(bp, kstat_waitq_to_runq);
6597 
6598 	status = st_transport(un, BP_PKT(bp));
6599 
6600 	if (un->un_last_throttle) {
6601 		un->un_throttle = un->un_last_throttle;
6602 	}
6603 
6604 	if (status != TRAN_ACCEPT) {
6605 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
6606 		ST_DEBUG(ST_DEVINFO, st_label, CE_WARN,
6607 		    "Unhappy transport packet status 0x%x\n", status);
6608 
6609 		if (status == TRAN_BUSY) {
6610 			pkt_info *pkti = BP_PKT(bp)->pkt_private;
6611 
6612 			/*
6613 			 * If command recovery is enabled and this isn't
6614 			 * a recovery command try command recovery.
6615 			 */
6616 			if (pkti->privatelen == sizeof (recov_info) &&
6617 			    bp != un->un_recov_buf) {
6618 				ST_RECOV(ST_DEVINFO, st_label, CE_WARN,
6619 				    "Command Recovery called on busy send\n");
6620 				if (st_command_recovery(un, BP_PKT(bp),
6621 				    ATTEMPT_RETRY) == JUST_RETURN) {
6622 					return;
6623 				}
6624 			} else {
6625 				mutex_exit(ST_MUTEX);
6626 				if (st_handle_start_busy(un, bp,
6627 				    ST_TRAN_BUSY_TIMEOUT, queued) == 0) {
6628 					mutex_enter(ST_MUTEX);
6629 					return;
6630 				}
6631 				/*
6632 				 * if too many retries, fail the transport
6633 				 */
6634 				mutex_enter(ST_MUTEX);
6635 			}
6636 		}
6637 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
6638 		    "transport rejected %d\n", status);
6639 		bp->b_resid = bp->b_bcount;
6640 
6641 		ST_DO_KSTATS(bp, kstat_waitq_exit);
6642 		ST_DO_ERRSTATS(un, st_transerrs);
6643 		if ((bp == un->un_recov_buf) && (status == TRAN_BUSY)) {
6644 			st_bioerror(bp, EBUSY);
6645 		} else {
6646 			st_bioerror(bp, EIO);
6647 			st_set_pe_flag(un);
6648 		}
6649 		st_done_and_mutex_exit(un, bp);
6650 		mutex_enter(ST_MUTEX);
6651 	}
6652 
6653 	ASSERT(mutex_owned(ST_MUTEX));
6654 }
6655 
6656 /*
6657  * if the transport is busy, then put this bp back on the waitq
6658  */
6659 static int
6660 st_handle_start_busy(struct scsi_tape *un, struct buf *bp,
6661     clock_t timeout_interval, int queued)
6662 {
6663 
6664 	pkt_info *pktinfo = BP_PKT(bp)->pkt_private;
6665 
6666 	ST_FUNC(ST_DEVINFO, st_handle_start_busy);
6667 
6668 	mutex_enter(ST_MUTEX);
6669 
6670 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6671 	    "st_handle_start_busy()\n");
6672 
6673 	/*
6674 	 * Check to see if we hit the retry timeout and one last check for
6675 	 * making sure this is the last on the runq, if it is not, we have
6676 	 * to fail
6677 	 */
6678 	if ((pktinfo->str_retry_cnt++ > st_retry_count) ||
6679 	    ((queued) && (un->un_runql != bp))) {
6680 		mutex_exit(ST_MUTEX);
6681 		return (-1);
6682 	}
6683 
6684 	if (queued) {
6685 		/* put the bp back on the waitq */
6686 		st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quef, bp);
6687 	}
6688 
6689 	/*
6690 	 * Decrement un_ncmds so that this
6691 	 * gets thru' st_start() again.
6692 	 */
6693 	un->un_ncmds--;
6694 
6695 	if (queued) {
6696 		/*
6697 		 * since this is an error case, we won't have to do this list
6698 		 * walking much. We've already made sure this bp was the
6699 		 * last on the runq
6700 		 */
6701 		(void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp);
6702 
6703 		/*
6704 		 * send a marker pkt, if appropriate
6705 		 */
6706 		st_hba_unflush(un);
6707 
6708 	}
6709 	/*
6710 	 * all queues are aligned, we are just waiting to
6711 	 * transport, don't alloc any more buf p's, when
6712 	 * st_start is reentered.
6713 	 */
6714 	(void) timeout(st_start_restart, un, timeout_interval);
6715 
6716 	mutex_exit(ST_MUTEX);
6717 	return (0);
6718 }
6719 
6720 
6721 /*
6722  * st_runout a callback that is called what a resource allocatation failed
6723  */
6724 static int
6725 st_runout(caddr_t arg)
6726 {
6727 	struct scsi_tape *un = (struct scsi_tape *)arg;
6728 	struct buf *bp;
6729 	int queued;
6730 
6731 	ASSERT(un != NULL);
6732 
6733 	ST_FUNC(ST_DEVINFO, st_runout);
6734 
6735 	mutex_enter(ST_MUTEX);
6736 
6737 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_runout()\n");
6738 
6739 	if (un->un_recov_buf_busy != 0) {
6740 		bp = un->un_recov_buf;
6741 		queued = 0;
6742 	} else if (un->un_sbuf_busy != 0) {
6743 		/* sbuf commands should only happen with an empty queue. */
6744 		ASSERT(un->un_quef == NULL);
6745 		ASSERT(un->un_runqf == NULL);
6746 		bp = un->un_sbufp;
6747 		queued = 0;
6748 	} else if (un->un_quef != NULL) {
6749 		bp = un->un_quef;
6750 		if (un->un_persistence && un->un_persist_errors) {
6751 			mutex_exit(ST_MUTEX);
6752 			bp->b_resid = bp->b_bcount;
6753 			biodone(bp);
6754 			return (1);
6755 		}
6756 		queued = 1;
6757 	} else {
6758 		ASSERT(1 == 0);
6759 		mutex_exit(ST_MUTEX);
6760 		return (1);
6761 	}
6762 
6763 	/*
6764 	 * failed scsi_init_pkt(). If errno is zero its retryable.
6765 	 */
6766 	if ((bp != NULL) && (geterror(bp) != 0)) {
6767 
6768 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
6769 		    "errors after pkt alloc (b_flags=0x%x, b_error=0x%x)\n",
6770 		    bp->b_flags, geterror(bp));
6771 		ASSERT((bp->b_flags & B_DONE) == 0);
6772 
6773 		if (queued) {
6774 			(void) st_remove_from_queue(&un->un_quef, &un->un_quel,
6775 			    bp);
6776 		}
6777 		mutex_exit(ST_MUTEX);
6778 
6779 		ASSERT((bp->b_flags & B_DONE) == 0);
6780 
6781 		/*
6782 		 * Set resid, Error already set, then unblock calling thread.
6783 		 */
6784 		bp->b_resid = bp->b_bcount;
6785 		biodone(bp);
6786 	} else {
6787 		/*
6788 		 * Try Again
6789 		 */
6790 		st_start(un);
6791 		mutex_exit(ST_MUTEX);
6792 	}
6793 
6794 	/*
6795 	 * Comments courtesy of sd.c
6796 	 * The scsi_init_pkt routine allows for the callback function to
6797 	 * return a 0 indicating the callback should be rescheduled or a 1
6798 	 * indicating not to reschedule. This routine always returns 1
6799 	 * because the driver always provides a callback function to
6800 	 * scsi_init_pkt. This results in a callback always being scheduled
6801 	 * (via the scsi_init_pkt callback implementation) if a resource
6802 	 * failure occurs.
6803 	 */
6804 
6805 	return (1);
6806 }
6807 
6808 /*
6809  * st_done_and_mutex_exit()
6810  *	- remove bp from runq
6811  *	- start up the next request
6812  *	- if this was an asynch bp, clean up
6813  *	- exit with released mutex
6814  */
6815 static void
6816 st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp)
6817 {
6818 	int pe_flagged = 0;
6819 	struct scsi_pkt *pkt = BP_PKT(bp);
6820 	pkt_info *pktinfo = pkt->pkt_private;
6821 
6822 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
6823 #if !defined(lint)
6824 	_NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex))
6825 #endif
6826 
6827 	ST_FUNC(ST_DEVINFO, st_done_and_mutex_exit);
6828 
6829 	ASSERT(mutex_owned(ST_MUTEX));
6830 
6831 	(void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp);
6832 
6833 	un->un_ncmds--;
6834 	cv_signal(&un->un_queue_cv);
6835 
6836 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6837 	    "st_done_and_mutex_exit(): cmd=0x%x count=%ld resid=%ld  flags="
6838 	    "0x%x\n", pkt->pkt_cdbp[0], bp->b_bcount,
6839 	    bp->b_resid, bp->b_flags);
6840 
6841 
6842 	/*
6843 	 * update kstats with transfer count info
6844 	 */
6845 	if (un->un_stats && (bp != un->un_sbufp) && IS_RW(bp)) {
6846 		uint32_t n_done =  bp->b_bcount - bp->b_resid;
6847 		if (bp->b_flags & B_READ) {
6848 			IOSP->reads++;
6849 			IOSP->nread += n_done;
6850 		} else {
6851 			IOSP->writes++;
6852 			IOSP->nwritten += n_done;
6853 		}
6854 	}
6855 
6856 	/*
6857 	 * Start the next one before releasing resources on this one, if
6858 	 * there is something on the queue and persistent errors has not been
6859 	 * flagged
6860 	 */
6861 
6862 	if ((pe_flagged = (un->un_persistence && un->un_persist_errors)) != 0) {
6863 		un->un_last_resid = bp->b_resid;
6864 		un->un_last_count = bp->b_bcount;
6865 	}
6866 
6867 	if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
6868 		cv_broadcast(&un->un_tape_busy_cv);
6869 	} else if (un->un_quef && un->un_throttle && !pe_flagged &&
6870 	    (bp != un->un_recov_buf)) {
6871 		st_start(un);
6872 	}
6873 
6874 	un->un_retry_ct = max(pktinfo->pkt_retry_cnt, pktinfo->str_retry_cnt);
6875 
6876 	if (bp == un->un_sbufp && (bp->b_flags & B_ASYNC)) {
6877 		/*
6878 		 * Since we marked this ourselves as ASYNC,
6879 		 * there isn't anybody around waiting for
6880 		 * completion any more.
6881 		 */
6882 		uchar_t *cmd = pkt->pkt_cdbp;
6883 		if (*cmd == SCMD_READ || *cmd == SCMD_WRITE) {
6884 			bp->b_un.b_addr = (caddr_t)0;
6885 		}
6886 		ST_DEBUG(ST_DEVINFO, st_label, CE_NOTE,
6887 		    "st_done_and_mutex_exit(async): freeing pkt\n");
6888 		st_print_cdb(ST_DEVINFO, st_label, CE_NOTE,
6889 		    "CDB sent with B_ASYNC",  (caddr_t)cmd);
6890 		if (pkt) {
6891 			scsi_destroy_pkt(pkt);
6892 		}
6893 		un->un_sbuf_busy = 0;
6894 		cv_signal(&un->un_sbuf_cv);
6895 		mutex_exit(ST_MUTEX);
6896 		return;
6897 	}
6898 
6899 	if (bp == un->un_sbufp && BP_UCMD(bp)) {
6900 		/*
6901 		 * Copy status from scsi_pkt to uscsi_cmd
6902 		 * since st_uscsi_cmd needs it
6903 		 */
6904 		BP_UCMD(bp)->uscsi_status = SCBP_C(BP_PKT(bp));
6905 	}
6906 
6907 
6908 #ifdef STDEBUG
6909 	if (((st_debug & 0x7) >= 4) &&
6910 	    (((un->un_pos.blkno % 100) == 0) ||
6911 	    (un->un_persistence && un->un_persist_errors))) {
6912 
6913 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6914 		    "st_d_a_m_exit(): ncmds = %d, thr = %d, "
6915 		    "un_errno = %d, un_pe = %d\n",
6916 		    un->un_ncmds, un->un_throttle, un->un_errno,
6917 		    un->un_persist_errors);
6918 	}
6919 
6920 #endif
6921 
6922 	mutex_exit(ST_MUTEX);
6923 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6924 	    "st_done_and_mutex_exit: freeing pkt\n");
6925 
6926 	if (pkt) {
6927 		scsi_destroy_pkt(pkt);
6928 	}
6929 
6930 	biodone(bp);
6931 
6932 	/*
6933 	 * now that we biodoned that command, if persistent errors have been
6934 	 * flagged, flush the waitq
6935 	 */
6936 	if (pe_flagged)
6937 		st_flush(un);
6938 }
6939 
6940 
6941 /*
6942  * Tape error, flush tape driver queue.
6943  */
6944 static void
6945 st_flush(struct scsi_tape *un)
6946 {
6947 	struct buf *bp;
6948 
6949 	ST_FUNC(ST_DEVINFO, st_flush);
6950 
6951 	mutex_enter(ST_MUTEX);
6952 
6953 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6954 	    "st_flush(), ncmds = %d, quef = 0x%p\n",
6955 	    un->un_ncmds, (void *)un->un_quef);
6956 
6957 	/*
6958 	 * if we still have commands outstanding, wait for them to come in
6959 	 * before flushing the queue, and make sure there is a queue
6960 	 */
6961 	if (un->un_ncmds || !un->un_quef)
6962 		goto exit;
6963 
6964 	/*
6965 	 * we have no more commands outstanding, so let's deal with special
6966 	 * cases in the queue for EOM and FM. If we are here, and un_errno
6967 	 * is 0, then we know there was no error and we return a 0 read or
6968 	 * write before showing errors
6969 	 */
6970 
6971 	/* Flush the wait queue. */
6972 	while ((bp = un->un_quef) != NULL) {
6973 		un->un_quef = bp->b_actf;
6974 
6975 		bp->b_resid = bp->b_bcount;
6976 
6977 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6978 		    "st_flush() : blkno=%d, err=%d, b_bcount=%ld\n",
6979 		    un->un_pos.blkno, un->un_errno, bp->b_bcount);
6980 
6981 		st_set_pe_errno(un);
6982 
6983 		bioerror(bp, un->un_errno);
6984 
6985 		mutex_exit(ST_MUTEX);
6986 		/* it should have one, but check anyway */
6987 		if (BP_PKT(bp)) {
6988 			scsi_destroy_pkt(BP_PKT(bp));
6989 		}
6990 		biodone(bp);
6991 		mutex_enter(ST_MUTEX);
6992 	}
6993 
6994 	/*
6995 	 * It's not a bad practice to reset the
6996 	 * waitq tail pointer to NULL.
6997 	 */
6998 	un->un_quel = NULL;
6999 
7000 exit:
7001 	/* we mucked with the queue, so let others know about it */
7002 	cv_signal(&un->un_queue_cv);
7003 	mutex_exit(ST_MUTEX);
7004 }
7005 
7006 
7007 /*
7008  * Utility functions
7009  */
7010 static int
7011 st_determine_generic(struct scsi_tape *un)
7012 {
7013 	int bsize;
7014 	static char *cart = "0.25 inch cartridge";
7015 	char *sizestr;
7016 
7017 	ST_FUNC(ST_DEVINFO, st_determine_generic);
7018 
7019 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7020 	    "st_determine_generic(un = 0x%p)\n", (void*)un);
7021 
7022 	ASSERT(mutex_owned(ST_MUTEX));
7023 
7024 	if (st_modesense(un)) {
7025 		return (-1);
7026 	}
7027 
7028 	bsize = (un->un_mspl->high_bl << 16)	|
7029 	    (un->un_mspl->mid_bl << 8)	|
7030 	    (un->un_mspl->low_bl);
7031 
7032 	if (bsize == 0) {
7033 		un->un_dp->options |= ST_VARIABLE;
7034 		un->un_dp->bsize = 0;
7035 		un->un_bsize = 0;
7036 	} else if (bsize > ST_MAXRECSIZE_FIXED) {
7037 		/*
7038 		 * record size of this device too big.
7039 		 * try and convert it to variable record length.
7040 		 *
7041 		 */
7042 		un->un_dp->options |= ST_VARIABLE;
7043 		if (st_change_block_size(un, 0) != 0) {
7044 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
7045 			    "Fixed Record Size %d is too large\n", bsize);
7046 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
7047 			    "Cannot switch to variable record size\n");
7048 			un->un_dp->options &= ~ST_VARIABLE;
7049 			return (-1);
7050 		}
7051 	} else if (st_change_block_size(un, 0) == 0) {
7052 		/*
7053 		 * If the drive was set to a non zero block size,
7054 		 * See if it can be set to a zero block size.
7055 		 * If it works, ST_VARIABLE so user can set it as they want.
7056 		 */
7057 		un->un_dp->options |= ST_VARIABLE;
7058 		un->un_dp->bsize = 0;
7059 		un->un_bsize = 0;
7060 	} else {
7061 		un->un_dp->bsize = bsize;
7062 		un->un_bsize = bsize;
7063 	}
7064 
7065 
7066 	switch (un->un_mspl->density) {
7067 	default:
7068 	case 0x0:
7069 		/*
7070 		 * default density, cannot determine any other
7071 		 * information.
7072 		 */
7073 		sizestr = "Unknown type- assuming 0.25 inch cartridge";
7074 		un->un_dp->type = ST_TYPE_DEFAULT;
7075 		un->un_dp->options |= (ST_AUTODEN_OVERRIDE|ST_QIC);
7076 		break;
7077 	case 0x1:
7078 	case 0x2:
7079 	case 0x3:
7080 	case 0x6:
7081 		/*
7082 		 * 1/2" reel
7083 		 */
7084 		sizestr = "0.50 inch reel";
7085 		un->un_dp->type = ST_TYPE_REEL;
7086 		un->un_dp->options |= ST_REEL;
7087 		un->un_dp->densities[0] = 0x1;
7088 		un->un_dp->densities[1] = 0x2;
7089 		un->un_dp->densities[2] = 0x6;
7090 		un->un_dp->densities[3] = 0x3;
7091 		break;
7092 	case 0x4:
7093 	case 0x5:
7094 	case 0x7:
7095 	case 0x0b:
7096 
7097 		/*
7098 		 * Quarter inch.
7099 		 */
7100 		sizestr = cart;
7101 		un->un_dp->type = ST_TYPE_DEFAULT;
7102 		un->un_dp->options |= ST_QIC;
7103 
7104 		un->un_dp->densities[1] = 0x4;
7105 		un->un_dp->densities[2] = 0x5;
7106 		un->un_dp->densities[3] = 0x7;
7107 		un->un_dp->densities[0] = 0x0b;
7108 		break;
7109 
7110 	case 0x0f:
7111 	case 0x10:
7112 	case 0x11:
7113 	case 0x12:
7114 		/*
7115 		 * QIC-120, QIC-150, QIC-320, QIC-600
7116 		 */
7117 		sizestr = cart;
7118 		un->un_dp->type = ST_TYPE_DEFAULT;
7119 		un->un_dp->options |= ST_QIC;
7120 		un->un_dp->densities[0] = 0x0f;
7121 		un->un_dp->densities[1] = 0x10;
7122 		un->un_dp->densities[2] = 0x11;
7123 		un->un_dp->densities[3] = 0x12;
7124 		break;
7125 
7126 	case 0x09:
7127 	case 0x0a:
7128 	case 0x0c:
7129 	case 0x0d:
7130 		/*
7131 		 * 1/2" cartridge tapes. Include HI-TC.
7132 		 */
7133 		sizestr = cart;
7134 		sizestr[2] = '5';
7135 		sizestr[3] = '0';
7136 		un->un_dp->type = ST_TYPE_HIC;
7137 		un->un_dp->densities[0] = 0x09;
7138 		un->un_dp->densities[1] = 0x0a;
7139 		un->un_dp->densities[2] = 0x0c;
7140 		un->un_dp->densities[3] = 0x0d;
7141 		break;
7142 
7143 	case 0x13:
7144 			/* DDS-2/DDS-3 scsi spec densities */
7145 	case 0x24:
7146 	case 0x25:
7147 	case 0x26:
7148 		sizestr = "DAT Data Storage (DDS)";
7149 		un->un_dp->type = ST_TYPE_DAT;
7150 		un->un_dp->options |= ST_AUTODEN_OVERRIDE;
7151 		break;
7152 
7153 	case 0x14:
7154 		/*
7155 		 * Helical Scan (Exabyte) devices
7156 		 */
7157 		sizestr = "8mm helical scan cartridge";
7158 		un->un_dp->type = ST_TYPE_EXABYTE;
7159 		un->un_dp->options |= ST_AUTODEN_OVERRIDE;
7160 		break;
7161 	}
7162 
7163 	/*
7164 	 * Assume LONG ERASE, BSF and BSR
7165 	 */
7166 
7167 	un->un_dp->options |=
7168 	    (ST_LONG_ERASE | ST_UNLOADABLE | ST_BSF | ST_BSR | ST_KNOWS_EOD);
7169 
7170 	/*
7171 	 * Only if mode sense data says no buffered write, set NOBUF
7172 	 */
7173 	if (un->un_mspl->bufm == 0)
7174 		un->un_dp->options |= ST_NOBUF;
7175 
7176 	/*
7177 	 * set up large read and write retry counts
7178 	 */
7179 
7180 	un->un_dp->max_rretries = un->un_dp->max_wretries = 1000;
7181 
7182 	/*
7183 	 * If this is a 0.50 inch reel tape, and
7184 	 * it is *not* variable mode, try and
7185 	 * set it to variable record length
7186 	 * mode.
7187 	 */
7188 	if ((un->un_dp->options & ST_REEL) && un->un_bsize != 0 &&
7189 	    (un->un_dp->options & ST_VARIABLE)) {
7190 		if (st_change_block_size(un, 0) == 0) {
7191 			un->un_dp->bsize = 0;
7192 			un->un_mspl->high_bl = un->un_mspl->mid_bl =
7193 			    un->un_mspl->low_bl = 0;
7194 		}
7195 	}
7196 
7197 	/*
7198 	 * Write to console about type of device found
7199 	 */
7200 	ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
7201 	    "Generic Drive, Vendor=%s\n\t%s", un->un_dp->name,
7202 	    sizestr);
7203 	if (un->un_dp->options & ST_VARIABLE) {
7204 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
7205 		    "!Variable record length I/O\n");
7206 	} else {
7207 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
7208 		    "!Fixed record length (%d byte blocks) I/O\n",
7209 		    un->un_dp->bsize);
7210 	}
7211 	ASSERT(mutex_owned(ST_MUTEX));
7212 	return (0);
7213 }
7214 
7215 static int
7216 st_determine_density(struct scsi_tape *un, int rw)
7217 {
7218 	int rval = 0;
7219 
7220 	ST_FUNC(ST_DEVINFO, st_determine_density);
7221 
7222 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7223 	    "st_determine_density(un = 0x%p, rw = %s)\n",
7224 	    (void*)un, (rw == B_WRITE ? wr_str: rd_str));
7225 
7226 	ASSERT(mutex_owned(ST_MUTEX));
7227 
7228 	/*
7229 	 * If we're past BOT, density is determined already.
7230 	 */
7231 	if (un->un_pos.pmode == logical) {
7232 		if (un->un_pos.lgclblkno != 0) {
7233 			goto exit;
7234 		}
7235 	} else if (un->un_pos.pmode == legacy) {
7236 		if ((un->un_pos.fileno != 0) || (un->un_pos.blkno != 0)) {
7237 			/*
7238 			 * XXX: put in a bitch message about attempting to
7239 			 * XXX: change density past BOT.
7240 			 */
7241 			goto exit;
7242 		}
7243 	} else {
7244 		goto exit;
7245 	}
7246 	if ((un->un_pos.pmode == logical) &&
7247 	    (un->un_pos.lgclblkno != 0)) {
7248 		goto exit;
7249 	}
7250 
7251 
7252 	/*
7253 	 * If we're going to be writing, we set the density
7254 	 */
7255 	if (rw == 0 || rw == B_WRITE) {
7256 		/* un_curdens is used as an index into densities table */
7257 		un->un_curdens = MT_DENSITY(un->un_dev);
7258 		if (st_set_density(un)) {
7259 			rval = -1;
7260 		}
7261 		goto exit;
7262 	}
7263 
7264 	/*
7265 	 * If density is known already,
7266 	 * we don't have to get it again.(?)
7267 	 */
7268 	if (!un->un_density_known) {
7269 		if (st_get_density(un)) {
7270 			rval = -1;
7271 		}
7272 	}
7273 
7274 exit:
7275 	ASSERT(mutex_owned(ST_MUTEX));
7276 	return (rval);
7277 }
7278 
7279 
7280 /*
7281  * Try to determine density. We do this by attempting to read the
7282  * first record off the tape, cycling through the available density
7283  * codes as we go.
7284  */
7285 
7286 static int
7287 st_get_density(struct scsi_tape *un)
7288 {
7289 	int succes = 0, rval = -1, i;
7290 	uint_t size;
7291 	uchar_t dens, olddens;
7292 
7293 	ST_FUNC(ST_DEVINFO, st_get_density);
7294 
7295 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7296 	    "st_get_density(un = 0x%p)\n", (void*)un);
7297 
7298 	ASSERT(mutex_owned(ST_MUTEX));
7299 
7300 	/*
7301 	 * If Auto Density override is enabled The drive has
7302 	 * only one density and there is no point in attempting
7303 	 * find the correct one.
7304 	 *
7305 	 * Since most modern drives auto detect the density
7306 	 * and format of the recorded media before they come
7307 	 * ready. What this function does is a legacy behavior
7308 	 * and modern drives not only don't need it, The backup
7309 	 * utilities that do positioning via uscsi find the un-
7310 	 * expected rewinds problematic.
7311 	 *
7312 	 * The drives that need this are old reel to reel devices.
7313 	 * I took a swag and said they must be scsi-1 or older.
7314 	 * I don't beleave there will any of the newer devices
7315 	 * that need this. There will be some scsi-1 devices that
7316 	 * don't need this but I don't think they will be using the
7317 	 * BIG aftermarket backup and restore utilitys.
7318 	 */
7319 	if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) ||
7320 	    (un->un_sd->sd_inq->inq_ansi > 1)) {
7321 		un->un_density_known = 1;
7322 		rval = 0;
7323 		goto exit;
7324 	}
7325 
7326 	/*
7327 	 * This will only work on variable record length tapes
7328 	 * if and only if all variable record length tapes autodensity
7329 	 * select.
7330 	 */
7331 	size = (unsigned)(un->un_dp->bsize ? un->un_dp->bsize : SECSIZE);
7332 	un->un_tmpbuf = kmem_alloc(size, KM_SLEEP);
7333 
7334 	/*
7335 	 * Start at the specified density
7336 	 */
7337 
7338 	dens = olddens = un->un_curdens = MT_DENSITY(un->un_dev);
7339 
7340 	for (i = 0; i < NDENSITIES; i++, ((un->un_curdens == NDENSITIES - 1) ?
7341 	    (un->un_curdens = 0) : (un->un_curdens += 1))) {
7342 		/*
7343 		 * If we've done this density before,
7344 		 * don't bother to do it again.
7345 		 */
7346 		dens = un->un_dp->densities[un->un_curdens];
7347 		if (i > 0 && dens == olddens)
7348 			continue;
7349 		olddens = dens;
7350 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7351 		    "trying density 0x%x\n", dens);
7352 		if (st_set_density(un)) {
7353 			continue;
7354 		}
7355 
7356 		/*
7357 		 * XXX - the creates lots of headaches and slowdowns - must
7358 		 * fix.
7359 		 */
7360 		succes = (st_cmd(un, SCMD_READ, (int)size, SYNC_CMD) == 0);
7361 		if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) {
7362 			break;
7363 		}
7364 		if (succes) {
7365 			st_init(un);
7366 			rval = 0;
7367 			un->un_density_known = 1;
7368 			break;
7369 		}
7370 	}
7371 	kmem_free(un->un_tmpbuf, size);
7372 	un->un_tmpbuf = 0;
7373 
7374 exit:
7375 	ASSERT(mutex_owned(ST_MUTEX));
7376 	return (rval);
7377 }
7378 
7379 static int
7380 st_set_density(struct scsi_tape *un)
7381 {
7382 	int rval = 0;
7383 
7384 	ST_FUNC(ST_DEVINFO, st_set_density);
7385 
7386 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7387 	    "st_set_density(un = 0x%p): density = 0x%x\n", (void*)un,
7388 	    un->un_dp->densities[un->un_curdens]);
7389 
7390 	ASSERT(mutex_owned(ST_MUTEX));
7391 
7392 	un->un_mspl->density = un->un_dp->densities[un->un_curdens];
7393 
7394 	if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) == 0) {
7395 		/*
7396 		 * If auto density override is not set, Use mode select
7397 		 * to set density and compression.
7398 		 */
7399 		if (st_modeselect(un)) {
7400 			rval = -1;
7401 		}
7402 	} else if ((un->un_dp->options & ST_MODE_SEL_COMP) != 0) {
7403 		/*
7404 		 * If auto density and mode select compression are set,
7405 		 * This is a drive with one density code but compression
7406 		 * can be enabled or disabled.
7407 		 * Set compression but no need to set density.
7408 		 */
7409 		rval = st_set_compression(un);
7410 		if ((rval != 0) && (rval != EALREADY)) {
7411 			rval = -1;
7412 		} else {
7413 			rval = 0;
7414 		}
7415 	}
7416 
7417 	/* If sucessful set density and/or compression, mark density known */
7418 	if (rval == 0) {
7419 		un->un_density_known = 1;
7420 	}
7421 
7422 	ASSERT(mutex_owned(ST_MUTEX));
7423 	return (rval);
7424 }
7425 
7426 static int
7427 st_loadtape(struct scsi_tape *un)
7428 {
7429 	int rval;
7430 
7431 	ST_FUNC(ST_DEVINFO, st_loadtape);
7432 
7433 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7434 	    "st_loadtape(un = 0x%p)\n", (void*) un);
7435 
7436 	ASSERT(mutex_owned(ST_MUTEX));
7437 
7438 	rval = st_update_block_pos(un, st_cmd, 0);
7439 	if (rval == EACCES) {
7440 		return (rval);
7441 	}
7442 
7443 	/*
7444 	 * 'LOAD' the tape to BOT by rewinding
7445 	 */
7446 	rval = st_cmd(un, SCMD_REWIND, 1, SYNC_CMD);
7447 	if (rval == 0) {
7448 		st_init(un);
7449 		un->un_density_known = 0;
7450 	}
7451 
7452 	ASSERT(mutex_owned(ST_MUTEX));
7453 	return (rval);
7454 }
7455 
7456 
7457 /*
7458  * Note: QIC devices aren't so smart.  If you try to append
7459  * after EOM, the write can fail because the device doesn't know
7460  * it's at EOM.	 In that case, issue a read.  The read should fail
7461  * because there's no data, but the device knows it's at EOM,
7462  * so a subsequent write should succeed.  To further confuse matters,
7463  * the target returns the same error if the tape is positioned
7464  * such that a write would overwrite existing data.  That's why
7465  * we have to do the append test.  A read in the middle of
7466  * recorded data would succeed, thus indicating we're attempting
7467  * something illegal.
7468  */
7469 
7470 
7471 static void
7472 st_test_append(struct buf *bp)
7473 {
7474 	dev_t dev = bp->b_edev;
7475 	struct scsi_tape *un;
7476 	uchar_t status;
7477 	unsigned bcount;
7478 
7479 	un = ddi_get_soft_state(st_state, MTUNIT(dev));
7480 
7481 	ST_FUNC(ST_DEVINFO, st_test_append);
7482 
7483 	ASSERT(mutex_owned(ST_MUTEX));
7484 
7485 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7486 	    "st_test_append(): fileno %d\n", un->un_pos.fileno);
7487 
7488 	un->un_laststate = un->un_state;
7489 	un->un_state = ST_STATE_APPEND_TESTING;
7490 	un->un_test_append = 0;
7491 
7492 	/*
7493 	 * first, map in the buffer, because we're doing a double write --
7494 	 * first into the kernel, then onto the tape.
7495 	 */
7496 	bp_mapin(bp);
7497 
7498 	/*
7499 	 * get a copy of the data....
7500 	 */
7501 	un->un_tmpbuf = kmem_alloc((unsigned)bp->b_bcount, KM_SLEEP);
7502 	bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount);
7503 
7504 	/*
7505 	 * attempt the write..
7506 	 */
7507 
7508 	if (st_cmd(un, (int)SCMD_WRITE, (int)bp->b_bcount, SYNC_CMD) == 0) {
7509 success:
7510 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7511 		    "append write succeeded\n");
7512 		bp->b_resid = un->un_sbufp->b_resid;
7513 		mutex_exit(ST_MUTEX);
7514 		bcount = (unsigned)bp->b_bcount;
7515 		biodone(bp);
7516 		mutex_enter(ST_MUTEX);
7517 		un->un_laststate = un->un_state;
7518 		un->un_state = ST_STATE_OPEN;
7519 		kmem_free(un->un_tmpbuf, bcount);
7520 		un->un_tmpbuf = NULL;
7521 		return;
7522 	}
7523 
7524 	/*
7525 	 * The append failed. Do a short read. If that fails,  we are at EOM
7526 	 * so we can retry the write command. If that succeeds, than we're
7527 	 * all screwed up (the controller reported a real error).
7528 	 *
7529 	 * XXX: should the dummy read be > SECSIZE? should it be the device's
7530 	 * XXX: block size?
7531 	 *
7532 	 */
7533 	status = un->un_status;
7534 	un->un_status = 0;
7535 	(void) st_cmd(un, SCMD_READ, SECSIZE, SYNC_CMD);
7536 	if (un->un_status == KEY_BLANK_CHECK) {
7537 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7538 		    "append at EOM\n");
7539 		/*
7540 		 * Okay- the read failed. We should actually have confused
7541 		 * the controller enough to allow writing. In any case, the
7542 		 * i/o is on its own from here on out.
7543 		 */
7544 		un->un_laststate = un->un_state;
7545 		un->un_state = ST_STATE_OPEN;
7546 		bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount);
7547 		if (st_cmd(un, (int)SCMD_WRITE, (int)bp->b_bcount,
7548 		    SYNC_CMD) == 0) {
7549 			goto success;
7550 		}
7551 	}
7552 
7553 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7554 	    "append write failed- not at EOM\n");
7555 	bp->b_resid = bp->b_bcount;
7556 	st_bioerror(bp, EIO);
7557 
7558 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
7559 	    "st_test_append : EIO : append write failed - not at EOM");
7560 
7561 	/*
7562 	 * backspace one record to get back to where we were
7563 	 */
7564 	if (st_cmd(un, SCMD_SPACE, Blk(-1), SYNC_CMD)) {
7565 		un->un_pos.pmode = invalid;
7566 	}
7567 
7568 	un->un_err_resid = bp->b_resid;
7569 	un->un_status = status;
7570 
7571 	/*
7572 	 * Note: biodone will do a bp_mapout()
7573 	 */
7574 	mutex_exit(ST_MUTEX);
7575 	bcount = (unsigned)bp->b_bcount;
7576 	biodone(bp);
7577 	mutex_enter(ST_MUTEX);
7578 	un->un_laststate = un->un_state;
7579 	un->un_state = ST_STATE_OPEN_PENDING_IO;
7580 	kmem_free(un->un_tmpbuf, bcount);
7581 	un->un_tmpbuf = NULL;
7582 }
7583 
7584 /*
7585  * Special command handler
7586  */
7587 
7588 /*
7589  * common st_cmd code. The fourth parameter states
7590  * whether the caller wishes to await the results
7591  * Note the release of the mutex during most of the function
7592  */
7593 static int
7594 st_cmd(struct scsi_tape *un, int com, int64_t count, int wait)
7595 {
7596 	struct buf *bp;
7597 	int err;
7598 	uint_t last_err_resid;
7599 
7600 	ST_FUNC(ST_DEVINFO, st_cmd);
7601 
7602 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7603 	    "st_cmd(dev = 0x%lx, com = 0x%x, count = %"PRIx64", wait = %d)\n",
7604 	    un->un_dev, com, count, wait);
7605 
7606 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
7607 	ASSERT(mutex_owned(ST_MUTEX));
7608 
7609 #ifdef STDEBUG
7610 	if ((st_debug & 0x7)) {
7611 		st_debug_cmds(un, com, count, wait);
7612 	}
7613 #endif
7614 
7615 	st_wait_for_io(un);
7616 
7617 	/* check to see if this command requires the drive to be reserved */
7618 	err = st_check_cmd_for_need_to_reserve(un, com, count);
7619 
7620 	if (err) {
7621 		return (err);
7622 	}
7623 
7624 	/*
7625 	 * A space command is not recoverable if we don't know were we
7626 	 * were when it was issued.
7627 	 */
7628 	if ((com == SCMD_SPACE) || (com == SCMD_SPACE_G4)) {
7629 		(void) st_update_block_pos(un, st_cmd, 0);
7630 	}
7631 
7632 	/*
7633 	 * Forground should not be doing anything while recovery is active.
7634 	 */
7635 	ASSERT(un->un_recov_buf_busy == 0);
7636 
7637 	while (un->un_sbuf_busy)
7638 		cv_wait(&un->un_sbuf_cv, ST_MUTEX);
7639 	un->un_sbuf_busy = 1;
7640 
7641 	bp = un->un_sbufp;
7642 	bzero(bp, sizeof (buf_t));
7643 
7644 	bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC;
7645 
7646 	err = st_setup_cmd(un, bp, com, count);
7647 
7648 	un->un_sbuf_busy = 0;
7649 
7650 	/*
7651 	 * If was a space command need to update logical block position.
7652 	 * Only do this if the command was sucessful or it will mask the fact
7653 	 * that the space command failed by promoting the pmode to logical.
7654 	 */
7655 	if (((com == SCMD_SPACE) || (com == SCMD_SPACE_G4)) &&
7656 	    (un->un_pos.pmode != invalid)) {
7657 		un->un_running.pmode = invalid;
7658 		last_err_resid = un->un_err_resid;
7659 		(void) st_update_block_pos(un, st_cmd, 1);
7660 		/*
7661 		 * Set running position to invalid so it updates on the
7662 		 * next command.
7663 		 */
7664 		un->un_running.pmode = invalid;
7665 		un->un_err_resid = last_err_resid;
7666 	}
7667 
7668 	cv_signal(&un->un_sbuf_cv);
7669 
7670 	return (err);
7671 }
7672 
7673 static int
7674 st_setup_cmd(struct scsi_tape *un, buf_t *bp, int com, int64_t count)
7675 {
7676 	int err;
7677 	dev_t dev = un->un_dev;
7678 
7679 	ST_FUNC(ST_DEVINFO, st_setup_cmd);
7680 	/*
7681 	 * Set count to the actual size of the data tranfer.
7682 	 * For commands with no data transfer, set bp->b_bcount
7683 	 * to the value to be used when constructing the
7684 	 * cdb in st_make_cmd().
7685 	 */
7686 	switch (com) {
7687 	case SCMD_READ:
7688 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7689 		    "special read %"PRId64"\n", count);
7690 		bp->b_flags |= B_READ;
7691 		bp->b_un.b_addr = un->un_tmpbuf;
7692 		break;
7693 
7694 	case SCMD_WRITE:
7695 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7696 		    "special write %"PRId64"\n", count);
7697 		bp->b_un.b_addr = un->un_tmpbuf;
7698 		break;
7699 
7700 	case SCMD_WRITE_FILE_MARK:
7701 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7702 		    "write %"PRId64" file marks\n", count);
7703 		bp->b_bcount = count;
7704 		count = 0;
7705 		break;
7706 
7707 	case SCMD_REWIND:
7708 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "rewind\n");
7709 		bp->b_bcount = count;
7710 		count = 0;
7711 		break;
7712 
7713 	case SCMD_SPACE:
7714 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "space\n");
7715 		/*
7716 		 * If the user could have entered a number that will
7717 		 * not fit in the 12 bit count field of space(8),
7718 		 * use space(16).
7719 		 */
7720 		if (((int64_t)SPACE_CNT(count) > 0x7fffff) ||
7721 		    ((int64_t)SPACE_CNT(count) < -(0x7fffff))) {
7722 			com = SCMD_SPACE_G4;
7723 		}
7724 		bp->b_bcount = count;
7725 		count = 0;
7726 		break;
7727 
7728 	case SCMD_RESERVE:
7729 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "reserve");
7730 		bp->b_bcount = 0;
7731 		count = 0;
7732 		break;
7733 
7734 	case SCMD_RELEASE:
7735 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "release");
7736 		bp->b_bcount = 0;
7737 		count = 0;
7738 		break;
7739 
7740 	case SCMD_LOAD:
7741 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7742 		    "%s tape\n", (count & LD_LOAD) ? "load" : "unload");
7743 		bp->b_bcount = count;
7744 		count = 0;
7745 		break;
7746 
7747 	case SCMD_ERASE:
7748 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7749 		    "erase tape\n");
7750 		bp->b_bcount = count;
7751 		count = 0;
7752 		break;
7753 
7754 	case SCMD_MODE_SENSE:
7755 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7756 		    "mode sense\n");
7757 		bp->b_flags |= B_READ;
7758 		bp->b_un.b_addr = (caddr_t)(un->un_mspl);
7759 		break;
7760 
7761 	case SCMD_MODE_SELECT:
7762 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7763 		    "mode select\n");
7764 		bp->b_un.b_addr = (caddr_t)(un->un_mspl);
7765 		break;
7766 
7767 	case SCMD_READ_BLKLIM:
7768 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7769 		    "read block limits\n");
7770 		bp->b_bcount = count;
7771 		bp->b_flags |= B_READ;
7772 		bp->b_un.b_addr = (caddr_t)(un->un_rbl);
7773 		break;
7774 
7775 	case SCMD_TEST_UNIT_READY:
7776 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7777 		    "test unit ready\n");
7778 		bp->b_bcount = 0;
7779 		count = 0;
7780 		break;
7781 
7782 	case SCMD_DOORLOCK:
7783 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7784 		    "%s tape\n", (count & MR_LOCK) ? "lock" : "unlock");
7785 		bp->b_bcount = count = 0;
7786 		break;
7787 
7788 	case SCMD_READ_POSITION:
7789 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7790 		    "read position\n");
7791 		switch (un->un_read_pos_type) {
7792 		case LONG_POS:
7793 			count = sizeof (tape_position_long_t);
7794 			break;
7795 		case EXT_POS:
7796 			count = min(count, sizeof (tape_position_ext_t));
7797 			break;
7798 		case SHORT_POS:
7799 			count = sizeof (tape_position_t);
7800 			break;
7801 		default:
7802 			ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
7803 			    "Unknown read position type 0x%x in "
7804 			    "st_make_cmd()\n", un->un_read_pos_type);
7805 		}
7806 		bp->b_bcount = count;
7807 		bp->b_flags |= B_READ;
7808 		bp->b_un.b_addr = (caddr_t)un->un_read_pos_data;
7809 		break;
7810 
7811 	default:
7812 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
7813 		    "Unhandled scsi command 0x%x in st_setup_cmd()\n", com);
7814 	}
7815 
7816 	mutex_exit(ST_MUTEX);
7817 
7818 	if (count > 0) {
7819 		int flg = (bp->b_flags & B_READ) ? B_READ : B_WRITE;
7820 		/*
7821 		 * We're going to do actual I/O.
7822 		 * Set things up for physio.
7823 		 */
7824 		struct iovec aiov;
7825 		struct uio auio;
7826 		struct uio *uio = &auio;
7827 
7828 		bzero(&auio, sizeof (struct uio));
7829 		bzero(&aiov, sizeof (struct iovec));
7830 		aiov.iov_base = bp->b_un.b_addr;
7831 		aiov.iov_len = count;
7832 
7833 		uio->uio_iov = &aiov;
7834 		uio->uio_iovcnt = 1;
7835 		uio->uio_resid = aiov.iov_len;
7836 		uio->uio_segflg = UIO_SYSSPACE;
7837 
7838 		/*
7839 		 * Let physio do the rest...
7840 		 */
7841 		bp->b_forw = (struct buf *)(uintptr_t)com;
7842 		bp->b_back = NULL;
7843 		err = physio(st_strategy, bp, dev, flg, st_minphys, uio);
7844 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7845 		    "st_setup_cmd: physio returns %d\n", err);
7846 	} else {
7847 		/*
7848 		 * Mimic physio
7849 		 */
7850 		bp->b_forw = (struct buf *)(uintptr_t)com;
7851 		bp->b_back = NULL;
7852 		bp->b_edev = dev;
7853 		bp->b_dev = cmpdev(dev);
7854 		bp->b_blkno = 0;
7855 		bp->b_resid = 0;
7856 		(void) st_strategy(bp);
7857 		if (bp->b_flags & B_ASYNC) {
7858 			/*
7859 			 * This is an async command- the caller won't wait
7860 			 * and doesn't care about errors.
7861 			 */
7862 			mutex_enter(ST_MUTEX);
7863 			return (0);
7864 		}
7865 
7866 		/*
7867 		 * BugTraq #4260046
7868 		 * ----------------
7869 		 * Restore Solaris 2.5.1 behavior, namely call biowait
7870 		 * unconditionally. The old comment said...
7871 		 *
7872 		 * "if strategy was flagged with  persistent errors, we would
7873 		 *  have an error here, and the bp would never be sent, so we
7874 		 *  don't want to wait on a bp that was never sent...or hang"
7875 		 *
7876 		 * The new rationale, courtesy of Chitrank...
7877 		 *
7878 		 * "we should unconditionally biowait() here because
7879 		 *  st_strategy() will do a biodone() in the persistent error
7880 		 *  case and the following biowait() will return immediately.
7881 		 *  If not, in the case of "errors after pkt alloc" in
7882 		 *  st_start(), we will not biowait here which will cause the
7883 		 *  next biowait() to return immediately which will cause
7884 		 *  us to send out the next command. In the case where both of
7885 		 *  these use the sbuf, when the first command completes we'll
7886 		 *  free the packet attached to sbuf and the same pkt will
7887 		 *  get freed again when we complete the second command.
7888 		 *  see esc 518987.  BTW, it is necessary to do biodone() in
7889 		 *  st_start() for the pkt alloc failure case because physio()
7890 		 *  does biowait() and will hang if we don't do biodone()"
7891 		 */
7892 
7893 		err = biowait(bp);
7894 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7895 		    "st_setup_cmd: biowait returns %d\n", err);
7896 	}
7897 
7898 	mutex_enter(ST_MUTEX);
7899 
7900 	return (err);
7901 }
7902 
7903 static int
7904 st_set_compression(struct scsi_tape *un)
7905 {
7906 	int rval;
7907 	int turn_compression_on;
7908 	minor_t minor;
7909 
7910 	ST_FUNC(ST_DEVINFO, st_set_compression);
7911 
7912 	/*
7913 	 * Drive either dosn't have compression or it is controlled with
7914 	 * special density codes. Return ENOTTY so caller
7915 	 * knows nothing was done.
7916 	 */
7917 	if ((un->un_dp->options & ST_MODE_SEL_COMP) == 0) {
7918 		un->un_comp_page = 0;
7919 		return (ENOTTY);
7920 	}
7921 
7922 	/* set compression based on minor node opened */
7923 	minor = MT_DENSITY(un->un_dev);
7924 
7925 	/*
7926 	 * If this the compression density or
7927 	 * the drive has two densities and uses mode select for
7928 	 * control of compression turn on compression for MT_DENSITY2
7929 	 * as well.
7930 	 */
7931 	if ((minor == ST_COMPRESSION_DENSITY) ||
7932 	    (minor == MT_DENSITY(MT_DENSITY2)) &&
7933 	    (un->un_dp->densities[0] == un->un_dp->densities[1]) &&
7934 	    (un->un_dp->densities[2] == un->un_dp->densities[3]) &&
7935 	    (un->un_dp->densities[0] != un->un_dp->densities[2])) {
7936 
7937 		turn_compression_on = 1;
7938 	} else {
7939 		turn_compression_on = 0;
7940 	}
7941 
7942 	un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16);
7943 	un->un_mspl->mid_bl  = (uchar_t)(un->un_bsize >> 8);
7944 	un->un_mspl->low_bl  = (uchar_t)(un->un_bsize);
7945 
7946 	/*
7947 	 * Need to determine which page does the device use for compression.
7948 	 * First try the data compression page. If this fails try the device
7949 	 * configuration page
7950 	 */
7951 
7952 	if ((un->un_comp_page & ST_DEV_DATACOMP_PAGE) == ST_DEV_DATACOMP_PAGE) {
7953 		rval = st_set_datacomp_page(un, turn_compression_on);
7954 		if (rval == EALREADY) {
7955 			return (rval);
7956 		}
7957 		if (rval != 0) {
7958 			if (un->un_status == KEY_ILLEGAL_REQUEST) {
7959 				/*
7960 				 * This device does not support data
7961 				 * compression page
7962 				 */
7963 				un->un_comp_page = ST_DEV_CONFIG_PAGE;
7964 			} else if (un->un_state >= ST_STATE_OPEN) {
7965 				un->un_pos.pmode = invalid;
7966 				rval = EIO;
7967 			} else {
7968 				rval = -1;
7969 			}
7970 		} else {
7971 			un->un_comp_page = ST_DEV_DATACOMP_PAGE;
7972 		}
7973 	}
7974 
7975 	if ((un->un_comp_page & ST_DEV_CONFIG_PAGE) == ST_DEV_CONFIG_PAGE) {
7976 		rval = st_set_devconfig_page(un, turn_compression_on);
7977 		if (rval == EALREADY) {
7978 			return (rval);
7979 		}
7980 		if (rval != 0) {
7981 			if (un->un_status == KEY_ILLEGAL_REQUEST) {
7982 				/*
7983 				 * This device does not support
7984 				 * compression at all advice the
7985 				 * user and unset ST_MODE_SEL_COMP
7986 				 */
7987 				un->un_dp->options &= ~ST_MODE_SEL_COMP;
7988 				un->un_comp_page = 0;
7989 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
7990 				    "Device Does Not Support Compression\n");
7991 			} else if (un->un_state >= ST_STATE_OPEN) {
7992 				un->un_pos.pmode = invalid;
7993 				rval = EIO;
7994 			} else {
7995 				rval = -1;
7996 			}
7997 		}
7998 	}
7999 
8000 	return (rval);
8001 }
8002 
8003 /*
8004  * set or unset compression thru device configuration page.
8005  */
8006 static int
8007 st_set_devconfig_page(struct scsi_tape *un, int compression_on)
8008 {
8009 	unsigned char cflag;
8010 	int rval = 0;
8011 
8012 
8013 	ST_FUNC(ST_DEVINFO, st_set_devconfig_page);
8014 
8015 	ASSERT(mutex_owned(ST_MUTEX));
8016 
8017 	/*
8018 	 * if the mode sense page is not the correct one, load the correct one.
8019 	 */
8020 	if (un->un_mspl->page_code != ST_DEV_CONFIG_PAGE) {
8021 		rval = st_gen_mode_sense(un, st_uscsi_cmd, ST_DEV_CONFIG_PAGE,
8022 		    un->un_mspl, sizeof (struct seq_mode));
8023 		if (rval)
8024 			return (rval);
8025 	}
8026 
8027 	/*
8028 	 * Figure what to set compression flag to.
8029 	 */
8030 	if (compression_on) {
8031 		/* They have selected a compression node */
8032 		if (un->un_dp->type == ST_TYPE_FUJI) {
8033 			cflag = 0x84;   /* use EDRC */
8034 		} else {
8035 			cflag = ST_DEV_CONFIG_DEF_COMP;
8036 		}
8037 	} else {
8038 		cflag = ST_DEV_CONFIG_NO_COMP;
8039 	}
8040 
8041 	/*
8042 	 * If compression is already set the way it was requested.
8043 	 * And if this not the first time we has tried.
8044 	 */
8045 	if ((cflag == un->un_mspl->page.dev.comp_alg) &&
8046 	    (un->un_comp_page == ST_DEV_CONFIG_PAGE)) {
8047 		return (EALREADY);
8048 	}
8049 
8050 	un->un_mspl->page.dev.comp_alg = cflag;
8051 	/*
8052 	 * need to send mode select even if correct compression is
8053 	 * already set since need to set density code
8054 	 */
8055 
8056 #ifdef STDEBUG
8057 	if ((st_debug & 0x7) >= 6) {
8058 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
8059 		    "st_set_devconfig_page: sense data for mode select",
8060 		    (char *)un->un_mspl, sizeof (struct seq_mode));
8061 	}
8062 #endif
8063 	rval = st_gen_mode_select(un, st_uscsi_cmd, un->un_mspl,
8064 	    sizeof (struct seq_mode));
8065 
8066 	return (rval);
8067 }
8068 
8069 /*
8070  * set/reset compression bit thru data compression page
8071  */
8072 static int
8073 st_set_datacomp_page(struct scsi_tape *un, int compression_on)
8074 {
8075 	int compression_on_already;
8076 	int rval = 0;
8077 
8078 
8079 	ST_FUNC(ST_DEVINFO, st_set_datacomp_page);
8080 
8081 	ASSERT(mutex_owned(ST_MUTEX));
8082 
8083 	/*
8084 	 * if the mode sense page is not the correct one, load the correct one.
8085 	 */
8086 	if (un->un_mspl->page_code != ST_DEV_DATACOMP_PAGE) {
8087 		rval = st_gen_mode_sense(un, st_uscsi_cmd, ST_DEV_DATACOMP_PAGE,
8088 		    un->un_mspl, sizeof (struct seq_mode));
8089 		if (rval)
8090 			return (rval);
8091 	}
8092 
8093 	/*
8094 	 * If drive is not capable of compression (at this time)
8095 	 * return EALREADY so caller doesn't think that this page
8096 	 * is not supported. This check is for drives that can
8097 	 * disable compression from the front panel or configuration.
8098 	 * I doubt that a drive that supports this page is not really
8099 	 * capable of compression.
8100 	 */
8101 	if (un->un_mspl->page.comp.dcc == 0) {
8102 		return (EALREADY);
8103 	}
8104 
8105 	/* See if compression currently turned on */
8106 	if (un->un_mspl->page.comp.dce) {
8107 		compression_on_already = 1;
8108 	} else {
8109 		compression_on_already = 0;
8110 	}
8111 
8112 	/*
8113 	 * If compression is already set the way it was requested.
8114 	 * And if this not the first time we has tried.
8115 	 */
8116 	if ((compression_on == compression_on_already) &&
8117 	    (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) {
8118 		return (EALREADY);
8119 	}
8120 
8121 	/*
8122 	 * if we are already set to the appropriate compression
8123 	 * mode, don't set it again
8124 	 */
8125 	if (compression_on) {
8126 		/* compression selected */
8127 		un->un_mspl->page.comp.dce = 1;
8128 	} else {
8129 		un->un_mspl->page.comp.dce = 0;
8130 	}
8131 
8132 
8133 #ifdef STDEBUG
8134 	if ((st_debug & 0x7) >= 6) {
8135 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
8136 		    "st_set_datacomp_page: sense data for mode select",
8137 		    (char *)un->un_mspl, sizeof (struct seq_mode));
8138 	}
8139 #endif
8140 	rval = st_gen_mode_select(un, st_uscsi_cmd, un->un_mspl,
8141 	    sizeof (struct seq_mode));
8142 
8143 	return (rval);
8144 }
8145 
8146 static int
8147 st_modesense(struct scsi_tape *un)
8148 {
8149 	int rval;
8150 	uchar_t page;
8151 
8152 	ST_FUNC(ST_DEVINFO, st_modesense);
8153 
8154 	page = un->un_comp_page;
8155 
8156 	switch (page) {
8157 	case ST_DEV_DATACOMP_PAGE:
8158 	case ST_DEV_CONFIG_PAGE: /* FALLTHROUGH */
8159 		rval = st_gen_mode_sense(un, st_uscsi_cmd, page, un->un_mspl,
8160 		    sizeof (struct seq_mode));
8161 		break;
8162 
8163 	case ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE:
8164 		if (un->un_dp->options & ST_MODE_SEL_COMP) {
8165 			page = ST_DEV_DATACOMP_PAGE;
8166 			rval = st_gen_mode_sense(un, st_uscsi_cmd, page,
8167 			    un->un_mspl, sizeof (struct seq_mode));
8168 			if (rval == 0 && un->un_mspl->page_code == page) {
8169 				un->un_comp_page = page;
8170 				break;
8171 			}
8172 			page = ST_DEV_CONFIG_PAGE;
8173 			rval = st_gen_mode_sense(un, st_uscsi_cmd, page,
8174 			    un->un_mspl, sizeof (struct seq_mode));
8175 			if (rval == 0 && un->un_mspl->page_code == page) {
8176 				un->un_comp_page = page;
8177 				break;
8178 			}
8179 			un->un_dp->options &= ~ST_MODE_SEL_COMP;
8180 			un->un_comp_page = 0;
8181 		} else {
8182 			un->un_comp_page = 0;
8183 		}
8184 
8185 	default:	/* FALLTHROUGH */
8186 		rval = st_cmd(un, SCMD_MODE_SENSE, MSIZE, SYNC_CMD);
8187 	}
8188 	return (rval);
8189 }
8190 
8191 static int
8192 st_modeselect(struct scsi_tape *un)
8193 {
8194 	int rval = 0;
8195 	int ix;
8196 
8197 	ST_FUNC(ST_DEVINFO, st_modeselect);
8198 
8199 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8200 	    "st_modeselect(dev = 0x%lx): density = 0x%x\n",
8201 	    un->un_dev, un->un_mspl->density);
8202 
8203 	ASSERT(mutex_owned(ST_MUTEX));
8204 
8205 	/*
8206 	 * The parameter list should be the same for all of the
8207 	 * cases that follow so set them here
8208 	 *
8209 	 * Try mode select first if if fails set fields manually
8210 	 */
8211 	rval = st_modesense(un);
8212 	if (rval != 0) {
8213 		ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
8214 		    "st_modeselect: First mode sense failed\n");
8215 		un->un_mspl->bd_len  = 8;
8216 		un->un_mspl->high_nb = 0;
8217 		un->un_mspl->mid_nb  = 0;
8218 		un->un_mspl->low_nb  = 0;
8219 	}
8220 	un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16);
8221 	un->un_mspl->mid_bl  = (uchar_t)(un->un_bsize >> 8);
8222 	un->un_mspl->low_bl  = (uchar_t)(un->un_bsize);
8223 
8224 
8225 	/*
8226 	 * If configured to use a specific density code for a media type.
8227 	 * curdens is previously set by the minor node opened.
8228 	 * If the media type doesn't match the minor node we change it so it
8229 	 * looks like the correct one was opened.
8230 	 */
8231 	if (un->un_dp->options & ST_KNOWS_MEDIA) {
8232 		uchar_t best;
8233 
8234 		for (best = 0xff, ix = 0; ix < NDENSITIES; ix++) {
8235 			if (un->un_mspl->media_type ==
8236 			    un->un_dp->mediatype[ix]) {
8237 				best = ix;
8238 				/*
8239 				 * It matches but it might not be the only one.
8240 				 * Use the highest matching media type but not
8241 				 * to exceed the density selected by the open.
8242 				 */
8243 				if (ix < un->un_curdens) {
8244 					continue;
8245 				}
8246 				un->un_curdens = ix;
8247 				break;
8248 			}
8249 		}
8250 		/* If a match was found best will not be 0xff any more */
8251 		if (best < NDENSITIES) {
8252 			ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
8253 			    "found media 0x%X using density 0x%X\n",
8254 			    un->un_mspl->media_type,
8255 			    un->un_dp->densities[best]);
8256 			un->un_mspl->density = un->un_dp->densities[best];
8257 		} else {
8258 			/* Otherwise set density based on minor node opened */
8259 			un->un_mspl->density =
8260 			    un->un_dp->densities[un->un_curdens];
8261 		}
8262 	} else {
8263 		un->un_mspl->density = un->un_dp->densities[un->un_curdens];
8264 	}
8265 
8266 	if (un->un_dp->options & ST_NOBUF) {
8267 		un->un_mspl->bufm = 0;
8268 	} else {
8269 		un->un_mspl->bufm = 1;
8270 	}
8271 
8272 	rval = st_set_compression(un);
8273 
8274 	/*
8275 	 * If st_set_compression returned invalid or already it
8276 	 * found no need to do the mode select.
8277 	 * So do it here.
8278 	 */
8279 	if ((rval == ENOTTY) || (rval == EALREADY)) {
8280 
8281 		/* Zero non-writeable fields */
8282 		un->un_mspl->data_len = 0;
8283 		un->un_mspl->media_type = 0;
8284 		un->un_mspl->wp = 0;
8285 
8286 		/* need to set the density code */
8287 		rval = st_cmd(un, SCMD_MODE_SELECT, MSIZE, SYNC_CMD);
8288 		if (rval != 0) {
8289 			if (un->un_state >= ST_STATE_OPEN) {
8290 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
8291 				    "unable to set tape mode\n");
8292 				un->un_pos.pmode = invalid;
8293 				rval = EIO;
8294 			} else {
8295 				rval = -1;
8296 			}
8297 		}
8298 	}
8299 
8300 	/*
8301 	 * The spec recommends to send a mode sense after a mode select
8302 	 */
8303 	(void) st_modesense(un);
8304 
8305 	ASSERT(mutex_owned(ST_MUTEX));
8306 
8307 	return (rval);
8308 }
8309 
8310 /*
8311  * st_gen_mode_sense
8312  *
8313  * generic mode sense.. it allows for any page
8314  */
8315 static int
8316 st_gen_mode_sense(struct scsi_tape *un, ubufunc_t ubf, int page,
8317     struct seq_mode *page_data, int page_size)
8318 {
8319 
8320 	int r;
8321 	char	cdb[CDB_GROUP0];
8322 	struct uscsi_cmd *com;
8323 	struct scsi_arq_status status;
8324 
8325 	ST_FUNC(ST_DEVINFO, st_gen_mode_sense);
8326 
8327 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
8328 
8329 	bzero(cdb, CDB_GROUP0);
8330 	cdb[0] = SCMD_MODE_SENSE;
8331 	cdb[2] = (char)page;
8332 	cdb[4] = (char)page_size;
8333 
8334 	com->uscsi_cdb = cdb;
8335 	com->uscsi_cdblen = CDB_GROUP0;
8336 	com->uscsi_bufaddr = (caddr_t)page_data;
8337 	com->uscsi_buflen = page_size;
8338 	com->uscsi_rqlen = sizeof (status);
8339 	com->uscsi_rqbuf = (caddr_t)&status;
8340 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
8341 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ;
8342 
8343 	r = ubf(un, com, FKIOCTL);
8344 	kmem_free(com, sizeof (*com));
8345 	return (r);
8346 }
8347 
8348 /*
8349  * st_gen_mode_select
8350  *
8351  * generic mode select.. it allows for any page
8352  */
8353 static int
8354 st_gen_mode_select(struct scsi_tape *un, ubufunc_t ubf,
8355     struct seq_mode *page_data, int page_size)
8356 {
8357 
8358 	int r;
8359 	char cdb[CDB_GROUP0];
8360 	struct uscsi_cmd *com;
8361 	struct scsi_arq_status status;
8362 
8363 	ST_FUNC(ST_DEVINFO, st_gen_mode_select);
8364 
8365 	/* Zero non-writeable fields */
8366 	page_data->data_len = 0;
8367 	page_data->media_type = 0;
8368 	page_data->wp = 0;
8369 
8370 	/*
8371 	 * If mode select has any page data, zero the ps (Page Savable) bit.
8372 	 */
8373 	if (page_size > MSIZE) {
8374 		page_data->ps = 0;
8375 	}
8376 
8377 
8378 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
8379 
8380 	/*
8381 	 * then, do a mode select to set what ever info
8382 	 */
8383 	bzero(cdb, CDB_GROUP0);
8384 	cdb[0] = SCMD_MODE_SELECT;
8385 	cdb[1] = 0x10;		/* set PF bit for many third party drives */
8386 	cdb[4] = (char)page_size;
8387 
8388 	com->uscsi_cdb = cdb;
8389 	com->uscsi_cdblen = CDB_GROUP0;
8390 	com->uscsi_bufaddr = (caddr_t)page_data;
8391 	com->uscsi_buflen = page_size;
8392 	com->uscsi_rqlen = sizeof (status);
8393 	com->uscsi_rqbuf = (caddr_t)&status;
8394 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
8395 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_WRITE;
8396 
8397 	r = ubf(un, com, FKIOCTL);
8398 
8399 	kmem_free(com, sizeof (*com));
8400 	return (r);
8401 }
8402 
8403 static int
8404 st_read_block_limits(struct scsi_tape *un, struct read_blklim *read_blk)
8405 {
8406 	int rval;
8407 	char cdb[CDB_GROUP0];
8408 	struct uscsi_cmd *com;
8409 	struct scsi_arq_status status;
8410 
8411 	ST_FUNC(ST_DEVINFO, st_read_block_limits);
8412 
8413 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
8414 
8415 	bzero(cdb, CDB_GROUP0);
8416 	cdb[0] = SCMD_READ_BLKLIM;
8417 
8418 	com->uscsi_cdb = cdb;
8419 	com->uscsi_cdblen = CDB_GROUP0;
8420 	com->uscsi_bufaddr = (caddr_t)read_blk;
8421 	com->uscsi_buflen = sizeof (struct read_blklim);
8422 	com->uscsi_rqlen = sizeof (status);
8423 	com->uscsi_rqbuf = (caddr_t)&status;
8424 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
8425 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ;
8426 
8427 	rval = st_uscsi_cmd(un, com, FKIOCTL);
8428 	if (com->uscsi_status || com->uscsi_resid) {
8429 		rval = -1;
8430 	}
8431 
8432 	kmem_free(com, sizeof (*com));
8433 	return (rval);
8434 }
8435 
8436 static int
8437 st_report_density_support(struct scsi_tape *un, uchar_t *density_data,
8438     size_t buflen)
8439 {
8440 	int rval;
8441 	char cdb[CDB_GROUP1];
8442 	struct uscsi_cmd *com;
8443 	struct scsi_arq_status status;
8444 
8445 	ST_FUNC(ST_DEVINFO, st_report_density_support);
8446 
8447 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
8448 
8449 	bzero(cdb, CDB_GROUP1);
8450 	cdb[0] = SCMD_REPORT_DENSITIES;
8451 	cdb[7] = (buflen & 0xff00) >> 8;
8452 	cdb[8] = buflen & 0xff;
8453 
8454 	com->uscsi_cdb = cdb;
8455 	com->uscsi_cdblen = CDB_GROUP1;
8456 	com->uscsi_bufaddr = (caddr_t)density_data;
8457 	com->uscsi_buflen = buflen;
8458 	com->uscsi_rqlen = sizeof (status);
8459 	com->uscsi_rqbuf = (caddr_t)&status;
8460 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
8461 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ;
8462 
8463 	rval = st_uscsi_cmd(un, com, FKIOCTL);
8464 	if (com->uscsi_status || com->uscsi_resid) {
8465 		rval = -1;
8466 	}
8467 
8468 	kmem_free(com, sizeof (*com));
8469 	return (rval);
8470 }
8471 
8472 static int
8473 st_report_supported_operation(struct scsi_tape *un, uchar_t *oper_data,
8474     uchar_t option_code, ushort_t service_action)
8475 {
8476 	int rval;
8477 	char cdb[CDB_GROUP5];
8478 	struct uscsi_cmd *com;
8479 	struct scsi_arq_status status;
8480 	uint32_t allo_length;
8481 
8482 	ST_FUNC(ST_DEVINFO, st_report_supported_operation);
8483 
8484 	allo_length = sizeof (struct one_com_des) +
8485 	    sizeof (struct com_timeout_des);
8486 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
8487 
8488 	bzero(cdb, CDB_GROUP5);
8489 	cdb[0] = (char)SCMD_MAINTENANCE_IN;
8490 	cdb[1] = SSVC_ACTION_GET_SUPPORTED_OPERATIONS;
8491 	if (service_action) {
8492 		cdb[2] = (char)(ONE_COMMAND_DATA_FORMAT | 0x80); /* RCTD */
8493 		cdb[4] = (service_action & 0xff00) >> 8;
8494 		cdb[5] = service_action & 0xff;
8495 	} else {
8496 		cdb[2] = (char)(ONE_COMMAND_NO_SERVICE_DATA_FORMAT |
8497 		    0x80); /* RCTD */
8498 	}
8499 	cdb[3] = option_code;
8500 	cdb[6] = (allo_length & 0xff000000) >> 24;
8501 	cdb[7] = (allo_length & 0xff0000) >> 16;
8502 	cdb[8] = (allo_length & 0xff00) >> 8;
8503 	cdb[9] = allo_length & 0xff;
8504 
8505 	com->uscsi_cdb = cdb;
8506 	com->uscsi_cdblen = CDB_GROUP5;
8507 	com->uscsi_bufaddr = (caddr_t)oper_data;
8508 	com->uscsi_buflen = allo_length;
8509 	com->uscsi_rqlen = sizeof (status);
8510 	com->uscsi_rqbuf = (caddr_t)&status;
8511 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
8512 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ;
8513 
8514 	rval = st_uscsi_cmd(un, com, FKIOCTL);
8515 	if (com->uscsi_status) {
8516 		rval = -1;
8517 	}
8518 
8519 	kmem_free(com, sizeof (*com));
8520 	return (rval);
8521 }
8522 
8523 /*
8524  * Changes devices blocksize and bsize to requested blocksize nblksz.
8525  * Returns returned value from first failed call or zero on success.
8526  */
8527 static int
8528 st_change_block_size(struct scsi_tape *un, uint32_t nblksz)
8529 {
8530 	struct seq_mode *current;
8531 	int rval;
8532 	uint32_t oldblksz;
8533 
8534 	ST_FUNC(ST_DEVINFO, st_change_block_size);
8535 
8536 	current = kmem_zalloc(MSIZE, KM_SLEEP);
8537 
8538 	/*
8539 	 * If we haven't got the compression page yet, do that first.
8540 	 */
8541 	if (un->un_comp_page == (ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE)) {
8542 		(void) st_modesense(un);
8543 	}
8544 
8545 	/* Read current settings */
8546 	rval = st_gen_mode_sense(un, st_uscsi_cmd, 0, current, MSIZE);
8547 	if (rval != 0) {
8548 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
8549 		    "mode sense for change block size failed: rval = %d", rval);
8550 		goto finish;
8551 	}
8552 
8553 	/* Figure the current block size */
8554 	oldblksz =
8555 	    (current->high_bl << 16) |
8556 	    (current->mid_bl << 8) |
8557 	    (current->low_bl);
8558 
8559 	/* If current block size is the same as requested were done */
8560 	if (oldblksz == nblksz) {
8561 		un->un_bsize = nblksz;
8562 		rval = 0;
8563 		goto finish;
8564 	}
8565 
8566 	/* Change to requested block size */
8567 	current->high_bl = (uchar_t)(nblksz >> 16);
8568 	current->mid_bl  = (uchar_t)(nblksz >> 8);
8569 	current->low_bl  = (uchar_t)(nblksz);
8570 
8571 	/* Attempt to change block size */
8572 	rval = st_gen_mode_select(un, st_uscsi_cmd, current, MSIZE);
8573 	if (rval != 0) {
8574 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
8575 		    "Set new block size failed: rval = %d", rval);
8576 		goto finish;
8577 	}
8578 
8579 	/* Read back and verify setting */
8580 	rval = st_modesense(un);
8581 	if (rval == 0) {
8582 		un->un_bsize =
8583 		    (un->un_mspl->high_bl << 16) |
8584 		    (un->un_mspl->mid_bl << 8) |
8585 		    (un->un_mspl->low_bl);
8586 
8587 		if (un->un_bsize != nblksz) {
8588 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
8589 			    "Blocksize set does not equal requested blocksize"
8590 			    "(read: %u requested: %u)\n", nblksz, un->un_bsize);
8591 			rval = EIO;
8592 		}
8593 	}
8594 finish:
8595 	kmem_free(current, MSIZE);
8596 	return (rval);
8597 }
8598 
8599 
8600 static void
8601 st_init(struct scsi_tape *un)
8602 {
8603 	ST_FUNC(ST_DEVINFO, st_init);
8604 
8605 	ASSERT(mutex_owned(ST_MUTEX));
8606 
8607 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8608 	    "st_init(): dev = 0x%lx, will reset fileno, blkno, eof\n",
8609 	    un->un_dev);
8610 
8611 	un->un_pos.blkno = 0;
8612 	un->un_pos.fileno = 0;
8613 	un->un_lastop = ST_OP_NIL;
8614 	un->un_pos.eof = ST_NO_EOF;
8615 	un->un_pwr_mgmt = ST_PWR_NORMAL;
8616 	if (st_error_level != SCSI_ERR_ALL) {
8617 		if (DEBUGGING) {
8618 			st_error_level = SCSI_ERR_ALL;
8619 		} else {
8620 			st_error_level = SCSI_ERR_RETRYABLE;
8621 		}
8622 	}
8623 }
8624 
8625 
8626 static void
8627 st_make_cmd(struct scsi_tape *un, struct buf *bp, int (*func)(caddr_t))
8628 {
8629 	struct scsi_pkt *pkt;
8630 	struct uscsi_cmd *ucmd;
8631 	recov_info *ri;
8632 	int tval = 0;
8633 	int64_t count;
8634 	uint32_t additional = 0;
8635 	uint32_t address = 0;
8636 	union scsi_cdb *ucdb;
8637 	int flags = 0;
8638 	int cdb_len = CDB_GROUP0; /* default */
8639 	uchar_t com;
8640 	char fixbit;
8641 	char short_fm = 0;
8642 	optype prev_op = un->un_lastop;
8643 	int stat_size =
8644 	    (un->un_arq_enabled ? sizeof (struct scsi_arq_status) : 1);
8645 
8646 	ST_FUNC(ST_DEVINFO, st_make_cmd);
8647 
8648 	ASSERT(mutex_owned(ST_MUTEX));
8649 
8650 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8651 	    "st_make_cmd(): dev = 0x%lx\n", un->un_dev);
8652 
8653 
8654 	/*
8655 	 * fixbit is for setting the Fixed Mode and Suppress Incorrect
8656 	 * Length Indicator bits on read/write commands, for setting
8657 	 * the Long bit on erase commands, and for setting the Code
8658 	 * Field bits on space commands.
8659 	 */
8660 
8661 	/* regular raw I/O */
8662 	if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) {
8663 		pkt = scsi_init_pkt(ROUTE, NULL, bp,
8664 		    CDB_GROUP0, stat_size, st_recov_sz, 0, func,
8665 		    (caddr_t)un);
8666 		if (pkt == NULL) {
8667 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
8668 			    "Read Write scsi_init_pkt() failure\n");
8669 			goto exit;
8670 		}
8671 		ASSERT(pkt->pkt_resid == 0);
8672 #ifdef STDEBUG
8673 		bzero(pkt->pkt_private, st_recov_sz);
8674 		bzero(pkt->pkt_scbp, stat_size);
8675 #endif
8676 		ri = (recov_info *)pkt->pkt_private;
8677 		ri->privatelen = st_recov_sz;
8678 		if (un->un_bsize == 0) {
8679 			count = bp->b_bcount;
8680 			fixbit = 0;
8681 		} else {
8682 			count = bp->b_bcount / un->un_bsize;
8683 			fixbit = 1;
8684 		}
8685 		if (bp->b_flags & B_READ) {
8686 			com = SCMD_READ;
8687 			un->un_lastop = ST_OP_READ;
8688 			if ((un->un_bsize == 0) && /* Not Fixed Block */
8689 			    (un->un_dp->options & ST_READ_IGNORE_ILI)) {
8690 				fixbit = 2;
8691 			}
8692 		} else {
8693 			com = SCMD_WRITE;
8694 			un->un_lastop = ST_OP_WRITE;
8695 		}
8696 		tval = un->un_dp->io_timeout;
8697 
8698 		/*
8699 		 * For really large xfers, increase timeout
8700 		 */
8701 		if (bp->b_bcount > (10 * ONE_MEG))
8702 			tval *= bp->b_bcount/(10 * ONE_MEG);
8703 
8704 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8705 		    "%s %d amt 0x%lx\n", (com == SCMD_WRITE) ?
8706 		    wr_str: rd_str, un->un_pos.blkno, bp->b_bcount);
8707 
8708 	} else if ((ucmd = BP_UCMD(bp)) != NULL) {
8709 		/*
8710 		 * uscsi - build command, allocate scsi resources
8711 		 */
8712 		st_make_uscsi_cmd(un, ucmd, bp, func);
8713 		goto exit;
8714 
8715 	} else {				/* special I/O */
8716 		struct buf *allocbp = NULL;
8717 		com = (uchar_t)(uintptr_t)bp->b_forw;
8718 		count = bp->b_bcount;
8719 
8720 		switch (com) {
8721 		case SCMD_READ:
8722 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8723 			    "special read %"PRId64"\n", count);
8724 			if (un->un_bsize == 0) {
8725 				fixbit = 2;	/* suppress SILI */
8726 			} else {
8727 				fixbit = 1;	/* Fixed Block Mode */
8728 				count /= un->un_bsize;
8729 			}
8730 			allocbp = bp;
8731 			un->un_lastop = ST_OP_READ;
8732 			tval = un->un_dp->io_timeout;
8733 			break;
8734 
8735 		case SCMD_WRITE:
8736 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8737 			    "special write %"PRId64"\n", count);
8738 			if (un->un_bsize != 0) {
8739 				fixbit = 1;	/* Fixed Block Mode */
8740 				count /= un->un_bsize;
8741 			} else {
8742 				fixbit = 0;
8743 			}
8744 			allocbp = bp;
8745 			un->un_lastop = ST_OP_WRITE;
8746 			tval = un->un_dp->io_timeout;
8747 			break;
8748 
8749 		case SCMD_WRITE_FILE_MARK:
8750 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8751 			    "write %"PRId64" file marks\n", count);
8752 			un->un_lastop = ST_OP_WEOF;
8753 			fixbit = 0;
8754 			tval = un->un_dp->io_timeout;
8755 			/*
8756 			 * If ST_SHORT_FILEMARKS bit is ON for EXABYTE
8757 			 * device, set the Vendor Unique bit to
8758 			 * write Short File Mark.
8759 			 */
8760 			if ((un->un_dp->options & ST_SHORT_FILEMARKS) &&
8761 			    ((un->un_dp->type == ST_TYPE_EXB8500) ||
8762 			    (un->un_dp->type == ST_TYPE_EXABYTE))) {
8763 				/*
8764 				 * Now the Vendor Unique bit 7 in Byte 5 of CDB
8765 				 * is set to to write Short File Mark
8766 				 */
8767 				short_fm = 1;
8768 			}
8769 			break;
8770 
8771 		case SCMD_REWIND:
8772 			/*
8773 			 * In the case of rewind we're gona do the rewind with
8774 			 * the immediate bit set so status will be retured when
8775 			 * the command is accepted by the device. We clear the
8776 			 * B_ASYNC flag so we wait for that acceptance.
8777 			 */
8778 			fixbit = 0;
8779 			if (bp->b_flags & B_ASYNC) {
8780 				allocbp = bp;
8781 				if (count) {
8782 					fixbit = 1;
8783 					bp->b_flags &= ~B_ASYNC;
8784 				}
8785 			}
8786 			count = 0;
8787 			bp->b_bcount = 0;
8788 			un->un_lastop = ST_OP_CTL;
8789 			tval = un->un_dp->rewind_timeout;
8790 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8791 			    "rewind\n");
8792 			break;
8793 
8794 		case SCMD_SPACE_G4:
8795 			cdb_len = CDB_GROUP4;
8796 			fixbit = SPACE_TYPE(bp->b_bcount);
8797 			count = SPACE_CNT(bp->b_bcount);
8798 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
8799 			    " %s space %s %"PRId64" from file %d blk %d\n",
8800 			    bp->b_bcount & SP_BACKSP ? "backward" : "forward",
8801 			    space_strs[fixbit & 7], count,
8802 			    un->un_pos.fileno, un->un_pos.blkno);
8803 			address = (count >> 48) & 0x1fff;
8804 			additional = (count >> 16) & 0xffffffff;
8805 			count &= 0xffff;
8806 			count <<= 16;
8807 			un->un_lastop = ST_OP_CTL;
8808 			tval = un->un_dp->space_timeout;
8809 			break;
8810 
8811 		case SCMD_SPACE:
8812 			fixbit = SPACE_TYPE(bp->b_bcount);
8813 			count = SPACE_CNT(bp->b_bcount);
8814 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8815 			    " %s space %s %"PRId64" from file %d blk %d\n",
8816 			    bp->b_bcount & SP_BACKSP ? "backward" : "forward",
8817 			    space_strs[fixbit & 7], count,
8818 			    un->un_pos.fileno, un->un_pos.blkno);
8819 			count &= 0xffffffff;
8820 			un->un_lastop = ST_OP_CTL;
8821 			tval = un->un_dp->space_timeout;
8822 			break;
8823 
8824 		case SCMD_LOAD:
8825 			ASSERT(count < 10);
8826 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8827 			    "%s tape\n", load_strs[count]);
8828 			fixbit = 0;
8829 
8830 			/* Loading or Unloading */
8831 			if (count & LD_LOAD) {
8832 				tval = un->un_dp->load_timeout;
8833 			} else {
8834 				tval = un->un_dp->unload_timeout;
8835 			}
8836 			/* Is Retension requested */
8837 			if (count & LD_RETEN) {
8838 				tval += un->un_dp->rewind_timeout;
8839 			}
8840 			un->un_lastop = ST_OP_CTL;
8841 			break;
8842 
8843 		case SCMD_ERASE:
8844 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8845 			    "erase tape\n");
8846 			ASSERT(count == 1); /* mt sets this */
8847 			if (count == 1) {
8848 				/*
8849 				 * do long erase
8850 				 */
8851 				fixbit = 1; /* Long */
8852 
8853 				/* Drive might not honor immidiate bit */
8854 				tval = un->un_dp->erase_timeout;
8855 			} else {
8856 				/* Short Erase */
8857 				tval = un->un_dp->erase_timeout;
8858 				fixbit = 0;
8859 			}
8860 			un->un_lastop = ST_OP_CTL;
8861 			count = 0;
8862 			break;
8863 
8864 		case SCMD_MODE_SENSE:
8865 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8866 			    "mode sense\n");
8867 			allocbp = bp;
8868 			fixbit = 0;
8869 			tval = un->un_dp->non_motion_timeout;
8870 			un->un_lastop = ST_OP_CTL;
8871 			break;
8872 
8873 		case SCMD_MODE_SELECT:
8874 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8875 			    "mode select\n");
8876 			allocbp = bp;
8877 			fixbit = 0;
8878 			tval = un->un_dp->non_motion_timeout;
8879 			un->un_lastop = ST_OP_CTL;
8880 			break;
8881 
8882 		case SCMD_RESERVE:
8883 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8884 			    "reserve\n");
8885 			fixbit = 0;
8886 			tval = un->un_dp->non_motion_timeout;
8887 			un->un_lastop = ST_OP_CTL;
8888 			break;
8889 
8890 		case SCMD_RELEASE:
8891 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8892 			    "release\n");
8893 			fixbit = 0;
8894 			tval = un->un_dp->non_motion_timeout;
8895 			un->un_lastop = ST_OP_CTL;
8896 			break;
8897 
8898 		case SCMD_READ_BLKLIM:
8899 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8900 			    "read block limits\n");
8901 			allocbp = bp;
8902 			fixbit = count = 0;
8903 			tval = un->un_dp->non_motion_timeout;
8904 			un->un_lastop = ST_OP_CTL;
8905 			break;
8906 
8907 		case SCMD_TEST_UNIT_READY:
8908 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8909 			    "test unit ready\n");
8910 			fixbit = 0;
8911 			tval = un->un_dp->non_motion_timeout;
8912 			un->un_lastop = ST_OP_CTL;
8913 			break;
8914 
8915 		case SCMD_DOORLOCK:
8916 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8917 			    "prevent/allow media removal\n");
8918 			fixbit = 0;
8919 			tval = un->un_dp->non_motion_timeout;
8920 			un->un_lastop = ST_OP_CTL;
8921 			break;
8922 
8923 		case SCMD_READ_POSITION:
8924 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8925 			    "read position\n");
8926 			fixbit = un->un_read_pos_type;
8927 			cdb_len = CDB_GROUP1;
8928 			tval = un->un_dp->non_motion_timeout;
8929 			allocbp = bp;
8930 			un->un_lastop = ST_OP_CTL;
8931 			switch (un->un_read_pos_type) {
8932 			case LONG_POS:
8933 				count = 0;
8934 				break;
8935 			case EXT_POS:
8936 				count = sizeof (tape_position_ext_t);
8937 				break;
8938 			case SHORT_POS:
8939 				count = 0;
8940 				break;
8941 			default:
8942 				ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
8943 				    "Unknown read position type 0x%x in "
8944 				    " st_make_cmd()\n", un->un_read_pos_type);
8945 			}
8946 			break;
8947 
8948 		default:
8949 			ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
8950 			    "Unhandled scsi command 0x%x in st_make_cmd()\n",
8951 			    com);
8952 		}
8953 
8954 		pkt = scsi_init_pkt(ROUTE, NULL, allocbp, cdb_len, stat_size,
8955 		    st_recov_sz, 0, func, (caddr_t)un);
8956 		if (pkt == NULL) {
8957 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
8958 			    "generic command scsi_init_pkt() failure\n");
8959 			goto exit;
8960 		}
8961 
8962 		ASSERT(pkt->pkt_resid == 0);
8963 #ifdef STDEBUG
8964 		bzero(pkt->pkt_private, st_recov_sz);
8965 		bzero(pkt->pkt_scbp, stat_size);
8966 #endif
8967 		ri = (recov_info *)pkt->pkt_private;
8968 		ri->privatelen = st_recov_sz;
8969 		if (allocbp) {
8970 			ASSERT(geterror(allocbp) == 0);
8971 		}
8972 
8973 	}
8974 
8975 	ucdb = (union scsi_cdb *)pkt->pkt_cdbp;
8976 
8977 	(void) scsi_setup_cdb(ucdb, com, address, (uint_t)count, additional);
8978 	FILL_SCSI1_LUN(un->un_sd, pkt);
8979 	/*
8980 	 * Initialize the SILI/Fixed bits of the byte 1 of cdb.
8981 	 */
8982 	ucdb->t_code = fixbit;
8983 	ucdb->g0_vu_1 = short_fm;
8984 	pkt->pkt_flags = flags;
8985 
8986 	ASSERT(tval);
8987 	pkt->pkt_time = tval;
8988 	if (bp == un->un_recov_buf) {
8989 		pkt->pkt_comp = st_recov_cb;
8990 	} else {
8991 		pkt->pkt_comp = st_intr;
8992 	}
8993 
8994 	st_add_recovery_info_to_pkt(un, bp, pkt);
8995 
8996 	/*
8997 	 * If we just write data to tape and did a command that doesn't
8998 	 * change position, we still need to write a filemark.
8999 	 */
9000 	if ((prev_op == ST_OP_WRITE) || (prev_op == ST_OP_WEOF)) {
9001 		recov_info *rcvi = pkt->pkt_private;
9002 		cmd_attribute const *atrib;
9003 
9004 		if (rcvi->privatelen == sizeof (recov_info)) {
9005 			atrib = rcvi->cmd_attrib;
9006 		} else {
9007 			atrib = st_lookup_cmd_attribute(com);
9008 		}
9009 		if (atrib->chg_tape_direction == DIR_NONE) {
9010 			un->un_lastop = prev_op;
9011 		}
9012 	}
9013 
9014 exit:
9015 	ASSERT(mutex_owned(ST_MUTEX));
9016 }
9017 
9018 
9019 /*
9020  * Build a command based on a uscsi command;
9021  */
9022 static void
9023 st_make_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd,
9024     struct buf *bp, int (*func)(caddr_t))
9025 {
9026 	struct scsi_pkt *pkt;
9027 	recov_info *ri;
9028 	caddr_t cdb;
9029 	int	cdblen;
9030 	int	stat_size = 1;
9031 	int	flags = 0;
9032 
9033 	ST_FUNC(ST_DEVINFO, st_make_uscsi_cmd);
9034 
9035 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9036 	    "st_make_uscsi_cmd(): dev = 0x%lx\n", un->un_dev);
9037 
9038 	if (ucmd->uscsi_flags & USCSI_RQENABLE) {
9039 		if (un->un_arq_enabled) {
9040 			if (ucmd->uscsi_rqlen > SENSE_LENGTH) {
9041 				stat_size = (int)(ucmd->uscsi_rqlen) +
9042 				    sizeof (struct scsi_arq_status) -
9043 				    sizeof (struct scsi_extended_sense);
9044 				flags = PKT_XARQ;
9045 			} else {
9046 				stat_size = sizeof (struct scsi_arq_status);
9047 			}
9048 		}
9049 	}
9050 
9051 	ASSERT(mutex_owned(ST_MUTEX));
9052 
9053 	cdb = ucmd->uscsi_cdb;
9054 	cdblen = ucmd->uscsi_cdblen;
9055 
9056 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9057 	    "st_make_uscsi_cmd: buflen=%ld bcount=%ld\n",
9058 	    ucmd->uscsi_buflen, bp->b_bcount);
9059 	pkt = scsi_init_pkt(ROUTE, NULL,
9060 	    (bp->b_bcount > 0) ? bp : NULL,
9061 	    cdblen, stat_size, st_recov_sz, flags, func, (caddr_t)un);
9062 	if (pkt == NULL) {
9063 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
9064 		    "uscsi command scsi_init_pkt() failure\n");
9065 		goto exit;
9066 	}
9067 
9068 	ASSERT(pkt->pkt_resid == 0);
9069 #ifdef STDEBUG
9070 	bzero(pkt->pkt_private, st_recov_sz);
9071 	bzero(pkt->pkt_scbp, stat_size);
9072 #endif
9073 	ri = (recov_info *)pkt->pkt_private;
9074 	ri->privatelen = st_recov_sz;
9075 
9076 	bcopy(cdb, pkt->pkt_cdbp, (uint_t)cdblen);
9077 
9078 #ifdef STDEBUG
9079 	if ((st_debug & 0x7) >= 6) {
9080 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
9081 		    "pkt_cdbp", (char *)cdb, cdblen);
9082 	}
9083 #endif
9084 
9085 	if (ucmd->uscsi_flags & USCSI_SILENT) {
9086 		pkt->pkt_flags |= FLAG_SILENT;
9087 	}
9088 
9089 	(void) scsi_uscsi_pktinit(ucmd, pkt);
9090 
9091 	pkt->pkt_time = ucmd->uscsi_timeout;
9092 	if (bp == un->un_recov_buf) {
9093 		pkt->pkt_comp = st_recov_cb;
9094 	} else {
9095 		pkt->pkt_comp = st_intr;
9096 	}
9097 
9098 	st_add_recovery_info_to_pkt(un, bp, pkt);
9099 exit:
9100 	ASSERT(mutex_owned(ST_MUTEX));
9101 }
9102 
9103 
9104 /*
9105  * restart cmd currently at the head of the runq
9106  *
9107  * If scsi_transport() succeeds or the retries
9108  * count exhausted, restore the throttle that was
9109  * zeroed out in st_handle_intr_busy().
9110  *
9111  */
9112 static void
9113 st_intr_restart(void *arg)
9114 {
9115 	struct scsi_tape *un = arg;
9116 	struct buf *bp;
9117 	int queued;
9118 	int status = TRAN_ACCEPT;
9119 
9120 	mutex_enter(ST_MUTEX);
9121 
9122 	ST_FUNC(ST_DEVINFO, st_intr_restart);
9123 
9124 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9125 	    "st_intr_restart(), un = 0x%p\n", (void *)un);
9126 
9127 	un->un_hib_tid = 0;
9128 
9129 	if (un->un_recov_buf_busy != 0) {
9130 		bp = un->un_recov_buf;
9131 		queued = 0;
9132 	} else if (un->un_sbuf_busy != 0) {
9133 		bp = un->un_sbufp;
9134 		queued = 0;
9135 	} else if (un->un_quef != NULL) {
9136 		bp = un->un_quef;
9137 		queued = 1;
9138 	} else {
9139 		mutex_exit(ST_MUTEX);
9140 		return;
9141 	}
9142 
9143 	/*
9144 	 * Here we know :
9145 	 *	throttle = 0, via st_handle_intr_busy
9146 	 */
9147 
9148 	if (queued) {
9149 		/*
9150 		 * move from waitq to runq, if there is anything on the waitq
9151 		 */
9152 		(void) st_remove_from_queue(&un->un_quef, &un->un_quef, bp);
9153 
9154 		if (un->un_runqf) {
9155 			/*
9156 			 * not good, we don't want to requeue something after
9157 			 * another.
9158 			 */
9159 			goto done_error;
9160 		} else {
9161 			un->un_runqf = bp;
9162 			un->un_runql = bp;
9163 		}
9164 	}
9165 
9166 	ST_CDB(ST_DEVINFO, "Interrupt restart CDB",
9167 	    (char *)BP_PKT(bp)->pkt_cdbp);
9168 
9169 	ST_DO_KSTATS(bp, kstat_waitq_to_runq);
9170 
9171 	status = st_transport(un, BP_PKT(bp));
9172 
9173 	if (status != TRAN_ACCEPT) {
9174 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
9175 
9176 		if (status == TRAN_BUSY) {
9177 			pkt_info *pkti = BP_PKT(bp)->pkt_private;
9178 
9179 			if (pkti->privatelen == sizeof (recov_info) &&
9180 			    un->un_unit_attention_flags &&
9181 			    bp != un->un_recov_buf) {
9182 			un->un_unit_attention_flags = 0;
9183 				ST_RECOV(ST_DEVINFO, st_label, CE_WARN,
9184 				    "Command Recovery called on busy resend\n");
9185 				if (st_command_recovery(un, BP_PKT(bp),
9186 				    ATTEMPT_RETRY) == JUST_RETURN) {
9187 					mutex_exit(ST_MUTEX);
9188 					return;
9189 				}
9190 			}
9191 			mutex_exit(ST_MUTEX);
9192 			if (st_handle_intr_busy(un, bp,
9193 			    ST_TRAN_BUSY_TIMEOUT) == 0)
9194 				return;	/* timeout is setup again */
9195 			mutex_enter(ST_MUTEX);
9196 		}
9197 
9198 done_error:
9199 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9200 		    "restart transport rejected\n");
9201 		bp->b_resid = bp->b_bcount;
9202 
9203 		if (un->un_last_throttle) {
9204 			un->un_throttle = un->un_last_throttle;
9205 		}
9206 		if (status != TRAN_ACCEPT) {
9207 			ST_DO_ERRSTATS(un, st_transerrs);
9208 		}
9209 		ST_DO_KSTATS(bp, kstat_waitq_exit);
9210 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9211 		    "busy restart aborted\n");
9212 		st_set_pe_flag(un);
9213 		st_bioerror(bp, EIO);
9214 		st_done_and_mutex_exit(un, bp);
9215 	} else {
9216 		if (un->un_last_throttle) {
9217 			un->un_throttle = un->un_last_throttle;
9218 		}
9219 		mutex_exit(ST_MUTEX);
9220 	}
9221 }
9222 
9223 /*
9224  * st_check_media():
9225  * Periodically check the media state using scsi_watch service;
9226  * this service calls back after TUR and possibly request sense
9227  * the callback handler (st_media_watch_cb()) decodes the request sense
9228  * data (if any)
9229  */
9230 
9231 static int
9232 st_check_media(dev_t dev, enum mtio_state state)
9233 {
9234 	int rval = 0;
9235 	enum mtio_state	prev_state;
9236 	opaque_t token = NULL;
9237 
9238 	GET_SOFT_STATE(dev);
9239 
9240 	ST_FUNC(ST_DEVINFO, st_check_media);
9241 
9242 	mutex_enter(ST_MUTEX);
9243 
9244 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9245 	    "st_check_media:state=%x, mediastate=%x\n",
9246 	    state, un->un_mediastate);
9247 
9248 	prev_state = un->un_mediastate;
9249 
9250 	/*
9251 	 * is there anything to do?
9252 	 */
9253 retry:
9254 	if (state == un->un_mediastate || un->un_mediastate == MTIO_NONE) {
9255 		/*
9256 		 * submit the request to the scsi_watch service;
9257 		 * scsi_media_watch_cb() does the real work
9258 		 */
9259 		mutex_exit(ST_MUTEX);
9260 		token = scsi_watch_request_submit(ST_SCSI_DEVP,
9261 		    st_check_media_time, SENSE_LENGTH,
9262 		    st_media_watch_cb, (caddr_t)dev);
9263 		if (token == NULL) {
9264 			rval = EAGAIN;
9265 			goto done;
9266 		}
9267 		mutex_enter(ST_MUTEX);
9268 
9269 		un->un_swr_token = token;
9270 		un->un_specified_mediastate = state;
9271 
9272 		/*
9273 		 * now wait for media change
9274 		 * we will not be signalled unless mediastate == state but it
9275 		 * still better to test for this condition, since there
9276 		 * is a 5 sec cv_broadcast delay when
9277 		 *  mediastate == MTIO_INSERTED
9278 		 */
9279 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9280 		    "st_check_media:waiting for media state change\n");
9281 		while (un->un_mediastate == state) {
9282 			if (cv_wait_sig(&un->un_state_cv, ST_MUTEX) == 0) {
9283 				mutex_exit(ST_MUTEX);
9284 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9285 				    "st_check_media:waiting for media state "
9286 				    "was interrupted\n");
9287 				rval = EINTR;
9288 				goto done;
9289 			}
9290 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9291 			    "st_check_media:received signal, state=%x\n",
9292 			    un->un_mediastate);
9293 		}
9294 	}
9295 
9296 	/*
9297 	 * if we transitioned to MTIO_INSERTED, media has really been
9298 	 * inserted.  If TUR fails, it is probably a exabyte slow spin up.
9299 	 * Reset and retry the state change.  If everything is ok, replay
9300 	 * the open() logic.
9301 	 */
9302 	if ((un->un_mediastate == MTIO_INSERTED) &&
9303 	    (un->un_state == ST_STATE_OFFLINE)) {
9304 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9305 		    "st_check_media: calling st_cmd to confirm inserted\n");
9306 
9307 		/*
9308 		 * set this early so that TUR will make it through strategy
9309 		 * without triggering a st_tape_init().  We needed it set
9310 		 * before calling st_tape_init() ourselves anyway.  If TUR
9311 		 * fails, set it back
9312 		 */
9313 		un->un_state = ST_STATE_INITIALIZING;
9314 
9315 		/*
9316 		 * If not reserved fail as getting reservation conflict
9317 		 * will make this hang forever.
9318 		 */
9319 		if ((un->un_rsvd_status &
9320 		    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) {
9321 			mutex_exit(ST_MUTEX);
9322 			rval = EACCES;
9323 			goto done;
9324 		}
9325 		rval = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
9326 		if (rval == EACCES) {
9327 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9328 			    "st_check_media: TUR got Reservation Conflict\n");
9329 			mutex_exit(ST_MUTEX);
9330 			goto done;
9331 		}
9332 		if (rval) {
9333 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9334 			    "st_check_media: TUR failed, going to retry\n");
9335 			un->un_mediastate = prev_state;
9336 			un->un_state = ST_STATE_OFFLINE;
9337 			goto retry;
9338 		}
9339 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9340 		    "st_check_media: media inserted\n");
9341 
9342 		/* this also rewinds the tape */
9343 		rval = st_tape_init(un);
9344 		if (rval != 0) {
9345 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9346 			    "st_check_media : OFFLINE init failure ");
9347 			un->un_state = ST_STATE_OFFLINE;
9348 			un->un_pos.pmode = invalid;
9349 		} else {
9350 			un->un_state = ST_STATE_OPEN_PENDING_IO;
9351 		}
9352 	} else if ((un->un_mediastate == MTIO_EJECTED) &&
9353 	    (un->un_state != ST_STATE_OFFLINE)) {
9354 		/*
9355 		 * supported devices must be rewound before ejection
9356 		 * rewind resets fileno & blkno
9357 		 */
9358 		un->un_laststate = un->un_state;
9359 		un->un_state = ST_STATE_OFFLINE;
9360 	}
9361 	mutex_exit(ST_MUTEX);
9362 done:
9363 	if (token) {
9364 		(void) scsi_watch_request_terminate(token,
9365 		    SCSI_WATCH_TERMINATE_WAIT);
9366 		mutex_enter(ST_MUTEX);
9367 		un->un_swr_token = (opaque_t)NULL;
9368 		mutex_exit(ST_MUTEX);
9369 	}
9370 
9371 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_media: done\n");
9372 
9373 	return (rval);
9374 }
9375 
9376 /*
9377  * st_media_watch_cb() is called by scsi_watch_thread for
9378  * verifying the request sense data (if any)
9379  */
9380 static int
9381 st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
9382 {
9383 	struct scsi_status *statusp = resultp->statusp;
9384 	struct scsi_extended_sense *sensep = resultp->sensep;
9385 	uchar_t actual_sense_length = resultp->actual_sense_length;
9386 	struct scsi_tape *un;
9387 	enum mtio_state state = MTIO_NONE;
9388 	int instance;
9389 	dev_t dev = (dev_t)arg;
9390 
9391 	instance = MTUNIT(dev);
9392 	if ((un = ddi_get_soft_state(st_state, instance)) == NULL) {
9393 		return (-1);
9394 	}
9395 
9396 	mutex_enter(ST_MUTEX);
9397 	ST_FUNC(ST_DEVINFO, st_media_watch_cb);
9398 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9399 	    "st_media_watch_cb: status=%x, sensep=%p, len=%x\n",
9400 	    *((char *)statusp), (void *)sensep,
9401 	    actual_sense_length);
9402 
9403 
9404 	/*
9405 	 * if there was a check condition then sensep points to valid
9406 	 * sense data
9407 	 * if status was not a check condition but a reservation or busy
9408 	 * status then the new state is MTIO_NONE
9409 	 */
9410 	if (sensep) {
9411 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9412 		    "st_media_watch_cb: KEY=%x, ASC=%x, ASCQ=%x\n",
9413 		    sensep->es_key, sensep->es_add_code, sensep->es_qual_code);
9414 
9415 		switch (un->un_dp->type) {
9416 		default:
9417 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9418 			    "st_media_watch_cb: unknown drive type %d, "
9419 			    "default to ST_TYPE_HP\n", un->un_dp->type);
9420 		/* FALLTHROUGH */
9421 
9422 		case ST_TYPE_STC3490:	/* STK 4220 1/2" cartridge */
9423 		case ST_TYPE_FUJI:	/* 1/2" cartridge */
9424 		case ST_TYPE_HP:	/* HP 88780 1/2" reel */
9425 			if (un->un_dp->type == ST_TYPE_FUJI) {
9426 				ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9427 				    "st_media_watch_cb: ST_TYPE_FUJI\n");
9428 			} else {
9429 				ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9430 				    "st_media_watch_cb: ST_TYPE_HP\n");
9431 			}
9432 			switch (sensep->es_key) {
9433 			case KEY_UNIT_ATTENTION:
9434 				/* not ready to ready transition */
9435 				/* hp/es_qual_code == 80 on>off>on */
9436 				/* hp/es_qual_code == 0 on>off>unld>ld>on */
9437 				if (sensep->es_add_code == 0x28) {
9438 					state = MTIO_INSERTED;
9439 				}
9440 				break;
9441 			case KEY_NOT_READY:
9442 				/* in process, rewinding or loading */
9443 				if ((sensep->es_add_code == 0x04) &&
9444 				    (sensep->es_qual_code == 0x00)) {
9445 					state = MTIO_EJECTED;
9446 				}
9447 				break;
9448 			}
9449 			break;
9450 
9451 		case ST_TYPE_EXB8500:	/* Exabyte 8500 */
9452 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9453 			    "st_media_watch_cb: ST_TYPE_EXB8500\n");
9454 			switch (sensep->es_key) {
9455 			case KEY_UNIT_ATTENTION:
9456 				/* operator medium removal request */
9457 				if ((sensep->es_add_code == 0x5a) &&
9458 				    (sensep->es_qual_code == 0x01)) {
9459 					state = MTIO_EJECTED;
9460 				/* not ready to ready transition */
9461 				} else if ((sensep->es_add_code == 0x28) &&
9462 				    (sensep->es_qual_code == 0x00)) {
9463 					state = MTIO_INSERTED;
9464 				}
9465 				break;
9466 			case KEY_NOT_READY:
9467 				/* medium not present */
9468 				if (sensep->es_add_code == 0x3a) {
9469 					state = MTIO_EJECTED;
9470 				}
9471 				break;
9472 			}
9473 			break;
9474 		case ST_TYPE_EXABYTE:	/* Exabyte 8200 */
9475 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9476 			    "st_media_watch_cb: ST_TYPE_EXABYTE\n");
9477 			switch (sensep->es_key) {
9478 			case KEY_NOT_READY:
9479 				if ((sensep->es_add_code == 0x04) &&
9480 				    (sensep->es_qual_code == 0x00)) {
9481 					/* volume not mounted? */
9482 					state = MTIO_EJECTED;
9483 				} else if (sensep->es_add_code == 0x3a) {
9484 					state = MTIO_EJECTED;
9485 				}
9486 				break;
9487 			case KEY_UNIT_ATTENTION:
9488 				state = MTIO_EJECTED;
9489 				break;
9490 			}
9491 			break;
9492 
9493 		case ST_TYPE_DLT:		/* quantum DLT4xxx */
9494 			switch (sensep->es_key) {
9495 			case KEY_UNIT_ATTENTION:
9496 				if (sensep->es_add_code == 0x28) {
9497 					state = MTIO_INSERTED;
9498 				}
9499 				break;
9500 			case KEY_NOT_READY:
9501 				if (sensep->es_add_code == 0x04) {
9502 					/* in transition but could be either */
9503 					state = un->un_specified_mediastate;
9504 				} else if ((sensep->es_add_code == 0x3a) &&
9505 				    (sensep->es_qual_code == 0x00)) {
9506 					state = MTIO_EJECTED;
9507 				}
9508 				break;
9509 			}
9510 			break;
9511 		}
9512 	} else if (*((char *)statusp) == STATUS_GOOD) {
9513 		state = MTIO_INSERTED;
9514 	}
9515 
9516 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9517 	    "st_media_watch_cb:state=%x, specified=%x\n",
9518 	    state, un->un_specified_mediastate);
9519 
9520 	/*
9521 	 * now signal the waiting thread if this is *not* the specified state;
9522 	 * delay the signal if the state is MTIO_INSERTED
9523 	 * to allow the target to recover
9524 	 */
9525 	if (state != un->un_specified_mediastate) {
9526 		un->un_mediastate = state;
9527 		if (state == MTIO_INSERTED) {
9528 			/*
9529 			 * delay the signal to give the drive a chance
9530 			 * to do what it apparently needs to do
9531 			 */
9532 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9533 			    "st_media_watch_cb:delayed cv_broadcast\n");
9534 			un->un_delay_tid = timeout(st_delayed_cv_broadcast,
9535 			    un, drv_usectohz((clock_t)MEDIA_ACCESS_DELAY));
9536 		} else {
9537 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9538 			    "st_media_watch_cb:immediate cv_broadcast\n");
9539 			cv_broadcast(&un->un_state_cv);
9540 		}
9541 	}
9542 	mutex_exit(ST_MUTEX);
9543 	return (0);
9544 }
9545 
9546 /*
9547  * delayed cv_broadcast to allow for target to recover
9548  * from media insertion
9549  */
9550 static void
9551 st_delayed_cv_broadcast(void *arg)
9552 {
9553 	struct scsi_tape *un = arg;
9554 
9555 	ST_FUNC(ST_DEVINFO, st_delayed_cv_broadcast);
9556 
9557 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9558 	    "st_delayed_cv_broadcast:delayed cv_broadcast\n");
9559 
9560 	mutex_enter(ST_MUTEX);
9561 	cv_broadcast(&un->un_state_cv);
9562 	mutex_exit(ST_MUTEX);
9563 }
9564 
9565 /*
9566  * restart cmd currently at the start of the waitq
9567  */
9568 static void
9569 st_start_restart(void *arg)
9570 {
9571 	struct scsi_tape *un = arg;
9572 
9573 	ST_FUNC(ST_DEVINFO, st_start_restart);
9574 
9575 	ASSERT(un != NULL);
9576 
9577 	mutex_enter(ST_MUTEX);
9578 
9579 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_tran_restart()\n");
9580 
9581 	st_start(un);
9582 
9583 	mutex_exit(ST_MUTEX);
9584 }
9585 
9586 
9587 /*
9588  * Command completion processing
9589  *
9590  */
9591 static void
9592 st_intr(struct scsi_pkt *pkt)
9593 {
9594 	recov_info *rcv = pkt->pkt_private;
9595 	struct buf *bp = rcv->cmd_bp;
9596 	struct scsi_tape *un;
9597 	errstate action = COMMAND_DONE;
9598 	clock_t	timout;
9599 	int	status;
9600 
9601 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
9602 
9603 	ST_FUNC(ST_DEVINFO, st_intr);
9604 
9605 	ASSERT(un != NULL);
9606 
9607 	mutex_enter(ST_MUTEX);
9608 
9609 	ASSERT(bp != un->un_recov_buf);
9610 
9611 	un->un_rqs_state &= ~(ST_RQS_ERROR);
9612 
9613 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_intr()\n");
9614 
9615 	if (pkt->pkt_reason != CMD_CMPLT) {
9616 		ST_DEBUG(ST_DEVINFO, st_label, CE_WARN,
9617 		    "Unhappy packet status reason = %s statistics = 0x%x\n",
9618 		    scsi_rname(pkt->pkt_reason), pkt->pkt_statistics);
9619 
9620 		/* If device has gone away not much else to do */
9621 		if (pkt->pkt_reason == CMD_DEV_GONE) {
9622 			action = COMMAND_DONE_ERROR;
9623 		} else if ((pkt == un->un_rqs) ||
9624 		    (un->un_state == ST_STATE_SENSING)) {
9625 			ASSERT(pkt == un->un_rqs);
9626 			ASSERT(un->un_state == ST_STATE_SENSING);
9627 			un->un_state = un->un_laststate;
9628 			rcv->cmd_bp = un->un_rqs_bp;
9629 			ST_DO_ERRSTATS(un, st_transerrs);
9630 			action = COMMAND_DONE_ERROR;
9631 		} else {
9632 			action = st_handle_incomplete(un, bp);
9633 		}
9634 	/*
9635 	 * At this point we know that the command was successfully
9636 	 * completed. Now what?
9637 	 */
9638 	} else if ((pkt == un->un_rqs) || (un->un_state == ST_STATE_SENSING)) {
9639 		/*
9640 		 * okay. We were running a REQUEST SENSE. Find
9641 		 * out what to do next.
9642 		 */
9643 		ASSERT(pkt == un->un_rqs);
9644 		ASSERT(un->un_state == ST_STATE_SENSING);
9645 		scsi_sync_pkt(pkt);
9646 		action = st_handle_sense(un, bp, &un->un_pos);
9647 		/*
9648 		 * Make rqs isn't going to be retied.
9649 		 */
9650 		if (action != QUE_BUSY_COMMAND && action != QUE_COMMAND) {
9651 			/*
9652 			 * set pkt back to original packet in case we will have
9653 			 * to requeue it
9654 			 */
9655 			pkt = BP_PKT(bp);
9656 			rcv->cmd_bp = un->un_rqs_bp;
9657 			/*
9658 			 * some actions are based on un_state, hence
9659 			 * restore the state st was in before ST_STATE_SENSING.
9660 			 */
9661 			un->un_state = un->un_laststate;
9662 		}
9663 
9664 	} else if (un->un_arq_enabled && (pkt->pkt_state & STATE_ARQ_DONE)) {
9665 		/*
9666 		 * the transport layer successfully completed an autorqsense
9667 		 */
9668 		action = st_handle_autosense(un, bp, &un->un_pos);
9669 
9670 	} else  if ((SCBP(pkt)->sts_busy) ||
9671 	    (SCBP(pkt)->sts_chk) ||
9672 	    (SCBP(pkt)->sts_vu7)) {
9673 		/*
9674 		 * Okay, we weren't running a REQUEST SENSE. Call a routine
9675 		 * to see if the status bits we're okay. If a request sense
9676 		 * is to be run, that will happen.
9677 		 */
9678 		action = st_check_error(un, pkt);
9679 	}
9680 
9681 	if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
9682 		switch (action) {
9683 			case QUE_COMMAND:
9684 				/*
9685 				 * return cmd to head to the queue
9686 				 * since we are suspending so that
9687 				 * it gets restarted during resume
9688 				 */
9689 				st_add_to_queue(&un->un_runqf, &un->un_runql,
9690 				    un->un_runqf, bp);
9691 
9692 				action = JUST_RETURN;
9693 				break;
9694 
9695 			case QUE_SENSE:
9696 				action = COMMAND_DONE_ERROR;
9697 				break;
9698 
9699 			default:
9700 				break;
9701 		}
9702 	}
9703 
9704 	/*
9705 	 * check for undetected path failover.
9706 	 */
9707 	if (un->un_multipath) {
9708 
9709 		struct uscsi_cmd *ucmd = BP_UCMD(bp);
9710 		int pkt_valid = 0;
9711 
9712 		if (ucmd) {
9713 			/*
9714 			 * Also copies path instance to the uscsi structure.
9715 			 */
9716 			pkt_valid = scsi_uscsi_pktfini(pkt, ucmd);
9717 
9718 			/*
9719 			 * scsi_uscsi_pktfini() zeros pkt_path_instance.
9720 			 */
9721 			pkt->pkt_path_instance = ucmd->uscsi_path_instance;
9722 		} else {
9723 			pkt_valid = scsi_pkt_allocated_correctly(pkt);
9724 		}
9725 
9726 		/*
9727 		 * If the scsi_pkt was not allocated correctly the
9728 		 * pkt_path_instance is not even there.
9729 		 */
9730 		if ((pkt_valid != 0) &&
9731 		    (un->un_last_path_instance != pkt->pkt_path_instance)) {
9732 			/*
9733 			 * Don't recover the path change if it was done
9734 			 * intentionally or if the device has not completely
9735 			 * opened yet.
9736 			 */
9737 			if (((pkt->pkt_flags & FLAG_PKT_PATH_INSTANCE) == 0) &&
9738 			    (un->un_state > ST_STATE_OPENING)) {
9739 				ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
9740 				    "Failover detected, action is %s\n",
9741 				    errstatenames[action]);
9742 				if (action == COMMAND_DONE) {
9743 					action = PATH_FAILED;
9744 				}
9745 			}
9746 			un->un_last_path_instance = pkt->pkt_path_instance;
9747 		}
9748 	}
9749 
9750 	/*
9751 	 * Restore old state if we were sensing.
9752 	 */
9753 	if (un->un_state == ST_STATE_SENSING && action != QUE_SENSE) {
9754 		un->un_state = un->un_laststate;
9755 	}
9756 
9757 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9758 	    "st_intr: pkt=%p, bp=%p, action=%s, status=%x\n",
9759 	    (void *)pkt, (void *)bp, errstatenames[action], SCBP_C(pkt));
9760 
9761 again:
9762 	switch (action) {
9763 	case COMMAND_DONE_EACCES:
9764 		/* this is to report a reservation conflict */
9765 		st_bioerror(bp, EACCES);
9766 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
9767 		    "Reservation Conflict \n");
9768 		un->un_pos.pmode = invalid;
9769 
9770 		/*FALLTHROUGH*/
9771 	case COMMAND_DONE_ERROR:
9772 		if (un->un_pos.eof < ST_EOT_PENDING &&
9773 		    un->un_state >= ST_STATE_OPEN) {
9774 			/*
9775 			 * all errors set state of the tape to 'unknown'
9776 			 * unless we're at EOT or are doing append testing.
9777 			 * If sense key was illegal request, preserve state.
9778 			 */
9779 			if (un->un_status != KEY_ILLEGAL_REQUEST) {
9780 				un->un_pos.pmode = invalid;
9781 			}
9782 		}
9783 
9784 		un->un_err_resid = bp->b_resid = bp->b_bcount;
9785 		/*
9786 		 * since we have an error (COMMAND_DONE_ERROR), we want to
9787 		 * make sure an error ocurrs, so make sure at least EIO is
9788 		 * returned
9789 		 */
9790 		if (geterror(bp) == 0)
9791 			st_bioerror(bp, EIO);
9792 
9793 		st_set_pe_flag(un);
9794 		if (!(un->un_rqs_state & ST_RQS_ERROR) &&
9795 		    (un->un_errno == EIO)) {
9796 			un->un_rqs_state &= ~(ST_RQS_VALID);
9797 		}
9798 		break;
9799 
9800 	case COMMAND_DONE_ERROR_RECOVERED:
9801 		un->un_err_resid = bp->b_resid = bp->b_bcount;
9802 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
9803 		    "st_intr(): COMMAND_DONE_ERROR_RECOVERED");
9804 		if (geterror(bp) == 0) {
9805 			st_bioerror(bp, EIO);
9806 		}
9807 		st_set_pe_flag(un);
9808 		if (!(un->un_rqs_state & ST_RQS_ERROR) &&
9809 		    (un->un_errno == EIO)) {
9810 			un->un_rqs_state &= ~(ST_RQS_VALID);
9811 		}
9812 		/*FALLTHROUGH*/
9813 	case COMMAND_DONE:
9814 		st_set_state(un, bp);
9815 		break;
9816 
9817 	case QUE_SENSE:
9818 		if ((un->un_ncmds > 1) && !un->un_flush_on_errors)
9819 			goto sense_error;
9820 
9821 		if (un->un_state != ST_STATE_SENSING) {
9822 			un->un_laststate = un->un_state;
9823 			un->un_state = ST_STATE_SENSING;
9824 		}
9825 
9826 		/*
9827 		 * zero the sense data.
9828 		 */
9829 		bzero(un->un_rqs->pkt_scbp, SENSE_LENGTH);
9830 
9831 		/*
9832 		 * If this is not a retry on QUE_SENSE point to the original
9833 		 * bp of the command that got us here.
9834 		 */
9835 		if (pkt != un->un_rqs) {
9836 			((recov_info *)un->un_rqs->pkt_private)->cmd_bp = bp;
9837 		}
9838 
9839 		if (un->un_throttle) {
9840 			un->un_last_throttle = un->un_throttle;
9841 			un->un_throttle = 0;
9842 		}
9843 
9844 		ST_CDB(ST_DEVINFO, "Queue sense CDB",
9845 		    (char *)BP_PKT(bp)->pkt_cdbp);
9846 
9847 		/*
9848 		 * never retry this, some other command will have nuked the
9849 		 * sense, anyway
9850 		 */
9851 		status = st_transport(un, un->un_rqs);
9852 
9853 		if (un->un_last_throttle) {
9854 			un->un_throttle = un->un_last_throttle;
9855 		}
9856 
9857 		if (status == TRAN_ACCEPT) {
9858 			mutex_exit(ST_MUTEX);
9859 			return;
9860 		}
9861 		if (status != TRAN_BUSY)
9862 			ST_DO_ERRSTATS(un, st_transerrs);
9863 sense_error:
9864 		un->un_pos.pmode = invalid;
9865 		st_bioerror(bp, EIO);
9866 		st_set_pe_flag(un);
9867 		break;
9868 
9869 	case QUE_BUSY_COMMAND:
9870 		/* longish timeout */
9871 		timout = ST_STATUS_BUSY_TIMEOUT;
9872 		goto que_it_up;
9873 
9874 	case QUE_COMMAND:
9875 		/* short timeout */
9876 		timout = ST_TRAN_BUSY_TIMEOUT;
9877 que_it_up:
9878 		/*
9879 		 * let st_handle_intr_busy put this bp back on waitq and make
9880 		 * checks to see if it is ok to requeue the command.
9881 		 */
9882 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
9883 
9884 		/*
9885 		 * Save the throttle before setting up the timeout
9886 		 */
9887 		if (un->un_throttle) {
9888 			un->un_last_throttle = un->un_throttle;
9889 		}
9890 		mutex_exit(ST_MUTEX);
9891 		if (st_handle_intr_busy(un, bp, timout) == 0)
9892 			return;		/* timeout is setup again */
9893 
9894 		mutex_enter(ST_MUTEX);
9895 		un->un_pos.pmode = invalid;
9896 		un->un_err_resid = bp->b_resid = bp->b_bcount;
9897 		st_bioerror(bp, EIO);
9898 		st_set_pe_flag(un);
9899 		break;
9900 
9901 	case QUE_LAST_COMMAND:
9902 
9903 		if ((un->un_ncmds > 1) && !un->un_flush_on_errors) {
9904 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
9905 			    "un_ncmds: %d can't retry cmd \n", un->un_ncmds);
9906 			goto last_command_error;
9907 		}
9908 		mutex_exit(ST_MUTEX);
9909 		if (st_handle_intr_retry_lcmd(un, bp) == 0)
9910 			return;
9911 		mutex_enter(ST_MUTEX);
9912 last_command_error:
9913 		un->un_err_resid = bp->b_resid = bp->b_bcount;
9914 		un->un_pos.pmode = invalid;
9915 		st_bioerror(bp, EIO);
9916 		st_set_pe_flag(un);
9917 		break;
9918 
9919 	case COMMAND_TIMEOUT:
9920 	case DEVICE_RESET:
9921 	case DEVICE_TAMPER:
9922 	case ATTEMPT_RETRY:
9923 	case PATH_FAILED:
9924 		ST_RECOV(ST_DEVINFO, st_label, CE_WARN,
9925 		    "Command Recovery called on %s status\n",
9926 		    errstatenames[action]);
9927 		action = st_command_recovery(un, pkt, action);
9928 		goto again;
9929 
9930 	default:
9931 		ASSERT(0);
9932 		/* FALLTHRU */
9933 	case JUST_RETURN:
9934 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
9935 		mutex_exit(ST_MUTEX);
9936 		return;
9937 	}
9938 
9939 	ST_DO_KSTATS(bp, kstat_runq_exit);
9940 	st_done_and_mutex_exit(un, bp);
9941 }
9942 
9943 static errstate
9944 st_handle_incomplete(struct scsi_tape *un, struct buf *bp)
9945 {
9946 	static char *fail = "SCSI transport failed: reason '%s': %s\n";
9947 	recov_info *rinfo;
9948 	errstate rval = COMMAND_DONE_ERROR;
9949 	struct scsi_pkt *pkt = (un->un_state == ST_STATE_SENSING) ?
9950 	    un->un_rqs : BP_PKT(bp);
9951 	int result;
9952 
9953 	ST_FUNC(ST_DEVINFO, st_handle_incomplete);
9954 
9955 	rinfo = (recov_info *)pkt->pkt_private;
9956 
9957 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9958 	    "st_handle_incomplete(): dev = 0x%lx\n", un->un_dev);
9959 
9960 	ASSERT(mutex_owned(ST_MUTEX));
9961 
9962 	/* prevent infinite number of retries */
9963 	if (rinfo->pkt_retry_cnt++ > st_retry_count) {
9964 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
9965 		    "Recovery stopped for incomplete %s command, "
9966 		    "retries exhausted",
9967 		    st_print_scsi_cmd(pkt->pkt_cdbp[0]));
9968 		return (COMMAND_DONE_ERROR);
9969 	}
9970 
9971 	switch (pkt->pkt_reason) {
9972 	case CMD_INCOMPLETE:	/* tran stopped with not normal state */
9973 		/*
9974 		 * this occurs when accessing a powered down drive, no
9975 		 * need to complain; just fail the open
9976 		 */
9977 		ST_CDB(ST_DEVINFO, "Incomplete CDB", (char *)pkt->pkt_cdbp);
9978 
9979 		/*
9980 		 * if we have commands outstanding in HBA, and a command
9981 		 * comes back incomplete, we're hosed, so reset target
9982 		 * If we have the bus, but cmd_incomplete, we probably just
9983 		 * have a failed selection, so don't reset the target, just
9984 		 * requeue the command and try again
9985 		 */
9986 		if ((un->un_ncmds > 1) || (pkt->pkt_state != STATE_GOT_BUS)) {
9987 			goto reset_target;
9988 		}
9989 
9990 		/*
9991 		 * Retry selection a couple more times if we're
9992 		 * open.  If opening, we only try just once to
9993 		 * reduce probe time for nonexistant devices.
9994 		 */
9995 		if ((un->un_laststate > ST_STATE_OPENING) &&
9996 		    (rinfo->pkt_retry_cnt < st_selection_retry_count)) {
9997 			/* XXX check retriable? */
9998 			rval = QUE_COMMAND;
9999 		}
10000 		ST_DO_ERRSTATS(un, st_transerrs);
10001 		break;
10002 
10003 	case CMD_ABORTED:
10004 		/*
10005 		 * most likely this is caused by flush-on-error support. If
10006 		 * it was not there, the we're in trouble.
10007 		 */
10008 		if (!un->un_flush_on_errors) {
10009 			un->un_status = SUN_KEY_FATAL;
10010 			goto reset_target;
10011 		}
10012 
10013 		st_set_pe_errno(un);
10014 		bioerror(bp, un->un_errno);
10015 		if (un->un_errno)
10016 			return (COMMAND_DONE_ERROR);
10017 		else
10018 			return (COMMAND_DONE);
10019 
10020 	case CMD_TIMEOUT:	/* Command timed out */
10021 		un->un_status = SUN_KEY_TIMEOUT;
10022 		return (COMMAND_TIMEOUT);
10023 
10024 	case CMD_TRAN_ERR:
10025 	case CMD_RESET:
10026 		if (pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET)) {
10027 			if ((un->un_rsvd_status &
10028 			    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) ==
10029 			    ST_RESERVE) {
10030 				un->un_rsvd_status |= ST_LOST_RESERVE;
10031 				ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
10032 				    "Lost Reservation\n");
10033 			}
10034 			rval = DEVICE_RESET;
10035 			return (rval);
10036 		}
10037 		if (pkt->pkt_statistics & (STAT_ABORTED | STAT_TERMINATED)) {
10038 			rval = DEVICE_RESET;
10039 			return (rval);
10040 		}
10041 		/*FALLTHROUGH*/
10042 	default:
10043 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10044 		    "Unhandled packet status reason = %s statistics = 0x%x\n",
10045 		    scsi_rname(pkt->pkt_reason), pkt->pkt_statistics);
10046 reset_target:
10047 
10048 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10049 		    "transport completed with %s\n",
10050 		    scsi_rname(pkt->pkt_reason));
10051 		ST_DO_ERRSTATS(un, st_transerrs);
10052 		if ((pkt->pkt_state & STATE_GOT_TARGET) &&
10053 		    ((pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET |
10054 		    STAT_ABORTED)) == 0)) {
10055 
10056 			/*
10057 			 * If we haven't reserved the drive don't reset it.
10058 			 */
10059 			if ((un->un_rsvd_status &
10060 			    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) {
10061 				return (rval);
10062 			}
10063 
10064 			/*
10065 			 * if we aren't lost yet we will be soon.
10066 			 */
10067 			un->un_pos.pmode = invalid;
10068 
10069 			result = st_reset(un, RESET_LUN);
10070 
10071 			if ((result == 0) && (un->un_state >= ST_STATE_OPEN)) {
10072 				/* no hope left to recover */
10073 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
10074 				    "recovery by resets failed\n");
10075 				return (rval);
10076 			}
10077 		}
10078 	}
10079 
10080 
10081 	if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
10082 		rval = QUE_COMMAND;
10083 	} else if (bp == un->un_sbufp) {
10084 		if (rinfo->privatelen == sizeof (recov_info)) {
10085 			if (rinfo->cmd_attrib->retriable) {
10086 				/*
10087 				 * These commands can be rerun
10088 				 * with impunity
10089 				 */
10090 				rval = QUE_COMMAND;
10091 			}
10092 		} else {
10093 			cmd_attribute const *attrib;
10094 			attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]);
10095 			if (attrib->retriable) {
10096 				rval = QUE_COMMAND;
10097 			}
10098 		}
10099 	}
10100 
10101 	if (un->un_state >= ST_STATE_OPEN) {
10102 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10103 		    fail, scsi_rname(pkt->pkt_reason),
10104 		    (rval == COMMAND_DONE_ERROR)?
10105 		    "giving up" : "retrying command");
10106 	}
10107 	return (rval);
10108 }
10109 
10110 /*
10111  * if the device is busy, then put this bp back on the waitq, on the
10112  * interrupt thread, where we want the head of the queue and not the
10113  * end
10114  *
10115  * The callers of this routine should take measures to save the
10116  * un_throttle in un_last_throttle which will be restored in
10117  * st_intr_restart(). The only exception should be st_intr_restart()
10118  * calling this routine for which the saving is already done.
10119  */
10120 static int
10121 st_handle_intr_busy(struct scsi_tape *un, struct buf *bp,
10122 	clock_t timeout_interval)
10123 {
10124 
10125 	int queued;
10126 	int rval = 0;
10127 	pkt_info *pktinfo = BP_PKT(bp)->pkt_private;
10128 
10129 	mutex_enter(ST_MUTEX);
10130 
10131 	ST_FUNC(ST_DEVINFO, st_handle_intr_busy);
10132 
10133 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10134 	    "st_handle_intr_busy(), un = 0x%p\n", (void *)un);
10135 
10136 	if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) {
10137 		queued = 1;
10138 	} else {
10139 		queued = 0;
10140 	}
10141 
10142 	/*
10143 	 * Check to see if we hit the retry timeout. We check to make sure
10144 	 * this is the first one on the runq and make sure we have not
10145 	 * queued up any more, so this one has to be the last on the list
10146 	 * also. If it is not, we have to fail.  If it is not the first, but
10147 	 * is the last we are in trouble anyway, as we are in the interrupt
10148 	 * context here.
10149 	 */
10150 	if ((pktinfo->str_retry_cnt++ > st_retry_count) ||
10151 	    ((un->un_runqf != bp) && (un->un_runql != bp) && (queued))) {
10152 		rval = -1;
10153 		goto exit;
10154 	}
10155 
10156 	/* put the bp back on the waitq */
10157 	if (queued) {
10158 		(void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp);
10159 		st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quef, bp);
10160 	}
10161 
10162 	/*
10163 	 * We don't want any other commands being started in the mean time.
10164 	 * If start had just released mutex after putting something on the
10165 	 * runq, we won't even get here.
10166 	 */
10167 	un->un_throttle = 0;
10168 
10169 	/*
10170 	 * send a marker pkt, if appropriate
10171 	 */
10172 	st_hba_unflush(un);
10173 
10174 	/*
10175 	 * all queues are aligned, we are just waiting to
10176 	 * transport
10177 	 */
10178 	un->un_hib_tid = timeout(st_intr_restart, un, timeout_interval);
10179 
10180 exit:
10181 	mutex_exit(ST_MUTEX);
10182 	return (rval);
10183 }
10184 
10185 /*
10186  * To get one error entry from error stack
10187  */
10188 static int
10189 st_get_error_entry(struct scsi_tape *un, intptr_t arg, int flag)
10190 {
10191 #ifdef _MULTI_DATAMODEL
10192 	/*
10193 	 * For use when a 32 bit app makes a call into a
10194 	 * 64 bit ioctl
10195 	 */
10196 	struct mterror_entry32 err_entry32;
10197 #endif /* _MULTI_DATAMODEL */
10198 
10199 	int rval = 0;
10200 	struct mterror_entry err_entry;
10201 	struct mterror_entry_stack *err_link_entry_p;
10202 	size_t arq_status_len_in, arq_status_len_kr;
10203 
10204 	ST_FUNC(ST_DEVINFO, st_get_error_entry);
10205 
10206 	ASSERT(mutex_owned(ST_MUTEX));
10207 
10208 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10209 	    "st_get_error_entry()\n");
10210 
10211 	/*
10212 	 * if error record stack empty, return ENXIO
10213 	 */
10214 	if (un->un_error_entry_stk == NULL) {
10215 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10216 		    "st_get_error_entry: Error Entry Stack Empty!\n");
10217 		rval = ENXIO;
10218 		goto ret;
10219 	}
10220 
10221 	/*
10222 	 * get the top entry from stack
10223 	 */
10224 	err_link_entry_p = un->un_error_entry_stk;
10225 	arq_status_len_kr =
10226 	    err_link_entry_p->mtees_entry.mtee_arq_status_len;
10227 
10228 #ifdef _MULTI_DATAMODEL
10229 	switch (ddi_model_convert_from(flag & FMODELS)) {
10230 	case DDI_MODEL_ILP32:
10231 		if (ddi_copyin((void *)arg, &err_entry32,
10232 		    MTERROR_ENTRY_SIZE_32, flag)) {
10233 			rval = EFAULT;
10234 			goto ret;
10235 		}
10236 
10237 		arq_status_len_in =
10238 		    (size_t)err_entry32.mtee_arq_status_len;
10239 
10240 		err_entry32.mtee_cdb_len =
10241 		    (size32_t)err_link_entry_p->mtees_entry.mtee_cdb_len;
10242 
10243 		if (arq_status_len_in > arq_status_len_kr)
10244 			err_entry32.mtee_arq_status_len =
10245 			    (size32_t)arq_status_len_kr;
10246 
10247 		if (ddi_copyout(
10248 		    err_link_entry_p->mtees_entry.mtee_cdb_buf,
10249 		    (void *)(uintptr_t)err_entry32.mtee_cdb_buf,
10250 		    err_entry32.mtee_cdb_len, flag)) {
10251 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10252 			    "st_get_error_entry: Copy cdb buffer error!");
10253 			rval = EFAULT;
10254 		}
10255 
10256 		if (ddi_copyout(
10257 		    err_link_entry_p->mtees_entry.mtee_arq_status,
10258 		    (void *)(uintptr_t)err_entry32.mtee_arq_status,
10259 		    err_entry32.mtee_arq_status_len, flag)) {
10260 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10261 			    "st_get_error_entry: copy arq status error!");
10262 			rval = EFAULT;
10263 		}
10264 
10265 		if (ddi_copyout(&err_entry32, (void *)arg,
10266 		    MTERROR_ENTRY_SIZE_32, flag)) {
10267 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10268 			    "st_get_error_entry: copy arq status out error!");
10269 			rval = EFAULT;
10270 		}
10271 		break;
10272 
10273 	case DDI_MODEL_NONE:
10274 		if (ddi_copyin((void *)arg, &err_entry,
10275 		    MTERROR_ENTRY_SIZE_64, flag)) {
10276 			rval = EFAULT;
10277 			goto ret;
10278 		}
10279 		arq_status_len_in = err_entry.mtee_arq_status_len;
10280 
10281 		err_entry.mtee_cdb_len =
10282 		    err_link_entry_p->mtees_entry.mtee_cdb_len;
10283 
10284 		if (arq_status_len_in > arq_status_len_kr)
10285 			err_entry.mtee_arq_status_len =
10286 			    arq_status_len_kr;
10287 
10288 		if (ddi_copyout(
10289 		    err_link_entry_p->mtees_entry.mtee_cdb_buf,
10290 		    err_entry.mtee_cdb_buf,
10291 		    err_entry.mtee_cdb_len, flag)) {
10292 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10293 			    "st_get_error_entry: Copy cdb buffer error!");
10294 			rval = EFAULT;
10295 		}
10296 
10297 		if (ddi_copyout(
10298 		    err_link_entry_p->mtees_entry.mtee_arq_status,
10299 		    err_entry.mtee_arq_status,
10300 		    err_entry.mtee_arq_status_len, flag)) {
10301 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10302 			    "st_get_error_entry: copy arq status error!");
10303 			rval = EFAULT;
10304 		}
10305 
10306 		if (ddi_copyout(&err_entry, (void *)arg,
10307 		    MTERROR_ENTRY_SIZE_64, flag)) {
10308 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10309 			    "st_get_error_entry: copy arq status out error!");
10310 			rval = EFAULT;
10311 		}
10312 		break;
10313 	}
10314 #else /* _MULTI_DATAMODEL */
10315 	if (ddi_copyin((void *)arg, &err_entry,
10316 	    MTERROR_ENTRY_SIZE_64, flag)) {
10317 		rval = EFAULT;
10318 		goto ret;
10319 	}
10320 	arq_status_len_in = err_entry.mtee_arq_status_len;
10321 
10322 	err_entry.mtee_cdb_len =
10323 	    err_link_entry_p->mtees_entry.mtee_cdb_len;
10324 
10325 	if (arq_status_len_in > arq_status_len_kr)
10326 		err_entry.mtee_arq_status_len =
10327 		    arq_status_len_kr;
10328 
10329 	if (ddi_copyout(
10330 	    err_link_entry_p->mtees_entry.mtee_cdb_buf,
10331 	    err_entry.mtee_cdb_buf,
10332 	    err_entry.mtee_cdb_len, flag)) {
10333 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10334 		    "st_get_error_entry: Copy cdb buffer error!");
10335 		rval = EFAULT;
10336 	}
10337 
10338 	if (ddi_copyout(
10339 	    err_link_entry_p->mtees_entry.mtee_arq_status,
10340 	    err_entry.mtee_arq_status,
10341 	    err_entry.mtee_arq_status_len, flag)) {
10342 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10343 		    "st_get_error_entry: copy arq status buffer error!");
10344 		rval = EFAULT;
10345 	}
10346 
10347 	if (ddi_copyout(&err_entry, (void *)arg,
10348 	    MTERROR_ENTRY_SIZE_64, flag)) {
10349 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10350 		    "st_get_error_entry: copy arq status out error!");
10351 		rval = EFAULT;
10352 	}
10353 #endif /* _MULTI_DATAMODEL */
10354 
10355 	/*
10356 	 * update stack
10357 	 */
10358 	un->un_error_entry_stk = err_link_entry_p->mtees_nextp;
10359 
10360 	kmem_free(err_link_entry_p->mtees_entry.mtee_cdb_buf,
10361 	    err_link_entry_p->mtees_entry.mtee_cdb_len);
10362 	err_link_entry_p->mtees_entry.mtee_cdb_buf = NULL;
10363 
10364 	kmem_free(err_link_entry_p->mtees_entry.mtee_arq_status,
10365 	    SECMDS_STATUS_SIZE);
10366 	err_link_entry_p->mtees_entry.mtee_arq_status = NULL;
10367 
10368 	kmem_free(err_link_entry_p, MTERROR_LINK_ENTRY_SIZE);
10369 	err_link_entry_p = NULL;
10370 ret:
10371 	return (rval);
10372 }
10373 
10374 /*
10375  * MTIOCGETERROR ioctl needs to retrieve the current sense data along with
10376  * the scsi CDB command which causes the error and generates sense data and
10377  * the scsi status.
10378  *
10379  *      error-record stack
10380  *
10381  *
10382  *             TOP                                     BOTTOM
10383  *              ------------------------------------------
10384  *              |   0   |   1   |   2   |   ...  |   n   |
10385  *              ------------------------------------------
10386  *                  ^
10387  *                  |
10388  *       pointer to error entry
10389  *
10390  * when st driver generates one sense data record, it creates a error-entry
10391  * and pushes it onto the stack.
10392  *
10393  */
10394 
10395 static void
10396 st_update_error_stack(struct scsi_tape *un,
10397 			struct scsi_pkt *pkt,
10398 			struct scsi_arq_status *cmd)
10399 {
10400 	struct mterror_entry_stack *err_entry_tmp;
10401 	uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp;
10402 	size_t cdblen = scsi_cdb_size[CDB_GROUPID(cdbp[0])];
10403 
10404 	ST_FUNC(ST_DEVINFO, st_update_error_stack);
10405 
10406 	ASSERT(mutex_owned(ST_MUTEX));
10407 
10408 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10409 	    "st_update_error_stack()\n");
10410 
10411 	ASSERT(cmd);
10412 	ASSERT(cdbp);
10413 	if (cdblen == 0) {
10414 		ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10415 		    "st_update_error_stack: CDB length error!\n");
10416 		return;
10417 	}
10418 
10419 	err_entry_tmp = kmem_alloc(MTERROR_LINK_ENTRY_SIZE, KM_SLEEP);
10420 	ASSERT(err_entry_tmp != NULL);
10421 
10422 	err_entry_tmp->mtees_entry.mtee_cdb_buf =
10423 	    kmem_alloc(cdblen, KM_SLEEP);
10424 	ASSERT(err_entry_tmp->mtees_entry.mtee_cdb_buf != NULL);
10425 
10426 	err_entry_tmp->mtees_entry.mtee_arq_status =
10427 	    kmem_alloc(SECMDS_STATUS_SIZE, KM_SLEEP);
10428 	ASSERT(err_entry_tmp->mtees_entry.mtee_arq_status != NULL);
10429 
10430 	/*
10431 	 * copy cdb command & length to current error entry
10432 	 */
10433 	err_entry_tmp->mtees_entry.mtee_cdb_len = cdblen;
10434 	bcopy(cdbp, err_entry_tmp->mtees_entry.mtee_cdb_buf, cdblen);
10435 
10436 	/*
10437 	 * copy scsi status length to current error entry
10438 	 */
10439 	err_entry_tmp->mtees_entry.mtee_arq_status_len =
10440 	    SECMDS_STATUS_SIZE;
10441 
10442 	/*
10443 	 * copy sense data and scsi status to current error entry
10444 	 */
10445 	bcopy(cmd, err_entry_tmp->mtees_entry.mtee_arq_status,
10446 	    SECMDS_STATUS_SIZE);
10447 
10448 	err_entry_tmp->mtees_nextp = un->un_error_entry_stk;
10449 	un->un_error_entry_stk = err_entry_tmp;
10450 
10451 }
10452 
10453 /*
10454  * Empty all the error entry in stack
10455  */
10456 static void
10457 st_empty_error_stack(struct scsi_tape *un)
10458 {
10459 	struct mterror_entry_stack *linkp;
10460 
10461 	ST_FUNC(ST_DEVINFO, st_empty_error_stack);
10462 
10463 	ASSERT(mutex_owned(ST_MUTEX));
10464 
10465 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10466 	    "st_empty_entry_stack()\n");
10467 
10468 	while (un->un_error_entry_stk != NULL) {
10469 		linkp = un->un_error_entry_stk;
10470 		un->un_error_entry_stk =
10471 		    un->un_error_entry_stk->mtees_nextp;
10472 
10473 		if (linkp->mtees_entry.mtee_cdb_buf != NULL)
10474 			kmem_free(linkp->mtees_entry.mtee_cdb_buf,
10475 			    linkp->mtees_entry.mtee_cdb_len);
10476 
10477 		if (linkp->mtees_entry.mtee_arq_status != NULL)
10478 			kmem_free(linkp->mtees_entry.mtee_arq_status,
10479 			    linkp->mtees_entry.mtee_arq_status_len);
10480 
10481 		kmem_free(linkp, MTERROR_LINK_ENTRY_SIZE);
10482 		linkp = NULL;
10483 	}
10484 }
10485 
10486 static errstate
10487 st_handle_sense(struct scsi_tape *un, struct buf *bp, tapepos_t *pos)
10488 {
10489 	struct scsi_pkt *pkt = BP_PKT(bp);
10490 	struct scsi_pkt *rqpkt = un->un_rqs;
10491 	struct scsi_arq_status arqstat;
10492 	recov_info *rcif = pkt->pkt_private;
10493 
10494 	errstate rval = COMMAND_DONE_ERROR;
10495 	int amt;
10496 
10497 	ST_FUNC(ST_DEVINFO, st_handle_sense);
10498 
10499 	ASSERT(mutex_owned(ST_MUTEX));
10500 
10501 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10502 	    "st_handle_sense()\n");
10503 
10504 	if (SCBP(rqpkt)->sts_busy) {
10505 		if (rcif->privatelen == sizeof (recov_info)) {
10506 			ST_RECOV(ST_DEVINFO, st_label, CE_WARN,
10507 			    "Attempt recovery of busy unit on request sense\n");
10508 			rval = ATTEMPT_RETRY;
10509 		} else if (rcif->pkt_retry_cnt++ < st_retry_count) {
10510 			ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN,
10511 			    "Retry busy unit on request sense\n");
10512 			rval = QUE_BUSY_COMMAND;
10513 		}
10514 		return (rval);
10515 	} else if (SCBP(rqpkt)->sts_chk) {
10516 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10517 		    "Check Condition on REQUEST SENSE\n");
10518 		return (rval);
10519 	}
10520 
10521 	/*
10522 	 * Make sure there is sense data to look at.
10523 	 */
10524 	if ((rqpkt->pkt_state & (STATE_GOT_BUS | STATE_GOT_TARGET |
10525 	    STATE_SENT_CMD | STATE_GOT_STATUS)) != (STATE_GOT_BUS |
10526 	    STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS)) {
10527 		return (rval);
10528 	}
10529 
10530 	/* was there enough data? */
10531 	amt = (int)MAX_SENSE_LENGTH - rqpkt->pkt_resid;
10532 	if ((rqpkt->pkt_state & STATE_XFERRED_DATA) == 0 ||
10533 	    (amt < SUN_MIN_SENSE_LENGTH)) {
10534 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10535 		    "REQUEST SENSE couldn't get sense data\n");
10536 		return (rval);
10537 	}
10538 
10539 	bcopy(SCBP(pkt), &arqstat.sts_status,
10540 	    sizeof (struct scsi_status));
10541 	bcopy(SCBP(rqpkt), &arqstat.sts_rqpkt_status,
10542 	    sizeof (struct scsi_status));
10543 	arqstat.sts_rqpkt_reason = rqpkt->pkt_reason;
10544 	arqstat.sts_rqpkt_resid = rqpkt->pkt_resid;
10545 	arqstat.sts_rqpkt_state = rqpkt->pkt_state;
10546 	arqstat.sts_rqpkt_statistics = rqpkt->pkt_statistics;
10547 	bcopy(ST_RQSENSE, &arqstat.sts_sensedata, SENSE_LENGTH);
10548 
10549 	/*
10550 	 * copy one arqstat entry in the sense data buffer
10551 	 */
10552 	st_update_error_stack(un, pkt, &arqstat);
10553 	return (st_decode_sense(un, bp, amt, &arqstat, pos));
10554 }
10555 
10556 static errstate
10557 st_handle_autosense(struct scsi_tape *un, struct buf *bp, tapepos_t *pos)
10558 {
10559 	struct scsi_pkt *pkt = BP_PKT(bp);
10560 	struct scsi_arq_status *arqstat =
10561 	    (struct scsi_arq_status *)pkt->pkt_scbp;
10562 	errstate rval = COMMAND_DONE_ERROR;
10563 	int amt;
10564 
10565 	ST_FUNC(ST_DEVINFO, st_handle_autosense);
10566 
10567 	ASSERT(mutex_owned(ST_MUTEX));
10568 
10569 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10570 	    "st_handle_autosense()\n");
10571 
10572 	if (arqstat->sts_rqpkt_status.sts_busy) {
10573 		ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN,
10574 		    "busy unit on request sense\n");
10575 		/*
10576 		 * we return QUE_SENSE so st_intr will setup the SENSE cmd.
10577 		 * the disadvantage is that we do not have any delay for the
10578 		 * second retry of rqsense and we have to keep a packet around
10579 		 */
10580 		return (QUE_SENSE);
10581 
10582 	} else if (arqstat->sts_rqpkt_reason != CMD_CMPLT) {
10583 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10584 		    "transport error on REQUEST SENSE\n");
10585 		if ((arqstat->sts_rqpkt_state & STATE_GOT_TARGET) &&
10586 		    ((arqstat->sts_rqpkt_statistics &
10587 		    (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) == 0)) {
10588 			if (st_reset(un, RESET_LUN) == 0) {
10589 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10590 				    "recovery by resets failed\n");
10591 			}
10592 		}
10593 		return (rval);
10594 
10595 	} else if (arqstat->sts_rqpkt_status.sts_chk) {
10596 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10597 		    "Check Condition on REQUEST SENSE\n");
10598 		return (rval);
10599 	}
10600 
10601 
10602 	/* was there enough data? */
10603 	if (pkt->pkt_state & STATE_XARQ_DONE) {
10604 		amt = (int)MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid;
10605 	} else {
10606 		if (arqstat->sts_rqpkt_resid > SENSE_LENGTH) {
10607 			amt = (int)MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid;
10608 		} else {
10609 			amt = (int)SENSE_LENGTH - arqstat->sts_rqpkt_resid;
10610 		}
10611 	}
10612 	if ((arqstat->sts_rqpkt_state & STATE_XFERRED_DATA) == 0 ||
10613 	    (amt < SUN_MIN_SENSE_LENGTH)) {
10614 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10615 		    "REQUEST SENSE couldn't get sense data\n");
10616 		return (rval);
10617 	}
10618 
10619 	if (pkt->pkt_state & STATE_XARQ_DONE) {
10620 		bcopy(&arqstat->sts_sensedata, ST_RQSENSE, MAX_SENSE_LENGTH);
10621 	} else {
10622 		bcopy(&arqstat->sts_sensedata, ST_RQSENSE, SENSE_LENGTH);
10623 	}
10624 
10625 	/*
10626 	 * copy one arqstat entry in the sense data buffer
10627 	 */
10628 	st_update_error_stack(un, pkt, arqstat);
10629 
10630 	return (st_decode_sense(un, bp, amt, arqstat, pos));
10631 }
10632 
10633 static errstate
10634 st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt,
10635     struct scsi_arq_status *statusp, tapepos_t *pos)
10636 {
10637 	struct scsi_pkt *pkt = BP_PKT(bp);
10638 	recov_info *ri = pkt->pkt_private;
10639 	errstate rval = COMMAND_DONE_ERROR;
10640 	cmd_attribute const *attrib;
10641 	long resid;
10642 	struct scsi_extended_sense *sensep = ST_RQSENSE;
10643 	int severity;
10644 	int get_error;
10645 
10646 	ST_FUNC(ST_DEVINFO, st_decode_sense);
10647 
10648 	ASSERT(mutex_owned(ST_MUTEX));
10649 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10650 	    "st_decode_sense()\n");
10651 
10652 	/*
10653 	 * For uscsi commands, squirrel away a copy of the
10654 	 * results of the Request Sense.
10655 	 */
10656 	if (USCSI_CMD(bp)) {
10657 		struct uscsi_cmd *ucmd = BP_UCMD(bp);
10658 		ucmd->uscsi_rqstatus = *(uchar_t *)statusp;
10659 		if (ucmd->uscsi_rqlen && un->un_srqbufp) {
10660 			uchar_t rqlen = min((uchar_t)amt, ucmd->uscsi_rqlen);
10661 			ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen;
10662 			bcopy(ST_RQSENSE, un->un_srqbufp, rqlen);
10663 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10664 			    "st_decode_sense: stat=0x%x resid=0x%x\n",
10665 			    ucmd->uscsi_rqstatus, ucmd->uscsi_rqresid);
10666 		}
10667 	}
10668 
10669 	if (ri->privatelen == sizeof (recov_info)) {
10670 		attrib = ri->cmd_attrib;
10671 	} else {
10672 		attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]);
10673 	}
10674 
10675 	/*
10676 	 * If the drive is an MT-02, reposition the
10677 	 * secondary error code into the proper place.
10678 	 *
10679 	 * XXX	MT-02 is non-CCS tape, so secondary error code
10680 	 * is in byte 8.  However, in SCSI-2, tape has CCS definition
10681 	 * so it's in byte 12.
10682 	 */
10683 	if (un->un_dp->type == ST_TYPE_EMULEX) {
10684 		sensep->es_code = sensep->es_add_info[0];
10685 	}
10686 
10687 	ST_CDB(ST_DEVINFO, "st_decode_sense failed CDB",
10688 	    (caddr_t)&CDBP(pkt)->scc_cmd);
10689 
10690 	ST_SENSE(ST_DEVINFO, "st_decode_sense sense data", (caddr_t)statusp,
10691 	    sizeof (*statusp));
10692 
10693 	/* for normal I/O check extract the resid values. */
10694 	if (bp != un->un_sbufp && bp != un->un_recov_buf) {
10695 		if (sensep->es_valid) {
10696 			resid =
10697 			    (sensep->es_info_1 << 24) |
10698 			    (sensep->es_info_2 << 16) |
10699 			    (sensep->es_info_3 << 8)  |
10700 			    (sensep->es_info_4);
10701 			/* If fixed block */
10702 			if (un->un_bsize) {
10703 				resid *= un->un_bsize;
10704 			}
10705 		} else if (pkt->pkt_state & STATE_XFERRED_DATA) {
10706 			resid = pkt->pkt_resid;
10707 		} else {
10708 			resid = bp->b_bcount;
10709 		}
10710 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10711 		    "st_decode_sense (rw): xferred bit = %d, resid=%ld (%d), "
10712 		    "pkt_resid=%ld\n", pkt->pkt_state & STATE_XFERRED_DATA,
10713 		    resid,
10714 		    (sensep->es_info_1 << 24) |
10715 		    (sensep->es_info_2 << 16) |
10716 		    (sensep->es_info_3 << 8)  |
10717 		    (sensep->es_info_4),
10718 		    pkt->pkt_resid);
10719 		/*
10720 		 * The problem is, what should we believe?
10721 		 */
10722 		if (resid && (pkt->pkt_resid == 0)) {
10723 			pkt->pkt_resid = resid;
10724 		}
10725 	} else {
10726 		/*
10727 		 * If the command is SCMD_SPACE, we need to get the
10728 		 * residual as returned in the sense data, to adjust
10729 		 * our idea of current tape position correctly
10730 		 */
10731 		if ((sensep->es_valid) &&
10732 		    (CDBP(pkt)->scc_cmd == SCMD_LOCATE) ||
10733 		    (CDBP(pkt)->scc_cmd == SCMD_LOCATE_G4) ||
10734 		    (CDBP(pkt)->scc_cmd == SCMD_SPACE) ||
10735 		    (CDBP(pkt)->scc_cmd == SCMD_SPACE_G4) ||
10736 		    (CDBP(pkt)->scc_cmd == SCMD_WRITE_FILE_MARK)) {
10737 			resid =
10738 			    (sensep->es_info_1 << 24) |
10739 			    (sensep->es_info_2 << 16) |
10740 			    (sensep->es_info_3 << 8)  |
10741 			    (sensep->es_info_4);
10742 			bp->b_resid = resid;
10743 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10744 			    "st_decode_sense(other):	resid=%ld\n", resid);
10745 		} else {
10746 			/*
10747 			 * If the special command is SCMD_READ,
10748 			 * the correct resid will be set later.
10749 			 */
10750 			if (attrib->get_cnt != NULL) {
10751 				resid = attrib->get_cnt(pkt->pkt_cdbp);
10752 			} else {
10753 				resid = bp->b_bcount;
10754 			}
10755 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10756 			    "st_decode_sense(special read):  resid=%ld\n",
10757 			    resid);
10758 		}
10759 	}
10760 
10761 	if ((un->un_state >= ST_STATE_OPEN) &&
10762 	    (DEBUGGING || st_error_level == SCSI_ERR_ALL)) {
10763 		st_print_cdb(ST_DEVINFO, st_label, CE_NOTE,
10764 		    "Failed CDB", (char *)pkt->pkt_cdbp);
10765 		st_clean_print(ST_DEVINFO, st_label, CE_CONT,
10766 		    "sense data", (char *)sensep, amt);
10767 		scsi_log(ST_DEVINFO, st_label, CE_CONT,
10768 		    "count 0x%lx resid 0x%lx pktresid 0x%lx\n",
10769 		    bp->b_bcount, resid, pkt->pkt_resid);
10770 	}
10771 
10772 	switch (un->un_status = sensep->es_key) {
10773 	case KEY_NO_SENSE:
10774 		severity = SCSI_ERR_INFO;
10775 
10776 		/*
10777 		 * Erase, locate or rewind operation in progress, retry
10778 		 * ASC  ASCQ
10779 		 *  00   18    Erase operation in progress
10780 		 *  00   19    Locate operation in progress
10781 		 *  00   1A    Rewind operation in progress
10782 		 */
10783 		if (sensep->es_add_code == 0 &&
10784 		    ((sensep->es_qual_code == 0x18) ||
10785 		    (sensep->es_qual_code == 0x19) ||
10786 		    (sensep->es_qual_code == 0x1a))) {
10787 			rval = QUE_BUSY_COMMAND;
10788 			break;
10789 		}
10790 
10791 		goto common;
10792 
10793 	case KEY_RECOVERABLE_ERROR:
10794 		severity = SCSI_ERR_RECOVERED;
10795 		if ((sensep->es_class == CLASS_EXTENDED_SENSE) &&
10796 		    (sensep->es_code == ST_DEFERRED_ERROR)) {
10797 			if (un->un_dp->options &
10798 			    ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) {
10799 				rval = QUE_LAST_COMMAND;
10800 				scsi_errmsg(ST_SCSI_DEVP, pkt, st_label,
10801 				    severity, pos->lgclblkno,
10802 				    un->un_err_pos.lgclblkno, scsi_cmds,
10803 				    sensep);
10804 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10805 				    "Command will be retried\n");
10806 			} else {
10807 				severity = SCSI_ERR_FATAL;
10808 				rval = COMMAND_DONE_ERROR_RECOVERED;
10809 				ST_DO_ERRSTATS(un, st_softerrs);
10810 				scsi_errmsg(ST_SCSI_DEVP, pkt, st_label,
10811 				    severity, pos->lgclblkno,
10812 				    un->un_err_pos.lgclblkno, scsi_cmds,
10813 				    sensep);
10814 			}
10815 			break;
10816 		}
10817 common:
10818 		/*
10819 		 * XXX only want reads to be stopped by filemarks.
10820 		 * Don't want them to be stopped by EOT.  EOT matters
10821 		 * only on write.
10822 		 */
10823 		if (sensep->es_filmk && !sensep->es_eom) {
10824 			rval = COMMAND_DONE;
10825 		} else if (sensep->es_eom) {
10826 			rval = COMMAND_DONE;
10827 		} else if (sensep->es_ili) {
10828 			/*
10829 			 * Fun with variable length record devices:
10830 			 * for specifying larger blocks sizes than the
10831 			 * actual physical record size.
10832 			 */
10833 			if (un->un_bsize == 0 && resid > 0) {
10834 				/*
10835 				 * XXX! Ugly.
10836 				 * The requested blocksize is > tape blocksize,
10837 				 * so this is ok, so we just return the
10838 				 * actual size xferred.
10839 				 */
10840 				pkt->pkt_resid = resid;
10841 				rval = COMMAND_DONE;
10842 			} else if (un->un_bsize == 0 && resid < 0) {
10843 				/*
10844 				 * The requested blocksize is < tape blocksize,
10845 				 * so this is not ok, so we err with ENOMEM
10846 				 */
10847 				rval = COMMAND_DONE_ERROR_RECOVERED;
10848 				st_bioerror(bp, ENOMEM);
10849 			} else {
10850 				ST_DO_ERRSTATS(un, st_softerrs);
10851 				severity = SCSI_ERR_FATAL;
10852 				rval = COMMAND_DONE_ERROR;
10853 				st_bioerror(bp, EINVAL);
10854 				un->un_running.pmode = invalid;
10855 			}
10856 		} else {
10857 			/*
10858 			 * we hope and pray for this just being
10859 			 * something we can ignore (ie. a
10860 			 * truly recoverable soft error)
10861 			 */
10862 			rval = COMMAND_DONE;
10863 		}
10864 		if (sensep->es_filmk) {
10865 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10866 			    "filemark\n");
10867 			un->un_status = SUN_KEY_EOF;
10868 			pos->eof = ST_EOF_PENDING;
10869 			st_set_pe_flag(un);
10870 		}
10871 
10872 		/*
10873 		 * ignore eom when reading, a fmk should terminate reading
10874 		 */
10875 		if ((sensep->es_eom) &&
10876 		    (CDBP(pkt)->scc_cmd != SCMD_READ)) {
10877 			if ((sensep->es_add_code == 0) &&
10878 			    (sensep->es_qual_code == 4)) {
10879 				ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10880 				    "bot\n");
10881 				un->un_status = SUN_KEY_BOT;
10882 				pos->eof = ST_NO_EOF;
10883 				pos->lgclblkno = 0;
10884 				pos->fileno = 0;
10885 				pos->blkno = 0;
10886 				if (pos->pmode != legacy)
10887 					pos->pmode = legacy;
10888 			} else {
10889 				ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10890 				    "eom\n");
10891 				un->un_status = SUN_KEY_EOT;
10892 				pos->eof = ST_EOM;
10893 			}
10894 			st_set_pe_flag(un);
10895 		}
10896 
10897 		break;
10898 
10899 	case KEY_ILLEGAL_REQUEST:
10900 
10901 		if (un->un_laststate >= ST_STATE_OPEN) {
10902 			ST_DO_ERRSTATS(un, st_softerrs);
10903 			severity = SCSI_ERR_FATAL;
10904 		} else {
10905 			severity = SCSI_ERR_INFO;
10906 		}
10907 		break;
10908 
10909 	case KEY_MEDIUM_ERROR:
10910 		ST_DO_ERRSTATS(un, st_harderrs);
10911 		severity = SCSI_ERR_FATAL;
10912 		un->un_pos.pmode = invalid;
10913 		un->un_running.pmode = invalid;
10914 check_keys:
10915 		/*
10916 		 * attempt to process the keys in the presence of
10917 		 * other errors
10918 		 */
10919 		if (sensep->es_ili && rval != COMMAND_DONE_ERROR) {
10920 			/*
10921 			 * Fun with variable length record devices:
10922 			 * for specifying larger blocks sizes than the
10923 			 * actual physical record size.
10924 			 */
10925 			if (un->un_bsize == 0 && resid > 0) {
10926 				/*
10927 				 * XXX! Ugly
10928 				 */
10929 				pkt->pkt_resid = resid;
10930 			} else if (un->un_bsize == 0 && resid < 0) {
10931 				st_bioerror(bp, EINVAL);
10932 			} else {
10933 				severity = SCSI_ERR_FATAL;
10934 				rval = COMMAND_DONE_ERROR;
10935 				st_bioerror(bp, EINVAL);
10936 			}
10937 		}
10938 		if (sensep->es_filmk) {
10939 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10940 			    "filemark\n");
10941 			un->un_status = SUN_KEY_EOF;
10942 			pos->eof = ST_EOF_PENDING;
10943 			st_set_pe_flag(un);
10944 		}
10945 
10946 		/*
10947 		 * ignore eom when reading, a fmk should terminate reading
10948 		 */
10949 		if ((sensep->es_eom) &&
10950 		    (CDBP(pkt)->scc_cmd != SCMD_READ)) {
10951 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "eom\n");
10952 			un->un_status = SUN_KEY_EOT;
10953 			pos->eof = ST_EOM;
10954 			st_set_pe_flag(un);
10955 		}
10956 
10957 		break;
10958 
10959 	case KEY_VOLUME_OVERFLOW:
10960 		ST_DO_ERRSTATS(un, st_softerrs);
10961 		pos->eof = ST_EOM;
10962 		severity = SCSI_ERR_FATAL;
10963 		rval = COMMAND_DONE_ERROR;
10964 		goto check_keys;
10965 
10966 	case KEY_HARDWARE_ERROR:
10967 		ST_DO_ERRSTATS(un, st_harderrs);
10968 		severity = SCSI_ERR_FATAL;
10969 		rval = COMMAND_DONE_ERROR;
10970 		if (un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE)
10971 			un->un_eject_tape_on_failure = st_check_asc_ascq(un);
10972 		break;
10973 
10974 	case KEY_BLANK_CHECK:
10975 		ST_DO_ERRSTATS(un, st_softerrs);
10976 		severity = SCSI_ERR_INFO;
10977 
10978 		/*
10979 		 * if not a special request and some data was xferred then it
10980 		 * it is not an error yet
10981 		 */
10982 		if (bp != un->un_sbufp && (bp->b_flags & B_READ)) {
10983 			/*
10984 			 * no error for read with or without data xferred
10985 			 */
10986 			un->un_status = SUN_KEY_EOT;
10987 			pos->eof = ST_EOT;
10988 			rval = COMMAND_DONE_ERROR;
10989 			un->un_running.pmode = invalid;
10990 			st_set_pe_flag(un);
10991 			goto check_keys;
10992 		} else if (bp != un->un_sbufp &&
10993 		    (pkt->pkt_state & STATE_XFERRED_DATA)) {
10994 			rval = COMMAND_DONE;
10995 		} else {
10996 			rval = COMMAND_DONE_ERROR_RECOVERED;
10997 		}
10998 
10999 		if (un->un_laststate >= ST_STATE_OPEN) {
11000 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
11001 			    "blank check\n");
11002 			pos->eof = ST_EOM;
11003 		}
11004 		if ((CDBP(pkt)->scc_cmd == SCMD_LOCATE) ||
11005 		    (CDBP(pkt)->scc_cmd == SCMD_LOCATE_G4) ||
11006 		    (CDBP(pkt)->scc_cmd == SCMD_SPACE) &&
11007 		    (un->un_dp->options & ST_KNOWS_EOD)) {
11008 			/*
11009 			 * we were doing a fast forward by skipping
11010 			 * multiple fmk at the time
11011 			 */
11012 			st_bioerror(bp, EIO);
11013 			severity = SCSI_ERR_RECOVERED;
11014 			rval	 = COMMAND_DONE;
11015 		}
11016 		st_set_pe_flag(un);
11017 		goto check_keys;
11018 
11019 	case KEY_WRITE_PROTECT:
11020 		if (st_wrongtapetype(un)) {
11021 			un->un_status = SUN_KEY_WRONGMEDIA;
11022 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11023 			    "wrong tape for writing- use DC6150 tape "
11024 			    "(or equivalent)\n");
11025 			severity = SCSI_ERR_UNKNOWN;
11026 		} else {
11027 			severity = SCSI_ERR_FATAL;
11028 		}
11029 		ST_DO_ERRSTATS(un, st_harderrs);
11030 		rval = COMMAND_DONE_ERROR;
11031 		st_bioerror(bp, EACCES);
11032 		break;
11033 
11034 	case KEY_UNIT_ATTENTION:
11035 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11036 		    "KEY_UNIT_ATTENTION : un_state = %d\n", un->un_state);
11037 
11038 		un->un_unit_attention_flags |= 1;
11039 		/*
11040 		 * If we have detected a Bus Reset and the tape
11041 		 * drive has been reserved.
11042 		 */
11043 		if (ST_RQSENSE->es_add_code == 0x29) {
11044 			rval = DEVICE_RESET;
11045 			if ((un->un_rsvd_status &
11046 			    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) ==
11047 			    ST_RESERVE) {
11048 				un->un_rsvd_status |= ST_LOST_RESERVE;
11049 				ST_DEBUG(ST_DEVINFO, st_label, CE_WARN,
11050 				    "st_decode_sense: Lost Reservation\n");
11051 			}
11052 		}
11053 
11054 		/*
11055 		 * If this is a recovery command and retrable, retry.
11056 		 */
11057 		if (bp == un->un_recov_buf) {
11058 			severity = SCSI_ERR_INFO;
11059 			if (attrib->retriable &&
11060 			    ri->pkt_retry_cnt++ < st_retry_count) {
11061 				rval = QUE_COMMAND;
11062 			} else {
11063 				rval = COMMAND_DONE_ERROR;
11064 			}
11065 			break; /* Don't set position invalid */
11066 		}
11067 
11068 		/*
11069 		 * If ST_APPLICATION_RESERVATIONS is set,
11070 		 * If the asc/ascq indicates that the reservation
11071 		 * has been cleared just allow the write to continue
11072 		 * which would force a scsi 2 reserve.
11073 		 * If preempted that persistent reservation
11074 		 * the scsi 2 reserve would get a reservation conflict.
11075 		 */
11076 		if ((un->un_rsvd_status &
11077 		    ST_APPLICATION_RESERVATIONS) != 0) {
11078 			/*
11079 			 * RESERVATIONS PREEMPTED
11080 			 * With MPxIO this could be a fail over? XXX
11081 			 */
11082 			if (ST_RQSENSE->es_add_code == 0x2a &&
11083 			    ST_RQSENSE->es_qual_code == 0x03) {
11084 				severity = SCSI_ERR_INFO;
11085 				rval = COMMAND_DONE_ERROR;
11086 				pos->pmode = invalid;
11087 				break;
11088 			/*
11089 			 * RESERVATIONS RELEASED
11090 			 */
11091 			} else if (ST_RQSENSE->es_add_code == 0x2a &&
11092 			    ST_RQSENSE->es_qual_code == 0x04) {
11093 				severity = SCSI_ERR_INFO;
11094 				rval = COMMAND_DONE;
11095 				break;
11096 			}
11097 		}
11098 
11099 		if (un->un_state <= ST_STATE_OPENING) {
11100 			/*
11101 			 * Look, the tape isn't open yet, now determine
11102 			 * if the cause is a BUS RESET, Save the file
11103 			 * and Block positions for the callers to
11104 			 * recover from the loss of position.
11105 			 */
11106 			severity = SCSI_ERR_INFO;
11107 			if ((pos->pmode != invalid) &&
11108 			    (rval == DEVICE_RESET) &&
11109 			    (un->un_restore_pos != 1)) {
11110 				un->un_save_fileno = pos->fileno;
11111 				un->un_save_blkno = pos->blkno;
11112 				un->un_restore_pos = 1;
11113 			}
11114 
11115 			if (attrib->retriable &&
11116 			    ri->pkt_retry_cnt++ < st_retry_count) {
11117 				rval = QUE_COMMAND;
11118 			} else if (rval == DEVICE_RESET) {
11119 				break;
11120 			} else {
11121 				rval = COMMAND_DONE_ERROR;
11122 			}
11123 		/*
11124 		 * Means it thinks the mode parameters have changed.
11125 		 * This is the result of a reset clearing settings or
11126 		 * another initiator changing what we set.
11127 		 */
11128 		}
11129 		if (ST_RQSENSE->es_add_code == 0x2a) {
11130 			if (ST_RQSENSE->es_qual_code == 0x1) {
11131 				/* Error recovery will modeselect and retry. */
11132 				rval = DEVICE_TAMPER;
11133 				severity = SCSI_ERR_INFO;
11134 				break; /* don't set position invalid */
11135 			}
11136 			if (ST_RQSENSE->es_qual_code == 0x0 ||
11137 			    ST_RQSENSE->es_qual_code == 0x2 ||
11138 			    ST_RQSENSE->es_qual_code == 0x3 ||
11139 			    ST_RQSENSE->es_qual_code == 0x4 ||
11140 			    ST_RQSENSE->es_qual_code == 0x5 ||
11141 			    ST_RQSENSE->es_qual_code == 0x6 ||
11142 			    ST_RQSENSE->es_qual_code == 0x7) {
11143 				rval = DEVICE_TAMPER;
11144 				severity = SCSI_ERR_INFO;
11145 			}
11146 		} else if (ST_RQSENSE->es_add_code == 0x28 &&
11147 		    ((ST_RQSENSE->es_qual_code == 0x0) ||
11148 		    ST_RQSENSE->es_qual_code == 0x5)) {
11149 			/*
11150 			 * Not Ready to Ready change, Media may have changed.
11151 			 */
11152 			rval = DEVICE_TAMPER;
11153 			severity = SCSI_ERR_RETRYABLE;
11154 		} else {
11155 			if (rval != DEVICE_RESET) {
11156 				rval = COMMAND_DONE_ERROR;
11157 			} else {
11158 				/*
11159 				 * Returning DEVICE_RESET will call
11160 				 * error recovery.
11161 				 */
11162 				severity = SCSI_ERR_INFO;
11163 				break; /* don't set position invalid */
11164 			}
11165 			/*
11166 			 * Check if it is an Unexpected Unit Attention.
11167 			 * If state is >= ST_STATE_OPEN, we have
11168 			 * already done the initialization .
11169 			 * In this case it is Fatal Error
11170 			 * since no further reading/writing
11171 			 * can be done with fileno set to < 0.
11172 			 */
11173 			if (un->un_state >= ST_STATE_OPEN) {
11174 				ST_DO_ERRSTATS(un, st_harderrs);
11175 				severity = SCSI_ERR_FATAL;
11176 			} else {
11177 				severity = SCSI_ERR_INFO;
11178 			}
11179 		}
11180 
11181 		pos->pmode = invalid;
11182 
11183 		break;
11184 
11185 	case KEY_NOT_READY:
11186 		/*
11187 		 * If in process of getting ready retry.
11188 		 */
11189 		if (sensep->es_add_code == 0x04) {
11190 			switch (sensep->es_qual_code) {
11191 			case 0x07:
11192 				/*
11193 				 * We get here when the tape is rewinding.
11194 				 * QUE_BUSY_COMMAND retries every 10 seconds.
11195 				 */
11196 				if (ri->pkt_retry_cnt++ <
11197 				    (un->un_dp->rewind_timeout / 10)) {
11198 					rval = QUE_BUSY_COMMAND;
11199 					severity = SCSI_ERR_INFO;
11200 				} else {
11201 					/* give up */
11202 					rval = COMMAND_DONE_ERROR;
11203 					severity = SCSI_ERR_FATAL;
11204 				}
11205 				break;
11206 			case 0x01:
11207 				if (ri->pkt_retry_cnt++ < st_retry_count) {
11208 					rval = QUE_COMMAND;
11209 					severity = SCSI_ERR_INFO;
11210 					break;
11211 				}
11212 			default: /* FALLTHRU */
11213 				/* give up */
11214 				rval = COMMAND_DONE_ERROR;
11215 				severity = SCSI_ERR_FATAL;
11216 			}
11217 		} else {
11218 			/* give up */
11219 			rval = COMMAND_DONE_ERROR;
11220 			severity = SCSI_ERR_FATAL;
11221 		}
11222 
11223 		/*
11224 		 * If this was an error and after device opened
11225 		 * do error stats.
11226 		 */
11227 		if (rval == COMMAND_DONE_ERROR &&
11228 		    un->un_state > ST_STATE_OPENING) {
11229 			ST_DO_ERRSTATS(un, st_harderrs);
11230 		}
11231 
11232 		if (ST_RQSENSE->es_add_code == 0x3a) {
11233 			if (st_error_level >= SCSI_ERR_FATAL)
11234 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
11235 				    "Tape not inserted in drive\n");
11236 			un->un_mediastate = MTIO_EJECTED;
11237 			cv_broadcast(&un->un_state_cv);
11238 		}
11239 		if ((un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) &&
11240 		    (rval != QUE_COMMAND))
11241 			un->un_eject_tape_on_failure = st_check_asc_ascq(un);
11242 		break;
11243 
11244 	case KEY_ABORTED_COMMAND:
11245 		/* XXX Do drives return this when they see a lost light? */
11246 		/* Testing would say yes */
11247 
11248 		if (ri->pkt_retry_cnt++ < st_retry_count) {
11249 			rval = ATTEMPT_RETRY;
11250 			severity = SCSI_ERR_RETRYABLE;
11251 			goto check_keys;
11252 		}
11253 		/*
11254 		 * Probably a parity error...
11255 		 * if we retry here then this may cause data to be
11256 		 * written twice or data skipped during reading
11257 		 */
11258 		ST_DO_ERRSTATS(un, st_harderrs);
11259 		severity = SCSI_ERR_FATAL;
11260 		rval = COMMAND_DONE_ERROR;
11261 		goto check_keys;
11262 
11263 	default:
11264 		/*
11265 		 * Undecoded sense key.	 Try retries and hope
11266 		 * that will fix the problem.  Otherwise, we're
11267 		 * dead.
11268 		 */
11269 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11270 		    "Unhandled Sense Key '%s'\n",
11271 		    sense_keys[un->un_status]);
11272 		ST_DO_ERRSTATS(un, st_harderrs);
11273 		severity = SCSI_ERR_FATAL;
11274 		rval = COMMAND_DONE_ERROR;
11275 		goto check_keys;
11276 	}
11277 
11278 	if ((!(pkt->pkt_flags & FLAG_SILENT) &&
11279 	    un->un_state >= ST_STATE_OPEN) && (DEBUGGING ||
11280 	    (un->un_laststate > ST_STATE_OPENING) &&
11281 	    (severity >= st_error_level))) {
11282 
11283 		scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity,
11284 		    pos->lgclblkno, un->un_err_pos.lgclblkno,
11285 		    scsi_cmds, sensep);
11286 		if (sensep->es_filmk) {
11287 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
11288 			    "File Mark Detected\n");
11289 		}
11290 		if (sensep->es_eom) {
11291 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
11292 			    "End-of-Media Detected\n");
11293 		}
11294 		if (sensep->es_ili) {
11295 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
11296 			    "Incorrect Length Indicator Set\n");
11297 		}
11298 	}
11299 	get_error = geterror(bp);
11300 	if (((rval == COMMAND_DONE_ERROR) ||
11301 	    (rval == COMMAND_DONE_ERROR_RECOVERED)) &&
11302 	    ((get_error == EIO) || (get_error == 0))) {
11303 		un->un_rqs_state |= (ST_RQS_ERROR | ST_RQS_VALID);
11304 		bcopy(ST_RQSENSE, un->un_uscsi_rqs_buf, SENSE_LENGTH);
11305 		if (un->un_rqs_state & ST_RQS_READ) {
11306 			un->un_rqs_state &= ~(ST_RQS_READ);
11307 		} else {
11308 			un->un_rqs_state |= ST_RQS_OVR;
11309 		}
11310 	}
11311 
11312 	return (rval);
11313 }
11314 
11315 
11316 static int
11317 st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp)
11318 {
11319 	int status = TRAN_ACCEPT;
11320 	pkt_info *pktinfo = BP_PKT(bp)->pkt_private;
11321 
11322 	mutex_enter(ST_MUTEX);
11323 
11324 	ST_FUNC(ST_DEVINFO, st_handle_intr_retry_lcmd);
11325 
11326 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
11327 	    "st_handle_intr_rtr_lcmd(), un = 0x%p\n", (void *)un);
11328 
11329 	/*
11330 	 * Check to see if we hit the retry timeout. We check to make sure
11331 	 * this is the first one on the runq and make sure we have not
11332 	 * queued up any more, so this one has to be the last on the list
11333 	 * also. If it is not, we have to fail.  If it is not the first, but
11334 	 * is the last we are in trouble anyway, as we are in the interrupt
11335 	 * context here.
11336 	 */
11337 	if ((pktinfo->pkt_retry_cnt > st_retry_count) ||
11338 	    ((un->un_runqf != bp) && (un->un_runql != bp))) {
11339 		goto exit;
11340 	}
11341 
11342 	if (un->un_throttle) {
11343 		un->un_last_throttle = un->un_throttle;
11344 		un->un_throttle = 0;
11345 	}
11346 
11347 	/*
11348 	 * Here we know : bp is the first and last one on the runq
11349 	 * it is not necessary to put it back on the head of the
11350 	 * waitq and then move from waitq to runq. Save this queuing
11351 	 * and call scsi_transport.
11352 	 */
11353 	ST_CDB(ST_DEVINFO, "Retry lcmd CDB", (char *)BP_PKT(bp)->pkt_cdbp);
11354 
11355 	status = st_transport(un, BP_PKT(bp));
11356 
11357 	if (status == TRAN_ACCEPT) {
11358 		if (un->un_last_throttle) {
11359 			un->un_throttle = un->un_last_throttle;
11360 		}
11361 		mutex_exit(ST_MUTEX);
11362 
11363 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11364 		    "restart transport \n");
11365 		return (0);
11366 	}
11367 
11368 	ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
11369 	mutex_exit(ST_MUTEX);
11370 
11371 	if (status == TRAN_BUSY) {
11372 		if (st_handle_intr_busy(un, bp, ST_TRAN_BUSY_TIMEOUT) == 0) {
11373 			return (0);
11374 		}
11375 	}
11376 	ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11377 	    "restart transport rejected\n");
11378 	mutex_enter(ST_MUTEX);
11379 	ST_DO_ERRSTATS(un, st_transerrs);
11380 	if (un->un_last_throttle) {
11381 		un->un_throttle = un->un_last_throttle;
11382 	}
11383 exit:
11384 	mutex_exit(ST_MUTEX);
11385 	return (-1);
11386 }
11387 
11388 static int
11389 st_wrongtapetype(struct scsi_tape *un)
11390 {
11391 
11392 	ST_FUNC(ST_DEVINFO, st_wrongtapetype);
11393 
11394 	ASSERT(mutex_owned(ST_MUTEX));
11395 
11396 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_wrongtapetype()\n");
11397 
11398 	/*
11399 	 * Hack to handle  600A, 600XTD, 6150 && 660 vs. 300XL tapes...
11400 	 */
11401 	if (un->un_dp && (un->un_dp->options & ST_QIC) && un->un_mspl) {
11402 		switch (un->un_dp->type) {
11403 		case ST_TYPE_WANGTEK:
11404 		case ST_TYPE_ARCHIVE:
11405 			/*
11406 			 * If this really worked, we could go off of
11407 			 * the density codes set in the modesense
11408 			 * page. For this drive, 0x10 == QIC-120,
11409 			 * 0xf == QIC-150, and 0x5 should be for
11410 			 * both QIC-24 and, maybe, QIC-11. However,
11411 			 * the h/w doesn't do what the manual says
11412 			 * that it should, so we'll key off of
11413 			 * getting a WRITE PROTECT error AND wp *not*
11414 			 * set in the mode sense information.
11415 			 */
11416 			/*
11417 			 * XXX but we already know that status is
11418 			 * write protect, so don't check it again.
11419 			 */
11420 
11421 			if (un->un_status == KEY_WRITE_PROTECT &&
11422 			    un->un_mspl->wp == 0) {
11423 				return (1);
11424 			}
11425 			break;
11426 		default:
11427 			break;
11428 		}
11429 	}
11430 	return (0);
11431 }
11432 
11433 static errstate
11434 st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt)
11435 {
11436 	errstate action;
11437 	recov_info *rcvi = pkt->pkt_private;
11438 	buf_t *bp = rcvi->cmd_bp;
11439 	struct scsi_arq_status *stat = (struct scsi_arq_status *)pkt->pkt_scbp;
11440 
11441 	ST_FUNC(ST_DEVINFO, st_check_error);
11442 
11443 	ASSERT(mutex_owned(ST_MUTEX));
11444 
11445 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_error()\n");
11446 
11447 	switch (SCBP_C(pkt)) {
11448 	case STATUS_RESERVATION_CONFLICT:
11449 		/*
11450 		 * Command recovery is enabled, not just opening,
11451 		 * we had the drive reserved and we thing its ours.
11452 		 * Call recovery to attempt to take it back.
11453 		 */
11454 		if ((rcvi->privatelen == sizeof (recov_info)) &&
11455 		    (bp != un->un_recov_buf) &&
11456 		    (un->un_state > ST_STATE_OPEN_PENDING_IO) &&
11457 		    ((un->un_rsvd_status & (ST_RESERVE |
11458 		    ST_APPLICATION_RESERVATIONS)) != 0)) {
11459 			action = ATTEMPT_RETRY;
11460 			un->un_rsvd_status |= ST_LOST_RESERVE;
11461 		} else {
11462 			action = COMMAND_DONE_EACCES;
11463 			un->un_rsvd_status |= ST_RESERVATION_CONFLICT;
11464 		}
11465 		break;
11466 
11467 	case STATUS_BUSY:
11468 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, "unit busy\n");
11469 		if (rcvi->privatelen == sizeof (recov_info) &&
11470 		    un->un_multipath && (pkt->pkt_state == (STATE_GOT_BUS |
11471 		    STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS))) {
11472 			/*
11473 			 * Status returned by scsi_vhci indicating path
11474 			 * has failed over.
11475 			 */
11476 			action = PATH_FAILED;
11477 			break;
11478 		}
11479 		/* FALLTHRU */
11480 	case STATUS_QFULL:
11481 		if (rcvi->privatelen == sizeof (recov_info)) {
11482 			/*
11483 			 * If recovery is inabled use it instead of
11484 			 * blind reties.
11485 			 */
11486 			action = ATTEMPT_RETRY;
11487 		} else if (rcvi->pkt_retry_cnt++ < st_retry_count) {
11488 			action = QUE_BUSY_COMMAND;
11489 		} else if ((un->un_rsvd_status &
11490 		    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) {
11491 			/*
11492 			 * If this is a command done before reserve is done
11493 			 * don't reset.
11494 			 */
11495 			action = COMMAND_DONE_ERROR;
11496 		} else {
11497 			ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
11498 			    "unit busy too long\n");
11499 			(void) st_reset(un, RESET_ALL);
11500 			action = COMMAND_DONE_ERROR;
11501 		}
11502 		break;
11503 
11504 	case STATUS_CHECK:
11505 	case STATUS_TERMINATED:
11506 		/*
11507 		 * we should only get here if the auto rqsense failed
11508 		 * thru a uscsi cmd without autorequest sense
11509 		 * so we just try again
11510 		 */
11511 		if (un->un_arq_enabled &&
11512 		    stat->sts_rqpkt_reason == CMD_CMPLT &&
11513 		    (stat->sts_rqpkt_state & (STATE_GOT_BUS |
11514 		    STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS)) ==
11515 		    (STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD |
11516 		    STATE_GOT_STATUS)) {
11517 
11518 			ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
11519 			    "Really got sense data\n");
11520 			action = st_decode_sense(un, bp, MAX_SENSE_LENGTH -
11521 			    pkt->pkt_resid, stat, &un->un_pos);
11522 		} else {
11523 			ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
11524 			    "Trying to queue sense command\n");
11525 			action = QUE_SENSE;
11526 		}
11527 		break;
11528 
11529 	case STATUS_TASK_ABORT:
11530 		/*
11531 		 * This is an aborted task. This can be a reset on the other
11532 		 * port of a multiport drive. Lets try and recover it.
11533 		 */
11534 		action = DEVICE_RESET;
11535 		break;
11536 
11537 	default:
11538 		action = COMMAND_DONE;
11539 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
11540 		    "Unexpected scsi status byte 0x%x\n", SCBP_C(pkt));
11541 	}
11542 	return (action);
11543 }
11544 
11545 static void
11546 st_calc_bnum(struct scsi_tape *un, struct buf *bp, struct scsi_pkt *pkt)
11547 {
11548 	int nblks;
11549 	int nfiles;
11550 	long count;
11551 	recov_info *ri = pkt->pkt_private;
11552 	cmd_attribute const *attrib;
11553 
11554 	ST_FUNC(ST_DEVINFO, st_calc_bnum);
11555 
11556 	ASSERT(mutex_owned(ST_MUTEX));
11557 
11558 	if (ri->privatelen == sizeof (recov_info)) {
11559 		attrib = ri->cmd_attrib;
11560 		ASSERT(attrib->recov_pos_type == POS_EXPECTED);
11561 		ASSERT(attrib->chg_tape_pos);
11562 	} else {
11563 		ri = NULL;
11564 		attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]);
11565 	}
11566 
11567 	count = bp->b_bcount - bp->b_resid;
11568 
11569 	/* Command reads or writes data */
11570 	if (attrib->transfers_data != TRAN_NONE) {
11571 		if (count == 0) {
11572 			if (attrib->transfers_data == TRAN_WRTE) {
11573 				ASSERT(un->un_pos.eof == ST_EOM);
11574 				nblks = 0;
11575 				nfiles = 0;
11576 			} else {
11577 				ASSERT(un->un_pos.eof == ST_EOF_PENDING);
11578 				nblks = 0;
11579 				nfiles = 1;
11580 			}
11581 		} else if (un->un_bsize == 0) {
11582 			/*
11583 			 * If variable block mode.
11584 			 * Fixed bit in CBD should be zero.
11585 			 */
11586 			ASSERT((pkt->pkt_cdbp[1] & 1) == 0);
11587 			nblks = 1;
11588 			un->un_kbytes_xferred += (count / ONE_K);
11589 			nfiles = 0;
11590 		} else {
11591 			/*
11592 			 * If fixed block mode.
11593 			 * Fixed bit in CBD should be one.
11594 			 */
11595 			ASSERT((pkt->pkt_cdbp[1] & 1) == 1);
11596 			nblks = (count / un->un_bsize);
11597 			un->un_kbytes_xferred += (nblks * un->un_bsize) / ONE_K;
11598 			nfiles = 0;
11599 		}
11600 		/*
11601 		 * So its possable to read some blocks and hit a filemark.
11602 		 * Example reading in fixed block mode where more then one
11603 		 * block at a time is requested. In this case because the
11604 		 * filemark is hit something less then the requesed number
11605 		 * of blocks is read.
11606 		 */
11607 		if (un->un_pos.eof == ST_EOF_PENDING && bp->b_resid) {
11608 			nfiles = 1;
11609 		}
11610 	} else {
11611 		nblks = 0;
11612 		nfiles = count;
11613 	}
11614 
11615 	/*
11616 	 * If some command failed after this one started and it seems
11617 	 * to have finshed without error count the position.
11618 	 */
11619 	if (un->un_persistence && un->un_persist_errors) {
11620 		ASSERT(un->un_pos.pmode != invalid);
11621 	}
11622 
11623 	if (attrib->chg_tape_direction == DIR_FORW) {
11624 		un->un_pos.blkno += nblks;
11625 		un->un_pos.lgclblkno += nblks;
11626 		un->un_pos.lgclblkno += nfiles;
11627 	} else if (attrib->chg_tape_direction == DIR_REVC) {
11628 		un->un_pos.blkno -= nblks;
11629 		un->un_pos.lgclblkno -= nblks;
11630 		un->un_pos.lgclblkno -= nfiles;
11631 	} else {
11632 		ASSERT(0);
11633 	}
11634 
11635 	/* recovery disabled */
11636 	if (ri == NULL) {
11637 		un->un_running.pmode = invalid;
11638 		return;
11639 	}
11640 
11641 	/*
11642 	 * If we didn't just read a filemark.
11643 	 */
11644 	if (un->un_pos.eof != ST_EOF_PENDING) {
11645 		ASSERT(nblks != 0 && nfiles == 0);
11646 		/*
11647 		 * If Previously calulated expected position does not match
11648 		 * debug the expected position.
11649 		 */
11650 		if ((ri->pos.pmode != invalid) && nblks &&
11651 		    ((un->un_pos.blkno != ri->pos.blkno) ||
11652 		    (un->un_pos.lgclblkno != ri->pos.lgclblkno))) {
11653 #ifdef STDEBUG
11654 			st_print_position(ST_DEVINFO, st_label, CE_NOTE,
11655 			    "Expected", &ri->pos);
11656 			st_print_position(ST_DEVINFO, st_label, CE_NOTE,
11657 			    "But Got", &un->un_pos);
11658 #endif
11659 			un->un_running.pmode = invalid;
11660 		}
11661 	} else {
11662 		ASSERT(nfiles != 0);
11663 		if (un->un_running.pmode != invalid) {
11664 			/*
11665 			 * blkno and lgclblkno already counted in
11666 			 * st_add_recovery_info_to_pkt(). Since a block was not
11667 			 * read and a filemark was.
11668 			 */
11669 			if (attrib->chg_tape_direction == DIR_FORW) {
11670 				un->un_running.fileno++;
11671 				un->un_running.blkno = 0;
11672 			} else if (attrib->chg_tape_direction == DIR_REVC) {
11673 				un->un_running.fileno--;
11674 				un->un_running.blkno = LASTBLK;
11675 			}
11676 		}
11677 	}
11678 }
11679 
11680 static void
11681 st_set_state(struct scsi_tape *un, struct buf *bp)
11682 {
11683 	struct scsi_pkt *sp = BP_PKT(bp);
11684 	struct uscsi_cmd *ucmd;
11685 
11686 	ST_FUNC(ST_DEVINFO, st_set_state);
11687 
11688 	ASSERT(mutex_owned(ST_MUTEX));
11689 	ASSERT(bp != un->un_recov_buf);
11690 
11691 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
11692 	    "st_set_state(): eof=%x	fmneeded=%x  pkt_resid=0x%lx (%ld)\n",
11693 	    un->un_pos.eof, un->un_fmneeded, sp->pkt_resid, sp->pkt_resid);
11694 
11695 	if (bp != un->un_sbufp) {
11696 #ifdef STDEBUG
11697 		if (DEBUGGING && sp->pkt_resid) {
11698 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
11699 			    "pkt_resid %ld bcount %ld\n",
11700 			    sp->pkt_resid, bp->b_bcount);
11701 		}
11702 #endif
11703 		bp->b_resid = sp->pkt_resid;
11704 		if (geterror(bp) != EIO) {
11705 			st_calc_bnum(un, bp, sp);
11706 		}
11707 		if (bp->b_flags & B_READ) {
11708 			un->un_lastop = ST_OP_READ;
11709 			un->un_fmneeded = 0;
11710 		} else {
11711 			un->un_lastop = ST_OP_WRITE;
11712 			if (un->un_dp->options & ST_REEL) {
11713 				un->un_fmneeded = 2;
11714 			} else {
11715 				un->un_fmneeded = 1;
11716 			}
11717 		}
11718 		/*
11719 		 * all is honky dory at this point, so let's
11720 		 * readjust the throttle, to increase speed, if we
11721 		 * have not throttled down.
11722 		 */
11723 		if (un->un_throttle) {
11724 			un->un_throttle = un->un_max_throttle;
11725 		}
11726 	} else {
11727 		optype new_lastop = ST_OP_NIL;
11728 		uchar_t cmd = (uchar_t)(intptr_t)bp->b_forw;
11729 
11730 		switch (cmd) {
11731 		case SCMD_WRITE:
11732 		case SCMD_WRITE_G4:
11733 			bp->b_resid = sp->pkt_resid;
11734 			new_lastop = ST_OP_WRITE;
11735 			if (geterror(bp) == EIO) {
11736 				break;
11737 			}
11738 			st_calc_bnum(un, bp, sp);
11739 			if (un->un_dp->options & ST_REEL) {
11740 				un->un_fmneeded = 2;
11741 			} else {
11742 				un->un_fmneeded = 1;
11743 			}
11744 			break;
11745 		case SCMD_READ:
11746 		case SCMD_READ_G4:
11747 			bp->b_resid = sp->pkt_resid;
11748 			new_lastop = ST_OP_READ;
11749 			un->un_lastop = ST_OP_READ;
11750 			if (geterror(bp) == EIO) {
11751 				break;
11752 			}
11753 			st_calc_bnum(un, bp, sp);
11754 			un->un_fmneeded = 0;
11755 			break;
11756 		case SCMD_WRITE_FILE_MARK_G4:
11757 		case SCMD_WRITE_FILE_MARK:
11758 		{
11759 			int fmdone;
11760 
11761 			if (un->un_pos.eof != ST_EOM) {
11762 				un->un_pos.eof = ST_NO_EOF;
11763 			}
11764 			fmdone = (bp->b_bcount - bp->b_resid);
11765 			if (fmdone > 0) {
11766 				un->un_lastop = new_lastop = ST_OP_WEOF;
11767 				un->un_pos.lgclblkno += fmdone;
11768 				un->un_pos.fileno += fmdone;
11769 				un->un_pos.blkno = 0;
11770 			} else {
11771 				new_lastop = ST_OP_CTL;
11772 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11773 				    "Flushed buffer\n");
11774 			}
11775 			if (fmdone > un->un_fmneeded) {
11776 				un->un_fmneeded = 0;
11777 			} else {
11778 				un->un_fmneeded -= fmdone;
11779 			}
11780 			break;
11781 		}
11782 		case SCMD_REWIND:
11783 			un->un_pos.eof = ST_NO_EOF;
11784 			un->un_pos.fileno = 0;
11785 			un->un_pos.blkno = 0;
11786 			un->un_pos.lgclblkno = 0;
11787 			if (un->un_pos.pmode != legacy)
11788 				un->un_pos.pmode = legacy;
11789 			new_lastop = ST_OP_CTL;
11790 			un->un_restore_pos = 0;
11791 			break;
11792 
11793 		case SCMD_SPACE:
11794 		case SCMD_SPACE_G4:
11795 		{
11796 			int64_t count;
11797 			int64_t resid;
11798 			int64_t done;
11799 			cmd_attribute const *attrib;
11800 			recov_info *ri = sp->pkt_private;
11801 
11802 			if (ri->privatelen == sizeof (recov_info)) {
11803 				attrib = ri->cmd_attrib;
11804 			} else {
11805 				attrib =
11806 				    st_lookup_cmd_attribute(sp->pkt_cdbp[0]);
11807 			}
11808 
11809 			resid = (int64_t)SPACE_CNT(bp->b_resid);
11810 			count = (int64_t)attrib->get_cnt(sp->pkt_cdbp);
11811 
11812 			if (count >= 0) {
11813 				done = (count - resid);
11814 			} else {
11815 				done = ((-count) - resid);
11816 			}
11817 			if (done > 0) {
11818 				un->un_lastop = new_lastop = ST_OP_CTL;
11819 			} else {
11820 				new_lastop = ST_OP_CTL;
11821 			}
11822 
11823 			ST_SPAC(ST_DEVINFO, st_label, CE_WARN,
11824 			    "space cmd: cdb[1] = %s\n"
11825 			    "space data:       = 0x%lx\n"
11826 			    "space count:      = %"PRId64"\n"
11827 			    "space resid:      = %"PRId64"\n"
11828 			    "spaces done:      = %"PRId64"\n"
11829 			    "fileno before     = %d\n"
11830 			    "blkno before      = %d\n",
11831 			    space_strs[sp->pkt_cdbp[1] & 7],
11832 			    bp->b_bcount,
11833 			    count, resid, done,
11834 			    un->un_pos.fileno, un->un_pos.blkno);
11835 
11836 			switch (sp->pkt_cdbp[1]) {
11837 			case SPACE_TYPE(SP_FLM):
11838 				/* Space file forward */
11839 				if (count >= 0) {
11840 					if (un->un_pos.eof <= ST_EOF) {
11841 						un->un_pos.eof = ST_NO_EOF;
11842 					}
11843 					un->un_pos.fileno += done;
11844 					un->un_pos.blkno = 0;
11845 					break;
11846 				}
11847 				/* Space file backward */
11848 				if (done > un->un_pos.fileno) {
11849 					un->un_pos.fileno = 0;
11850 					un->un_pos.blkno = 0;
11851 				} else {
11852 					un->un_pos.fileno -= done;
11853 					un->un_pos.blkno = LASTBLK;
11854 					un->un_running.pmode = invalid;
11855 				}
11856 				break;
11857 			case SPACE_TYPE(SP_BLK):
11858 				/* Space block forward */
11859 				if (count >= 0) {
11860 					un->un_pos.blkno += done;
11861 					break;
11862 				}
11863 				/* Space block backward */
11864 				if (un->un_pos.eof >= ST_EOF_PENDING) {
11865 				/*
11866 				 * we stepped back into
11867 				 * a previous file; we are not
11868 				 * making an effort to pretend that
11869 				 * we are still in the current file
11870 				 * ie. logical == physical position
11871 				 * and leave it to st_ioctl to correct
11872 				 */
11873 					if (done > un->un_pos.blkno) {
11874 						un->un_pos.blkno = 0;
11875 					} else {
11876 						un->un_pos.fileno--;
11877 						un->un_pos.blkno = LASTBLK;
11878 						un->un_running.pmode = invalid;
11879 					}
11880 				} else {
11881 					un->un_pos.blkno -= done;
11882 				}
11883 				break;
11884 			case SPACE_TYPE(SP_SQFLM):
11885 				un->un_pos.pmode = logical;
11886 				un->un_pos.blkno = 0;
11887 				un->un_lastop = new_lastop = ST_OP_CTL;
11888 				break;
11889 			case SPACE_TYPE(SP_EOD):
11890 				un->un_pos.pmode = logical;
11891 				un->un_pos.eof = ST_EOM;
11892 				un->un_status = KEY_BLANK_CHECK;
11893 				break;
11894 			default:
11895 				un->un_pos.pmode = invalid;
11896 				scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
11897 				    "Unsupported space cmd: %s\n",
11898 				    space_strs[sp->pkt_cdbp[1] & 7]);
11899 
11900 				un->un_lastop = new_lastop = ST_OP_CTL;
11901 			}
11902 
11903 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
11904 			    "after_space rs %"PRId64" fil %d blk %d\n",
11905 			    resid, un->un_pos.fileno, un->un_pos.blkno);
11906 
11907 			break;
11908 		}
11909 		case SCMD_LOAD:
11910 			if ((bp->b_bcount & (LD_LOAD | LD_EOT)) == LD_LOAD) {
11911 				un->un_pos.fileno = 0;
11912 				if (un->un_pos.pmode != legacy)
11913 					un->un_pos.pmode = legacy;
11914 			} else {
11915 				un->un_state = ST_STATE_OFFLINE;
11916 				un->un_pos.pmode = invalid;
11917 
11918 			}
11919 			/*
11920 			 * If we are loading or unloading we expect the media id
11921 			 * to change. Lets make it unknown.
11922 			 */
11923 			if (un->un_media_id != bogusID && un->un_media_id_len) {
11924 				kmem_free(un->un_media_id, un->un_media_id_len);
11925 				un->un_media_id = NULL;
11926 				un->un_media_id_len = 0;
11927 			}
11928 			un->un_density_known = 0;
11929 			un->un_pos.eof = ST_NO_EOF;
11930 			un->un_pos.blkno = 0;
11931 			un->un_lastop = new_lastop = ST_OP_CTL;
11932 			break;
11933 		case SCMD_ERASE:
11934 			un->un_pos.eof = ST_NO_EOF;
11935 			un->un_pos.blkno = 0;
11936 			un->un_pos.fileno = 0;
11937 			un->un_pos.lgclblkno = 0;
11938 			if (un->un_pos.pmode != legacy)
11939 				un->un_pos.pmode = legacy;
11940 			new_lastop = ST_OP_CTL;
11941 			break;
11942 		case SCMD_RESERVE:
11943 			un->un_rsvd_status |= ST_RESERVE;
11944 			un->un_rsvd_status &=
11945 			    ~(ST_RELEASE | ST_LOST_RESERVE |
11946 			    ST_RESERVATION_CONFLICT | ST_INITIATED_RESET);
11947 			new_lastop = ST_OP_CTL;
11948 			break;
11949 		case SCMD_RELEASE:
11950 			un->un_rsvd_status |= ST_RELEASE;
11951 			un->un_rsvd_status &=
11952 			    ~(ST_RESERVE | ST_LOST_RESERVE |
11953 			    ST_RESERVATION_CONFLICT | ST_INITIATED_RESET);
11954 			new_lastop = ST_OP_CTL;
11955 			break;
11956 		case SCMD_PERSISTENT_RESERVE_IN:
11957 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11958 			    "PGR_IN command\n");
11959 			new_lastop = ST_OP_CTL;
11960 			break;
11961 		case SCMD_PERSISTENT_RESERVE_OUT:
11962 			switch (sp->pkt_cdbp[1] & ST_SA_MASK) {
11963 			case ST_SA_SCSI3_RESERVE:
11964 			case ST_SA_SCSI3_PREEMPT:
11965 			case ST_SA_SCSI3_PREEMPTANDABORT:
11966 				un->un_rsvd_status |=
11967 				    (ST_APPLICATION_RESERVATIONS | ST_RESERVE);
11968 				un->un_rsvd_status &= ~(ST_RELEASE |
11969 				    ST_LOST_RESERVE | ST_RESERVATION_CONFLICT |
11970 				    ST_INITIATED_RESET);
11971 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11972 				    "PGR Reserve and set: entering"
11973 				    " ST_APPLICATION_RESERVATIONS mode");
11974 				break;
11975 			case ST_SA_SCSI3_REGISTER:
11976 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11977 				    "PGR Reserve register key");
11978 				un->un_rsvd_status |= ST_INIT_RESERVE;
11979 				break;
11980 			case ST_SA_SCSI3_CLEAR:
11981 				un->un_rsvd_status &= ~ST_INIT_RESERVE;
11982 				/* FALLTHROUGH */
11983 			case ST_SA_SCSI3_RELEASE:
11984 				un->un_rsvd_status &=
11985 				    ~(ST_APPLICATION_RESERVATIONS | ST_RESERVE |
11986 				    ST_LOST_RESERVE | ST_RESERVATION_CONFLICT |
11987 				    ST_INITIATED_RESET);
11988 				un->un_rsvd_status |= ST_RELEASE;
11989 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
11990 				    "PGR Release and reset: exiting"
11991 				    " ST_APPLICATION_RESERVATIONS mode");
11992 				break;
11993 			}
11994 			new_lastop = ST_OP_CTL;
11995 			break;
11996 		case SCMD_TEST_UNIT_READY:
11997 		case SCMD_READ_BLKLIM:
11998 		case SCMD_REQUEST_SENSE:
11999 		case SCMD_INQUIRY:
12000 		case SCMD_RECOVER_BUF:
12001 		case SCMD_MODE_SELECT:
12002 		case SCMD_MODE_SENSE:
12003 		case SCMD_DOORLOCK:
12004 		case SCMD_READ_BUFFER:
12005 		case SCMD_REPORT_DENSITIES:
12006 		case SCMD_LOG_SELECT_G1:
12007 		case SCMD_LOG_SENSE_G1:
12008 		case SCMD_REPORT_LUNS:
12009 		case SCMD_READ_ATTRIBUTE:
12010 		case SCMD_WRITE_ATTRIBUTE:
12011 		case SCMD_SVC_ACTION_IN_G5:
12012 		case SCMD_SECURITY_PROTO_IN:
12013 		case SCMD_SECURITY_PROTO_OUT:
12014 			new_lastop = ST_OP_CTL;
12015 			break;
12016 		case SCMD_READ_POSITION:
12017 			new_lastop = ST_OP_CTL;
12018 			/*
12019 			 * Only if the buf used was un_sbufp.
12020 			 * Among other things the prevents read positions used
12021 			 * as part of error recovery from messing up our
12022 			 * current position as they will use un_recov_buf.
12023 			 */
12024 			if (USCSI_CMD(bp)) {
12025 				(void) st_get_read_pos(un, bp);
12026 			}
12027 			break;
12028 		case SCMD_LOCATE:
12029 		case SCMD_LOCATE_G4:
12030 			/* Locate makes position mode no longer legacy */
12031 			un->un_lastop = new_lastop = ST_OP_CTL;
12032 			break;
12033 		case SCMD_MAINTENANCE_IN:
12034 			switch (sp->pkt_cdbp[1]) {
12035 			case SSVC_ACTION_GET_SUPPORTED_OPERATIONS:
12036 			case SSVC_ACTION_SET_TARGET_PORT_GROUPS:
12037 				new_lastop = ST_OP_CTL;
12038 				break;
12039 			}
12040 			if (new_lastop != ST_OP_NIL) {
12041 				break;
12042 			}
12043 		default:
12044 			/*
12045 			 * Unknown command, If was USCSI and USCSI_SILENT
12046 			 * flag was not set, set position to unknown.
12047 			 */
12048 			if ((((ucmd = BP_UCMD(bp)) != NULL) &&
12049 			    (ucmd->uscsi_flags & USCSI_SILENT) == 0)) {
12050 				ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
12051 				    "unknown cmd 0x%X caused loss of state\n",
12052 				    cmd);
12053 			} else {
12054 				/*
12055 				 * keep the old agreement to allow unknown
12056 				 * commands with the USCSI_SILENT set.
12057 				 * This prevents ASSERT below.
12058 				 */
12059 				new_lastop = ST_OP_CTL;
12060 				break;
12061 			}
12062 			/* FALLTHROUGH */
12063 		case SCMD_WRITE_BUFFER: /* Writes new firmware to device */
12064 			un->un_pos.pmode = invalid;
12065 			un->un_lastop = new_lastop = ST_OP_CTL;
12066 			break;
12067 		}
12068 
12069 		/* new_lastop should have been changed */
12070 		ASSERT(new_lastop != ST_OP_NIL);
12071 
12072 		/* If un_lastop should copy new_lastop  */
12073 		if (((un->un_lastop == ST_OP_WRITE) ||
12074 		    (un->un_lastop == ST_OP_WEOF)) &&
12075 		    new_lastop != ST_OP_CTL) {
12076 			un->un_lastop = new_lastop;
12077 		}
12078 	}
12079 
12080 	/*
12081 	 * In the st driver we have a logical and physical file position.
12082 	 * Under BSD behavior, when you get a zero read, the logical position
12083 	 * is before the filemark but after the last record of the file.
12084 	 * The physical position is after the filemark. MTIOCGET should always
12085 	 * return the logical file position.
12086 	 *
12087 	 * The next read gives a silent skip to the next file.
12088 	 * Under SVR4, the logical file position remains before the filemark
12089 	 * until the file is closed or a space operation is performed.
12090 	 * Hence set err_resid and err_file before changing fileno if case
12091 	 * BSD Behaviour.
12092 	 */
12093 	un->un_err_resid = bp->b_resid;
12094 	COPY_POS(&un->un_err_pos, &un->un_pos);
12095 
12096 
12097 	/*
12098 	 * If we've seen a filemark via the last read operation
12099 	 * advance the file counter, but mark things such that
12100 	 * the next read operation gets a zero count. We have
12101 	 * to put this here to handle the case of sitting right
12102 	 * at the end of a tape file having seen the file mark,
12103 	 * but the tape is closed and then re-opened without
12104 	 * any further i/o. That is, the position information
12105 	 * must be updated before a close.
12106 	 */
12107 
12108 	if (un->un_lastop == ST_OP_READ && un->un_pos.eof == ST_EOF_PENDING) {
12109 		/*
12110 		 * If we're a 1/2" tape, and we get a filemark
12111 		 * right on block 0, *AND* we were not in the
12112 		 * first file on the tape, and we've hit logical EOM.
12113 		 * We'll mark the state so that later we do the
12114 		 * right thing (in st_close(), st_strategy() or
12115 		 * st_ioctl()).
12116 		 *
12117 		 */
12118 		if ((un->un_dp->options & ST_REEL) &&
12119 		    !(un->un_dp->options & ST_READ_IGNORE_EOFS) &&
12120 		    un->un_pos.blkno == 0 && un->un_pos.fileno > 0) {
12121 			un->un_pos.eof = ST_EOT_PENDING;
12122 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
12123 			    "eot pending\n");
12124 			un->un_pos.fileno++;
12125 			un->un_pos.blkno = 0;
12126 		} else if (BP_UCMD(bp)) {
12127 			/*
12128 			 * Uscsi reads have no concept of Berkley ver System IV.
12129 			 * Counts here must match raw device.
12130 			 * A non-full resid implies fix block mode where an
12131 			 * attempt to read X blocks resulted in less then X.
12132 			 */
12133 			if (bp->b_resid != bp->b_bcount) {
12134 				un->un_pos.eof = ST_EOF;
12135 			} else {
12136 				/* Read over a file mark */
12137 				un->un_pos.fileno++;
12138 				/* logical block is counted up elsewhere */
12139 				/* we're before the first block in next file */
12140 				un->un_pos.blkno = 0;
12141 				/* EOF is no longer pending */
12142 				un->un_pos.eof = ST_NO_EOF;
12143 			}
12144 		} else if (BSD_BEHAVIOR) {
12145 			/*
12146 			 * If the read of the filemark was a side effect
12147 			 * of reading some blocks (i.e., data was actually
12148 			 * read), then the EOF mark is pending and the
12149 			 * bump into the next file awaits the next read
12150 			 * operation (which will return a zero count), or
12151 			 * a close or a space operation, else the bump
12152 			 * into the next file occurs now.
12153 			 */
12154 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
12155 			    "resid=%lx, bcount=%lx\n",
12156 			    bp->b_resid, bp->b_bcount);
12157 
12158 			if (bp->b_resid != bp->b_bcount) {
12159 				un->un_pos.eof = ST_EOF;
12160 			} else {
12161 				un->un_silent_skip = 1;
12162 				un->un_pos.eof = ST_NO_EOF;
12163 				un->un_pos.fileno++;
12164 				un->un_pos.lgclblkno++;
12165 				un->un_save_blkno = un->un_pos.blkno;
12166 				un->un_pos.blkno = 0;
12167 			}
12168 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
12169 			    "eof of file %d, eof=%d\n",
12170 			    un->un_pos.fileno, un->un_pos.eof);
12171 		} else if (SVR4_BEHAVIOR) {
12172 			/*
12173 			 * If the read of the filemark was a side effect
12174 			 * of reading some blocks (i.e., data was actually
12175 			 * read), then the next read should return 0
12176 			 */
12177 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
12178 			    "resid=%lx, bcount=%lx\n",
12179 			    bp->b_resid, bp->b_bcount);
12180 			if (bp->b_resid == bp->b_bcount) {
12181 				un->un_pos.eof = ST_EOF;
12182 			}
12183 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
12184 			    "eof of file=%d, eof=%d\n",
12185 			    un->un_pos.fileno, un->un_pos.eof);
12186 		}
12187 	}
12188 }
12189 
12190 /*
12191  * set the correct un_errno, to take corner cases into consideration
12192  */
12193 static void
12194 st_set_pe_errno(struct scsi_tape *un)
12195 {
12196 	ST_FUNC(ST_DEVINFO, st_set_pe_errno);
12197 
12198 	ASSERT(mutex_owned(ST_MUTEX));
12199 
12200 	/* if errno is already set, don't reset it */
12201 	if (un->un_errno)
12202 		return;
12203 
12204 	/* here un_errno == 0 */
12205 	/*
12206 	 * if the last transfer before flushing all the
12207 	 * waiting I/O's, was 0 (resid = count), then we
12208 	 * want to give the user an error on all the rest,
12209 	 * so here.  If there was a transfer, we set the
12210 	 * resid and counts to 0, and let it drop through,
12211 	 * giving a zero return.  the next I/O will then
12212 	 * give an error.
12213 	 */
12214 	if (un->un_last_resid == un->un_last_count) {
12215 		switch (un->un_pos.eof) {
12216 		case ST_EOM:
12217 			un->un_errno = ENOMEM;
12218 			break;
12219 		case ST_EOT:
12220 		case ST_EOF:
12221 			un->un_errno = EIO;
12222 			break;
12223 		}
12224 	} else {
12225 		/*
12226 		 * we know they did not have a zero, so make
12227 		 * sure they get one
12228 		 */
12229 		un->un_last_resid = un->un_last_count = 0;
12230 	}
12231 }
12232 
12233 
12234 /*
12235  * send in a marker pkt to terminate flushing of commands by BBA (via
12236  * flush-on-errors) property.  The HBA will always return TRAN_ACCEPT
12237  */
12238 static void
12239 st_hba_unflush(struct scsi_tape *un)
12240 {
12241 	ST_FUNC(ST_DEVINFO, st_hba_unflush);
12242 
12243 	ASSERT(mutex_owned(ST_MUTEX));
12244 
12245 	if (!un->un_flush_on_errors)
12246 		return;
12247 
12248 #ifdef FLUSH_ON_ERRORS
12249 
12250 	if (!un->un_mkr_pkt) {
12251 		un->un_mkr_pkt = scsi_init_pkt(ROUTE, NULL, (struct buf *)NULL,
12252 		    NULL, 0, 0, 0, SLEEP_FUNC, NULL);
12253 
12254 		/* we slept, so it must be there */
12255 		pkt->pkt_flags |= FLAG_FLUSH_MARKER;
12256 	}
12257 
12258 	st_transport(un, un->un_mkr_pkt);
12259 #endif
12260 }
12261 
12262 static char *
12263 st_print_scsi_cmd(char cmd)
12264 {
12265 	char tmp[64];
12266 	char *cpnt;
12267 
12268 	cpnt = scsi_cmd_name(cmd, scsi_cmds, tmp);
12269 	/* tmp goes out of scope on return and caller sees garbage */
12270 	if (cpnt == tmp) {
12271 		cpnt = "Unknown Command";
12272 	}
12273 	return (cpnt);
12274 }
12275 
12276 static void
12277 st_print_cdb(dev_info_t *dip, char *label, uint_t level,
12278     char *title, char *cdb)
12279 {
12280 	int len = scsi_cdb_size[CDB_GROUPID(cdb[0])];
12281 	char buf[256];
12282 	struct scsi_tape *un;
12283 	int instance = ddi_get_instance(dip);
12284 
12285 	un = ddi_get_soft_state(st_state, instance);
12286 
12287 	ST_FUNC(dip, st_print_cdb);
12288 
12289 	/* force one line output so repeated commands are printed once */
12290 	if ((st_debug & 0x180) == 0x100) {
12291 		scsi_log(dip, label, level, "node %s cmd %s\n",
12292 		    st_dev_name(un->un_dev), st_print_scsi_cmd(*cdb));
12293 		return;
12294 	}
12295 
12296 	/* force one line output so repeated CDB's are printed once */
12297 	if ((st_debug & 0x180) == 0x80) {
12298 		st_clean_print(dip, label, level, NULL, cdb, len);
12299 	} else {
12300 		(void) sprintf(buf, "%s for cmd(%s)", title,
12301 		    st_print_scsi_cmd(*cdb));
12302 		st_clean_print(dip, label, level, buf, cdb, len);
12303 	}
12304 }
12305 
12306 static void
12307 st_clean_print(dev_info_t *dev, char *label, uint_t level,
12308     char *title, char *data, int len)
12309 {
12310 	int	i;
12311 	int 	c;
12312 	char	*format;
12313 	char	buf[256];
12314 	uchar_t	byte;
12315 
12316 	ST_FUNC(dev, st_clean_print);
12317 
12318 
12319 	if (title) {
12320 		(void) sprintf(buf, "%s:\n", title);
12321 		scsi_log(dev, label, level, "%s", buf);
12322 		level = CE_CONT;
12323 	}
12324 
12325 	for (i = 0; i < len; ) {
12326 		buf[0] = 0;
12327 		for (c = 0; c < 8 && i < len; c++, i++) {
12328 			byte = (uchar_t)data[i];
12329 			if (byte < 0x10)
12330 				format = "0x0%x ";
12331 			else
12332 				format = "0x%x ";
12333 			(void) sprintf(&buf[(int)strlen(buf)], format, byte);
12334 		}
12335 		(void) sprintf(&buf[(int)strlen(buf)], "\n");
12336 
12337 		scsi_log(dev, label, level, "%s\n", buf);
12338 		level = CE_CONT;
12339 	}
12340 }
12341 
12342 /*
12343  * Conditionally enabled debugging
12344  */
12345 #ifdef	STDEBUG
12346 static void
12347 st_debug_cmds(struct scsi_tape *un, int com, int count, int wait)
12348 {
12349 	char tmpbuf[64];
12350 
12351 	ST_FUNC(ST_DEVINFO, st_debug_cmds);
12352 
12353 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
12354 	    "cmd=%s count=0x%x (%d)	 %ssync\n",
12355 	    scsi_cmd_name(com, scsi_cmds, tmpbuf),
12356 	    count, count,
12357 	    wait == ASYNC_CMD ? "a" : "");
12358 }
12359 #endif	/* STDEBUG */
12360 
12361 /*
12362  * Returns pointer to name of minor node name of device 'dev'.
12363  */
12364 static char *
12365 st_dev_name(dev_t dev)
12366 {
12367 	struct scsi_tape *un;
12368 	const char density[] = { 'l', 'm', 'h', 'c' };
12369 	static char name[32];
12370 	minor_t minor;
12371 	int instance;
12372 	int nprt = 0;
12373 
12374 	minor = getminor(dev);
12375 	instance = ((minor & 0xff80) >> 5) | (minor & 3);
12376 	un = ddi_get_soft_state(st_state, instance);
12377 	if (un) {
12378 		ST_FUNC(ST_DEVINFO, st_dev_name);
12379 	}
12380 
12381 	name[nprt] = density[(minor & MT_DENSITY_MASK) >> 3];
12382 
12383 	if (minor & MT_BSD) {
12384 		name[++nprt] = 'b';
12385 	}
12386 
12387 	if (minor & MT_NOREWIND) {
12388 		name[++nprt] = 'n';
12389 	}
12390 
12391 	/* NULL terminator */
12392 	name[++nprt] = 0;
12393 
12394 	return (name);
12395 }
12396 
12397 /*
12398  * Soft error reporting, so far unique to each drive
12399  *
12400  * Currently supported: exabyte and DAT soft error reporting
12401  */
12402 static int
12403 st_report_exabyte_soft_errors(dev_t dev, int flag)
12404 {
12405 	uchar_t *sensep;
12406 	int amt;
12407 	int rval = 0;
12408 	char cdb[CDB_GROUP0], *c = cdb;
12409 	struct uscsi_cmd *com;
12410 
12411 	GET_SOFT_STATE(dev);
12412 
12413 	ST_FUNC(ST_DEVINFO, st_report_exabyte_soft_errors);
12414 
12415 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
12416 	    "st_report_exabyte_soft_errors(dev = 0x%lx, flag = %d)\n",
12417 	    dev, flag);
12418 
12419 	ASSERT(mutex_owned(ST_MUTEX));
12420 
12421 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
12422 	sensep = kmem_zalloc(TAPE_SENSE_LENGTH, KM_SLEEP);
12423 
12424 	*c++ = SCMD_REQUEST_SENSE;
12425 	*c++ = 0;
12426 	*c++ = 0;
12427 	*c++ = 0;
12428 	*c++ = TAPE_SENSE_LENGTH;
12429 	/*
12430 	 * set CLRCNT (byte 5, bit 7 which clears the error counts)
12431 	 */
12432 	*c   = (char)0x80;
12433 
12434 	com->uscsi_cdb = cdb;
12435 	com->uscsi_cdblen = CDB_GROUP0;
12436 	com->uscsi_bufaddr = (caddr_t)sensep;
12437 	com->uscsi_buflen = TAPE_SENSE_LENGTH;
12438 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ;
12439 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
12440 
12441 	rval = st_uscsi_cmd(un, com, FKIOCTL);
12442 	if (rval || com->uscsi_status) {
12443 		goto done;
12444 	}
12445 
12446 	/*
12447 	 * was there enough data?
12448 	 */
12449 	amt = (int)TAPE_SENSE_LENGTH - com->uscsi_resid;
12450 
12451 	if ((amt >= 19) && un->un_kbytes_xferred) {
12452 		uint_t count, error_rate;
12453 		uint_t rate;
12454 
12455 		if (sensep[21] & CLN) {
12456 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
12457 			    "Periodic head cleaning required");
12458 		}
12459 		if (un->un_kbytes_xferred < (EXABYTE_MIN_TRANSFER/ONE_K)) {
12460 			goto done;
12461 		}
12462 		/*
12463 		 * check if soft error reporting needs to be done.
12464 		 */
12465 		count = sensep[16] << 16 | sensep[17] << 8 | sensep[18];
12466 		count &= 0xffffff;
12467 		error_rate = (count * 100)/un->un_kbytes_xferred;
12468 
12469 #ifdef	STDEBUG
12470 		if (st_soft_error_report_debug) {
12471 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
12472 			    "Exabyte Soft Error Report:\n");
12473 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
12474 			    "read/write error counter: %d\n", count);
12475 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
12476 			    "number of bytes transferred: %dK\n",
12477 			    un->un_kbytes_xferred);
12478 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
12479 			    "error_rate: %d%%\n", error_rate);
12480 
12481 			if (amt >= 22) {
12482 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
12483 				    "unit sense: 0x%b 0x%b 0x%b\n",
12484 				    sensep[19], SENSE_19_BITS,
12485 				    sensep[20], SENSE_20_BITS,
12486 				    sensep[21], SENSE_21_BITS);
12487 			}
12488 			if (amt >= 27) {
12489 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
12490 				    "tracking retry counter: %d\n",
12491 				    sensep[26]);
12492 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
12493 				    "read/write retry counter: %d\n",
12494 				    sensep[27]);
12495 			}
12496 		}
12497 #endif
12498 
12499 		if (flag & FWRITE) {
12500 			rate = EXABYTE_WRITE_ERROR_THRESHOLD;
12501 		} else {
12502 			rate = EXABYTE_READ_ERROR_THRESHOLD;
12503 		}
12504 		if (error_rate >= rate) {
12505 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
12506 			    "Soft error rate (%d%%) during %s was too high",
12507 			    error_rate,
12508 			    ((flag & FWRITE) ? wrg_str : rdg_str));
12509 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
12510 			    "Please, replace tape cartridge\n");
12511 		}
12512 	}
12513 
12514 done:
12515 	kmem_free(com, sizeof (*com));
12516 	kmem_free(sensep, TAPE_SENSE_LENGTH);
12517 
12518 	if (rval != 0) {
12519 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
12520 		    "exabyte soft error reporting failed\n");
12521 	}
12522 	return (rval);
12523 }
12524 
12525 /*
12526  * this is very specific to Archive 4mm dat
12527  */
12528 #define	ONE_GIG	(ONE_K * ONE_K * ONE_K)
12529 
12530 static int
12531 st_report_dat_soft_errors(dev_t dev, int flag)
12532 {
12533 	uchar_t *sensep;
12534 	int amt, i;
12535 	int rval = 0;
12536 	char cdb[CDB_GROUP1], *c = cdb;
12537 	struct uscsi_cmd *com;
12538 	struct scsi_arq_status status;
12539 
12540 	GET_SOFT_STATE(dev);
12541 
12542 	ST_FUNC(ST_DEVINFO, st_report_dat_soft_errors);
12543 
12544 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
12545 	    "st_report_dat_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag);
12546 
12547 	ASSERT(mutex_owned(ST_MUTEX));
12548 
12549 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
12550 	sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP);
12551 
12552 	*c++ = SCMD_LOG_SENSE_G1;
12553 	*c++ = 0;
12554 	*c++ = (flag & FWRITE) ? 0x42 : 0x43;
12555 	*c++ = 0;
12556 	*c++ = 0;
12557 	*c++ = 0;
12558 	*c++ = 2;
12559 	*c++ = 0;
12560 	*c++ = (char)LOG_SENSE_LENGTH;
12561 	*c   = 0;
12562 	com->uscsi_cdb    = cdb;
12563 	com->uscsi_cdblen  = CDB_GROUP1;
12564 	com->uscsi_bufaddr = (caddr_t)sensep;
12565 	com->uscsi_buflen  = LOG_SENSE_LENGTH;
12566 	com->uscsi_rqlen = sizeof (status);
12567 	com->uscsi_rqbuf = (caddr_t)&status;
12568 	com->uscsi_flags   = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ;
12569 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
12570 	rval = st_uscsi_cmd(un, com, FKIOCTL);
12571 	if (rval) {
12572 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
12573 		    "DAT soft error reporting failed\n");
12574 	}
12575 	if (rval || com->uscsi_status) {
12576 		goto done;
12577 	}
12578 
12579 	/*
12580 	 * was there enough data?
12581 	 */
12582 	amt = (int)LOG_SENSE_LENGTH - com->uscsi_resid;
12583 
12584 	if ((amt >= MIN_LOG_SENSE_LENGTH) && un->un_kbytes_xferred) {
12585 		int total, retries, param_code;
12586 
12587 		total = -1;
12588 		retries = -1;
12589 		amt = sensep[3] + 4;
12590 
12591 
12592 #ifdef STDEBUG
12593 		if (st_soft_error_report_debug) {
12594 			(void) printf("logsense:");
12595 			for (i = 0; i < MIN_LOG_SENSE_LENGTH; i++) {
12596 				if (i % 16 == 0) {
12597 					(void) printf("\t\n");
12598 				}
12599 				(void) printf(" %x", sensep[i]);
12600 			}
12601 			(void) printf("\n");
12602 		}
12603 #endif
12604 
12605 		/*
12606 		 * parse the param_codes
12607 		 */
12608 		if (sensep[0] == 2 || sensep[0] == 3) {
12609 			for (i = 4; i < amt; i++) {
12610 				param_code = (sensep[i++] << 8);
12611 				param_code += sensep[i++];
12612 				i++; /* skip control byte */
12613 				if (param_code == 5) {
12614 					if (sensep[i++] == 4) {
12615 						total = (sensep[i++] << 24);
12616 						total += (sensep[i++] << 16);
12617 						total += (sensep[i++] << 8);
12618 						total += sensep[i];
12619 					}
12620 				} else if (param_code == 0x8007) {
12621 					if (sensep[i++] == 2) {
12622 						retries = sensep[i++] << 8;
12623 						retries += sensep[i];
12624 					}
12625 				} else {
12626 					i += sensep[i];
12627 				}
12628 			}
12629 		}
12630 
12631 		/*
12632 		 * if the log sense returned valid numbers then determine
12633 		 * the read and write error thresholds based on the amount of
12634 		 * data transferred
12635 		 */
12636 
12637 		if (total > 0 && retries > 0) {
12638 			short normal_retries = 0;
12639 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
12640 			    "total xferred (%s) =%x, retries=%x\n",
12641 			    ((flag & FWRITE) ? wrg_str : rdg_str),
12642 			    total, retries);
12643 
12644 			if (flag & FWRITE) {
12645 				if (total <=
12646 				    WRITE_SOFT_ERROR_WARNING_THRESHOLD) {
12647 					normal_retries =
12648 					    DAT_SMALL_WRITE_ERROR_THRESHOLD;
12649 				} else {
12650 					normal_retries =
12651 					    DAT_LARGE_WRITE_ERROR_THRESHOLD;
12652 				}
12653 			} else {
12654 				if (total <=
12655 				    READ_SOFT_ERROR_WARNING_THRESHOLD) {
12656 					normal_retries =
12657 					    DAT_SMALL_READ_ERROR_THRESHOLD;
12658 				} else {
12659 					normal_retries =
12660 					    DAT_LARGE_READ_ERROR_THRESHOLD;
12661 				}
12662 			}
12663 
12664 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
12665 			"normal retries=%d\n", normal_retries);
12666 
12667 			if (retries >= normal_retries) {
12668 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
12669 				    "Soft error rate (retries = %d) during "
12670 				    "%s was too high",  retries,
12671 				    ((flag & FWRITE) ? wrg_str : rdg_str));
12672 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
12673 				    "Periodic head cleaning required "
12674 				    "and/or replace tape cartridge\n");
12675 			}
12676 
12677 		} else if (total == -1 || retries == -1) {
12678 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
12679 			    "log sense parameter code does not make sense\n");
12680 		}
12681 	}
12682 
12683 	/*
12684 	 * reset all values
12685 	 */
12686 	c = cdb;
12687 	*c++ = SCMD_LOG_SELECT_G1;
12688 	*c++ = 2;	/* this resets all values */
12689 	*c++ = (char)0xc0;
12690 	*c++ = 0;
12691 	*c++ = 0;
12692 	*c++ = 0;
12693 	*c++ = 0;
12694 	*c++ = 0;
12695 	*c++ = 0;
12696 	*c   = 0;
12697 	com->uscsi_bufaddr = NULL;
12698 	com->uscsi_buflen  = 0;
12699 	com->uscsi_flags   = USCSI_DIAGNOSE | USCSI_SILENT;
12700 	rval = st_uscsi_cmd(un, com, FKIOCTL);
12701 	if (rval) {
12702 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
12703 		    "DAT soft error reset failed\n");
12704 	}
12705 done:
12706 	kmem_free(com, sizeof (*com));
12707 	kmem_free(sensep, LOG_SENSE_LENGTH);
12708 	return (rval);
12709 }
12710 
12711 static int
12712 st_report_soft_errors(dev_t dev, int flag)
12713 {
12714 	GET_SOFT_STATE(dev);
12715 
12716 	ST_FUNC(ST_DEVINFO, st_report_soft_errors);
12717 
12718 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
12719 	    "st_report_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag);
12720 
12721 	ASSERT(mutex_owned(ST_MUTEX));
12722 
12723 	switch (un->un_dp->type) {
12724 	case ST_TYPE_EXB8500:
12725 	case ST_TYPE_EXABYTE:
12726 		return (st_report_exabyte_soft_errors(dev, flag));
12727 		/*NOTREACHED*/
12728 	case ST_TYPE_PYTHON:
12729 		return (st_report_dat_soft_errors(dev, flag));
12730 		/*NOTREACHED*/
12731 	default:
12732 		un->un_dp->options &= ~ST_SOFT_ERROR_REPORTING;
12733 		return (-1);
12734 	}
12735 }
12736 
12737 /*
12738  * persistent error routines
12739  */
12740 
12741 /*
12742  * enable persistent errors, and set the throttle appropriately, checking
12743  * for flush-on-errors capability
12744  */
12745 static void
12746 st_turn_pe_on(struct scsi_tape *un)
12747 {
12748 	ST_FUNC(ST_DEVINFO, st_turn_pe_on);
12749 
12750 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_on\n");
12751 	ASSERT(mutex_owned(ST_MUTEX));
12752 
12753 	un->un_persistence = 1;
12754 
12755 	/*
12756 	 * only use flush-on-errors if auto-request-sense and untagged-qing are
12757 	 * enabled.  This will simplify the error handling for request senses
12758 	 */
12759 
12760 	if (un->un_arq_enabled && un->un_untagged_qing) {
12761 		uchar_t f_o_e;
12762 
12763 		mutex_exit(ST_MUTEX);
12764 		f_o_e = (scsi_ifsetcap(ROUTE, "flush-on-errors", 1, 1) == 1) ?
12765 		    1 : 0;
12766 		mutex_enter(ST_MUTEX);
12767 
12768 		un->un_flush_on_errors = f_o_e;
12769 	} else {
12770 		un->un_flush_on_errors = 0;
12771 	}
12772 
12773 	if (un->un_flush_on_errors)
12774 		un->un_max_throttle = (uchar_t)st_max_throttle;
12775 	else
12776 		un->un_max_throttle = 1;
12777 
12778 	if (un->un_dp->options & ST_RETRY_ON_RECOVERED_DEFERRED_ERROR)
12779 		un->un_max_throttle = 1;
12780 
12781 	/* this will send a marker pkt */
12782 	st_clear_pe(un);
12783 }
12784 
12785 /*
12786  * This turns persistent errors permanently off
12787  */
12788 static void
12789 st_turn_pe_off(struct scsi_tape *un)
12790 {
12791 	ST_FUNC(ST_DEVINFO, st_turn_pe_off);
12792 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_off\n");
12793 	ASSERT(mutex_owned(ST_MUTEX));
12794 
12795 	/* turn it off for good */
12796 	un->un_persistence = 0;
12797 
12798 	/* this will send a marker pkt */
12799 	st_clear_pe(un);
12800 
12801 	/* turn off flush on error capability, if enabled */
12802 	if (un->un_flush_on_errors) {
12803 		mutex_exit(ST_MUTEX);
12804 		(void) scsi_ifsetcap(ROUTE, "flush-on-errors", 0, 1);
12805 		mutex_enter(ST_MUTEX);
12806 	}
12807 
12808 
12809 	un->un_flush_on_errors = 0;
12810 }
12811 
12812 /*
12813  * This clear persistent errors, allowing more commands through, and also
12814  * sending a marker packet.
12815  */
12816 static void
12817 st_clear_pe(struct scsi_tape *un)
12818 {
12819 	ST_FUNC(ST_DEVINFO, st_clear_pe);
12820 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_clear\n");
12821 	ASSERT(mutex_owned(ST_MUTEX));
12822 
12823 	un->un_persist_errors = 0;
12824 	un->un_throttle = un->un_last_throttle = 1;
12825 	un->un_errno = 0;
12826 	st_hba_unflush(un);
12827 }
12828 
12829 /*
12830  * This will flag persistent errors, shutting everything down, if the
12831  * application had enabled persistent errors via MTIOCPERSISTENT
12832  */
12833 static void
12834 st_set_pe_flag(struct scsi_tape *un)
12835 {
12836 	ST_FUNC(ST_DEVINFO, st_set_pe_flag);
12837 	ASSERT(mutex_owned(ST_MUTEX));
12838 
12839 	if (un->un_persistence) {
12840 		ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_flag\n");
12841 		un->un_persist_errors = 1;
12842 		un->un_throttle = un->un_last_throttle = 0;
12843 		cv_broadcast(&un->un_sbuf_cv);
12844 	}
12845 }
12846 
12847 static int
12848 st_do_reserve(struct scsi_tape *un)
12849 {
12850 	int rval;
12851 	int was_lost = un->un_rsvd_status & ST_LOST_RESERVE;
12852 
12853 	ST_FUNC(ST_DEVINFO, st_do_reserve);
12854 
12855 	/*
12856 	 * Issue a Throw-Away reserve command to clear the
12857 	 * check condition.
12858 	 * If the current behaviour of reserve/release is to
12859 	 * hold reservation across opens , and if a Bus reset
12860 	 * has been issued between opens then this command
12861 	 * would set the ST_LOST_RESERVE flags in rsvd_status.
12862 	 * In this case return an EACCES so that user knows that
12863 	 * reservation has been lost in between opens.
12864 	 * If this error is not returned and we continue with
12865 	 * successful open , then user may think position of the
12866 	 * tape is still the same but inreality we would rewind the
12867 	 * tape and continue from BOT.
12868 	 */
12869 	rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd);
12870 	if (rval) {
12871 		if ((un->un_rsvd_status & ST_LOST_RESERVE_BETWEEN_OPENS) ==
12872 		    ST_LOST_RESERVE_BETWEEN_OPENS) {
12873 			un->un_rsvd_status &= ~(ST_LOST_RESERVE | ST_RESERVE);
12874 			un->un_errno = EACCES;
12875 			return (EACCES);
12876 		}
12877 		rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd);
12878 	}
12879 	if (rval == 0) {
12880 		un->un_rsvd_status |= ST_INIT_RESERVE;
12881 	}
12882 	if (was_lost) {
12883 		un->un_running.pmode = invalid;
12884 	}
12885 
12886 	return (rval);
12887 }
12888 
12889 static int
12890 st_check_cdb_for_need_to_reserve(struct scsi_tape *un, uchar_t *cdb)
12891 {
12892 	int rval;
12893 	cmd_attribute const *attrib;
12894 
12895 	ST_FUNC(ST_DEVINFO, st_check_cdb_for_need_to_reserve);
12896 
12897 	/*
12898 	 * If already reserved no need to do it again.
12899 	 * Also if Reserve and Release are disabled Just return.
12900 	 */
12901 	if ((un->un_rsvd_status & (ST_APPLICATION_RESERVATIONS)) ||
12902 	    ((un->un_rsvd_status & (ST_RESERVE | ST_LOST_RESERVE)) ==
12903 	    ST_RESERVE) || (un->un_dp->options & ST_NO_RESERVE_RELEASE)) {
12904 		ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
12905 		    "st_check_cdb_for_need_to_reserve() reserve unneeded %s",
12906 		    st_print_scsi_cmd((uchar_t)cdb[0]));
12907 		return (0);
12908 	}
12909 
12910 	/* See if command is on the list */
12911 	attrib = st_lookup_cmd_attribute(cdb[0]);
12912 
12913 	if (attrib == NULL) {
12914 		rval = 1; /* Not found, when in doubt reserve */
12915 	} else if ((attrib->requires_reserve) != 0) {
12916 		rval = 1;
12917 	} else if ((attrib->reserve_byte) != 0) {
12918 		/*
12919 		 * cmd is on list.
12920 		 * if byte is zero always allowed.
12921 		 */
12922 		rval = 1;
12923 	} else if (((cdb[attrib->reserve_byte]) &
12924 	    (attrib->reserve_mask)) != 0) {
12925 		rval = 1;
12926 	} else {
12927 		rval = 0;
12928 	}
12929 
12930 	if (rval) {
12931 		ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
12932 		    "Command %s requires reservation",
12933 		    st_print_scsi_cmd(cdb[0]));
12934 
12935 		rval = st_do_reserve(un);
12936 	}
12937 
12938 	return (rval);
12939 }
12940 
12941 static int
12942 st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd, int cnt)
12943 {
12944 	int rval;
12945 	cmd_attribute const *attrib;
12946 
12947 	ST_FUNC(ST_DEVINFO, st_check_cmd_for_need_to_reserve);
12948 
12949 	/*
12950 	 * Do not reserve when already reserved, when not supported or when
12951 	 * auto-rewinding on device closure.
12952 	 */
12953 	if ((un->un_rsvd_status & (ST_APPLICATION_RESERVATIONS)) ||
12954 	    ((un->un_rsvd_status & (ST_RESERVE | ST_LOST_RESERVE)) ==
12955 	    ST_RESERVE) || (un->un_dp->options & ST_NO_RESERVE_RELEASE) ||
12956 	    ((un->un_state == ST_STATE_CLOSING) && (cmd == SCMD_REWIND))) {
12957 		ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
12958 		    "st_check_cmd_for_need_to_reserve() reserve unneeded %s",
12959 		    st_print_scsi_cmd(cmd));
12960 		return (0);
12961 	}
12962 
12963 	/* search for this command on the list */
12964 	attrib = st_lookup_cmd_attribute(cmd);
12965 
12966 	if (attrib == NULL) {
12967 		rval = 1; /* Not found, when in doubt reserve */
12968 	} else if ((attrib->requires_reserve) != 0) {
12969 		rval = 1;
12970 	} else if ((attrib->reserve_byte) != 0) {
12971 		/*
12972 		 * cmd is on list.
12973 		 * if byte is zero always allowed.
12974 		 */
12975 		rval = 1;
12976 	} else if (((attrib->reserve_mask) & cnt) != 0) {
12977 		rval = 1;
12978 	} else {
12979 		rval = 0;
12980 	}
12981 
12982 	if (rval) {
12983 		ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
12984 		    "Cmd %s requires reservation", st_print_scsi_cmd(cmd));
12985 
12986 		rval = st_do_reserve(un);
12987 	}
12988 
12989 	return (rval);
12990 }
12991 
12992 static int
12993 st_reserve_release(struct scsi_tape *un, int cmd, ubufunc_t ubf)
12994 {
12995 	struct uscsi_cmd	uscsi_cmd;
12996 	int			rval;
12997 	char			cdb[CDB_GROUP0];
12998 	struct scsi_arq_status	stat;
12999 
13000 
13001 
13002 	ST_FUNC(ST_DEVINFO, st_reserve_release);
13003 
13004 	ASSERT(mutex_owned(ST_MUTEX));
13005 
13006 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
13007 	    "st_reserve_release: %s \n",
13008 	    (cmd == ST_RELEASE)?  "Releasing":"Reserving");
13009 
13010 	bzero(&cdb, CDB_GROUP0);
13011 	if (cmd == ST_RELEASE) {
13012 		cdb[0] = SCMD_RELEASE;
13013 	} else {
13014 		cdb[0] = SCMD_RESERVE;
13015 	}
13016 	bzero(&uscsi_cmd, sizeof (struct uscsi_cmd));
13017 	uscsi_cmd.uscsi_flags = USCSI_WRITE | USCSI_RQENABLE;
13018 	uscsi_cmd.uscsi_cdb = cdb;
13019 	uscsi_cmd.uscsi_cdblen = CDB_GROUP0;
13020 	uscsi_cmd.uscsi_timeout = un->un_dp->non_motion_timeout;
13021 	uscsi_cmd.uscsi_rqbuf = (caddr_t)&stat;
13022 	uscsi_cmd.uscsi_rqlen = sizeof (stat);
13023 
13024 	rval = ubf(un, &uscsi_cmd, FKIOCTL);
13025 
13026 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
13027 	    "st_reserve_release: rval(1)=%d\n", rval);
13028 
13029 	if (rval) {
13030 		if (uscsi_cmd.uscsi_status == STATUS_RESERVATION_CONFLICT) {
13031 			rval = EACCES;
13032 		}
13033 		/*
13034 		 * dynamically turn off reserve/release support
13035 		 * in case of drives which do not support
13036 		 * reserve/release command(ATAPI drives).
13037 		 */
13038 		if (un->un_status == KEY_ILLEGAL_REQUEST) {
13039 			if ((un->un_dp->options & ST_NO_RESERVE_RELEASE) == 0) {
13040 				un->un_dp->options |= ST_NO_RESERVE_RELEASE;
13041 				ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
13042 				    "Tape unit does not support "
13043 				    "reserve/release \n");
13044 			}
13045 			rval = 0;
13046 		}
13047 	}
13048 	return (rval);
13049 }
13050 
13051 static int
13052 st_take_ownership(struct scsi_tape *un, ubufunc_t ubf)
13053 {
13054 	int rval;
13055 
13056 	ST_FUNC(ST_DEVINFO, st_take_ownership);
13057 
13058 	ASSERT(mutex_owned(ST_MUTEX));
13059 
13060 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
13061 	    "st_take_ownership: Entering ...\n");
13062 
13063 
13064 	rval = st_reserve_release(un, ST_RESERVE, ubf);
13065 	/*
13066 	 * XXX -> Should reset be done only if we get EACCES.
13067 	 * .
13068 	 */
13069 	if (rval) {
13070 		if (st_reset(un, RESET_LUN) == 0) {
13071 			return (EIO);
13072 		}
13073 		un->un_rsvd_status &=
13074 		    ~(ST_LOST_RESERVE | ST_RESERVATION_CONFLICT);
13075 
13076 		mutex_exit(ST_MUTEX);
13077 		delay(drv_usectohz(ST_RESERVATION_DELAY));
13078 		mutex_enter(ST_MUTEX);
13079 		/*
13080 		 * remove the check condition.
13081 		 */
13082 		(void) st_reserve_release(un, ST_RESERVE, ubf);
13083 		rval = st_reserve_release(un, ST_RESERVE, ubf);
13084 		if (rval != 0) {
13085 			if ((st_reserve_release(un, ST_RESERVE, ubf))
13086 			    != 0) {
13087 				rval = (un->un_rsvd_status &
13088 				    ST_RESERVATION_CONFLICT) ? EACCES : EIO;
13089 				return (rval);
13090 			}
13091 		}
13092 		/*
13093 		 * Set tape state to ST_STATE_OFFLINE , in case if
13094 		 * the user wants to continue and start using
13095 		 * the tape.
13096 		 */
13097 		un->un_state = ST_STATE_OFFLINE;
13098 		un->un_rsvd_status |= ST_INIT_RESERVE;
13099 	}
13100 	return (rval);
13101 }
13102 
13103 static int
13104 st_create_errstats(struct scsi_tape *un, int instance)
13105 {
13106 	char	kstatname[KSTAT_STRLEN];
13107 
13108 	ST_FUNC(ST_DEVINFO, st_create_errstats);
13109 
13110 	/*
13111 	 * Create device error kstats
13112 	 */
13113 
13114 	if (un->un_errstats == (kstat_t *)0) {
13115 		(void) sprintf(kstatname, "st%d,err", instance);
13116 		un->un_errstats = kstat_create("sterr", instance, kstatname,
13117 		    "device_error", KSTAT_TYPE_NAMED,
13118 		    sizeof (struct st_errstats) / sizeof (kstat_named_t),
13119 		    KSTAT_FLAG_PERSISTENT);
13120 
13121 		if (un->un_errstats) {
13122 			struct st_errstats	*stp;
13123 
13124 			stp = (struct st_errstats *)un->un_errstats->ks_data;
13125 			kstat_named_init(&stp->st_softerrs, "Soft Errors",
13126 			    KSTAT_DATA_ULONG);
13127 			kstat_named_init(&stp->st_harderrs, "Hard Errors",
13128 			    KSTAT_DATA_ULONG);
13129 			kstat_named_init(&stp->st_transerrs, "Transport Errors",
13130 			    KSTAT_DATA_ULONG);
13131 			kstat_named_init(&stp->st_vid, "Vendor",
13132 			    KSTAT_DATA_CHAR);
13133 			kstat_named_init(&stp->st_pid, "Product",
13134 			    KSTAT_DATA_CHAR);
13135 			kstat_named_init(&stp->st_revision, "Revision",
13136 			    KSTAT_DATA_CHAR);
13137 			kstat_named_init(&stp->st_serial, "Serial No",
13138 			    KSTAT_DATA_CHAR);
13139 			un->un_errstats->ks_private = un;
13140 			un->un_errstats->ks_update = nulldev;
13141 			kstat_install(un->un_errstats);
13142 			/*
13143 			 * Fill in the static data
13144 			 */
13145 			(void) strncpy(&stp->st_vid.value.c[0],
13146 			    ST_INQUIRY->inq_vid, 8);
13147 			/*
13148 			 * XXX:  Emulex MT-02 (and emulators) predates
13149 			 *	 SCSI-1 and has no vid & pid inquiry data.
13150 			 */
13151 			if (ST_INQUIRY->inq_len != 0) {
13152 				(void) strncpy(&stp->st_pid.value.c[0],
13153 				    ST_INQUIRY->inq_pid, 16);
13154 				(void) strncpy(&stp->st_revision.value.c[0],
13155 				    ST_INQUIRY->inq_revision, 4);
13156 			}
13157 		}
13158 	}
13159 	return (0);
13160 }
13161 
13162 static int
13163 st_validate_tapemarks(struct scsi_tape *un, ubufunc_t ubf, tapepos_t *pos)
13164 {
13165 	int rval;
13166 	bufunc_t bf = (ubf == st_uscsi_rcmd) ? st_rcmd : st_cmd;
13167 
13168 	ST_FUNC(ST_DEVINFO, st_validate_tapemarks);
13169 
13170 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
13171 	ASSERT(mutex_owned(ST_MUTEX));
13172 
13173 	/* Can't restore an invalid position */
13174 	if (pos->pmode == invalid) {
13175 		return (4);
13176 	}
13177 
13178 	/*
13179 	 * Assumtions:
13180 	 *	If a position was read and is in logical position mode.
13181 	 *	If a drive supports read position it supports locate.
13182 	 *	If the read position type is not NO_POS. even though
13183 	 *	   a read position make not have been attemped yet.
13184 	 *
13185 	 *	The drive can locate to the position.
13186 	 */
13187 	if (pos->pmode == logical || un->un_read_pos_type != NO_POS) {
13188 		/*
13189 		 * If position mode is logical or legacy mode try
13190 		 * to locate there as it is faster.
13191 		 * If it fails try the old way.
13192 		 */
13193 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
13194 		    "Restoring tape position to lgclblkbo=0x%"PRIx64"....",
13195 		    pos->lgclblkno);
13196 
13197 		if (st_logical_block_locate(un, st_uscsi_cmd, &un->un_pos,
13198 		    pos->lgclblkno, pos->partition) == 0) {
13199 			/* Assume we are there copy rest of position back */
13200 			if (un->un_pos.lgclblkno == pos->lgclblkno) {
13201 				COPY_POS(&un->un_pos, pos);
13202 			}
13203 			return (0);
13204 		}
13205 
13206 		/*
13207 		 * If logical block locate failed to restore a logical
13208 		 * position, can't recover.
13209 		 */
13210 		if (pos->pmode == logical) {
13211 			return (-1);
13212 		}
13213 	}
13214 
13215 
13216 	scsi_log(ST_DEVINFO, st_label, CE_NOTE,
13217 	    "Restoring tape position at fileno=%x, blkno=%x....",
13218 	    pos->fileno, pos->blkno);
13219 
13220 	/*
13221 	 * Rewind ? Oh yeah, Fidelity has got the STK F/W changed
13222 	 * so as not to rewind tape on RESETS: Gee, Has life ever
13223 	 * been simple in tape land ?
13224 	 */
13225 	rval = bf(un, SCMD_REWIND, 0, SYNC_CMD);
13226 	if (rval) {
13227 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
13228 		    "Failed to restore the last file and block position: In"
13229 		    " this state, Tape will be loaded at BOT during next open");
13230 		un->un_pos.pmode = invalid;
13231 		return (rval);
13232 	}
13233 
13234 	/* If the position was as the result of back space file */
13235 	if (pos->blkno > (INF / 2)) {
13236 		/* Go one extra file forward */
13237 		pos->fileno++;
13238 		/* Figure how many blocks to back into the previous file */
13239 		pos->blkno = -(INF - pos->blkno);
13240 	}
13241 
13242 	/* Go to requested fileno */
13243 	if (pos->fileno) {
13244 		rval = st_cmd(un, SCMD_SPACE, Fmk(pos->fileno), SYNC_CMD);
13245 		if (rval) {
13246 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
13247 			    "Failed to restore the last file position: In this "
13248 			    " state, Tape will be loaded at BOT during next"
13249 			    " open %d", __LINE__);
13250 			un->un_pos.pmode = invalid;
13251 			pos->pmode = invalid;
13252 			return (rval);
13253 		}
13254 	}
13255 
13256 	/*
13257 	 * If backing into a file we already did an extra file forward.
13258 	 * Now we have to back over the filemark to get to the end of
13259 	 * the previous file. The blkno has been ajusted to a negative
13260 	 * value so we will get to the expected location.
13261 	 */
13262 	if (pos->blkno) {
13263 		rval = bf(un, SCMD_SPACE, Fmk(-1), SYNC_CMD);
13264 		if (rval) {
13265 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
13266 			    "Failed to restore the last file position: In this "
13267 			    " state, Tape will be loaded at BOT during next"
13268 			    " open %d", __LINE__);
13269 			un->un_pos.pmode = invalid;
13270 			pos->pmode = invalid;
13271 			return (rval);
13272 		}
13273 	}
13274 
13275 	/*
13276 	 * The position mode, block and fileno should be correct,
13277 	 * This updates eof and logical position information.
13278 	 */
13279 	un->un_pos.eof = pos->eof;
13280 	un->un_pos.lgclblkno = pos->lgclblkno;
13281 
13282 	return (0);
13283 }
13284 
13285 /*
13286  * check sense key, ASC, ASCQ in order to determine if the tape needs
13287  * to be ejected
13288  */
13289 
13290 static int
13291 st_check_asc_ascq(struct scsi_tape *un)
13292 {
13293 	struct scsi_extended_sense *sensep = ST_RQSENSE;
13294 	struct tape_failure_code   *code;
13295 
13296 	ST_FUNC(ST_DEVINFO, st_check_asc_ascq);
13297 
13298 	for (code = st_tape_failure_code; code->key != 0xff; code++) {
13299 		if ((code->key  == sensep->es_key) &&
13300 		    (code->add_code  == sensep->es_add_code) &&
13301 		    (code->qual_code == sensep->es_qual_code))
13302 			return (1);
13303 	}
13304 	return (0);
13305 }
13306 
13307 /*
13308  * st_logpage_supported() sends a Log Sense command with
13309  * page code = 0 = Supported Log Pages Page to the device,
13310  * to see whether the page 'page' is supported.
13311  * Return values are:
13312  * -1 if the Log Sense command fails
13313  * 0 if page is not supported
13314  * 1 if page is supported
13315  */
13316 
13317 static int
13318 st_logpage_supported(struct scsi_tape *un, uchar_t page)
13319 {
13320 	uchar_t *sp, *sensep;
13321 	unsigned length;
13322 	struct uscsi_cmd *com;
13323 	struct scsi_arq_status status;
13324 	int rval;
13325 	char cdb[CDB_GROUP1] = {
13326 		SCMD_LOG_SENSE_G1,
13327 		0,
13328 		SUPPORTED_LOG_PAGES_PAGE,
13329 		0,
13330 		0,
13331 		0,
13332 		0,
13333 		0,
13334 		(char)LOG_SENSE_LENGTH,
13335 		0
13336 	};
13337 
13338 	ST_FUNC(ST_DEVINFO, st_logpage_supported);
13339 
13340 	ASSERT(mutex_owned(ST_MUTEX));
13341 
13342 	com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
13343 	sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP);
13344 
13345 	com->uscsi_cdb = cdb;
13346 	com->uscsi_cdblen = CDB_GROUP1;
13347 	com->uscsi_bufaddr = (caddr_t)sensep;
13348 	com->uscsi_buflen = LOG_SENSE_LENGTH;
13349 	com->uscsi_rqlen = sizeof (status);
13350 	com->uscsi_rqbuf = (caddr_t)&status;
13351 	com->uscsi_flags =
13352 	    USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ;
13353 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
13354 	rval = st_uscsi_cmd(un, com, FKIOCTL);
13355 	if (rval || com->uscsi_status) {
13356 		/* uscsi-command failed */
13357 		rval = -1;
13358 	} else {
13359 
13360 		sp = sensep + 3;
13361 
13362 		for (length = *sp++; length > 0; length--, sp++) {
13363 
13364 			if (*sp == page) {
13365 				rval = 1;
13366 				break;
13367 			}
13368 		}
13369 	}
13370 	kmem_free(com, sizeof (struct uscsi_cmd));
13371 	kmem_free(sensep, LOG_SENSE_LENGTH);
13372 	return (rval);
13373 }
13374 
13375 
13376 /*
13377  * st_check_clean_bit() gets the status of the tape's cleaning bit.
13378  *
13379  * If the device does support the TapeAlert log page, then the cleaning bit
13380  * information will be read from this page. Otherwise we will see if one of
13381  * ST_CLN_TYPE_1, ST_CLN_TYPE_2 or ST_CLN_TYPE_3 is set in the properties of
13382  * the device, which means, that we can get the cleaning bit information via
13383  * a RequestSense command.
13384  * If both methods of getting cleaning bit information are not supported
13385  * st_check_clean_bit() will return with 0. Otherwise st_check_clean_bit()
13386  * returns with
13387  * - MTF_TAPE_CLN_SUPPORTED if cleaning bit is not set or
13388  * - MTF_TAPE_CLN_SUPPORTED | MTF_TAPE_HEAD_DIRTY if cleaning bit is set.
13389  * If the call to st_uscsi_cmd() to do the Log Sense or the Request Sense
13390  * command fails, or if the amount of Request Sense data is not enough, then
13391  *  st_check_clean_bit() returns with -1.
13392  */
13393 
13394 static int
13395 st_check_clean_bit(struct scsi_tape *un)
13396 {
13397 	int rval = 0;
13398 
13399 	ST_FUNC(ST_DEVINFO, st_check_clean_bit);
13400 
13401 	ASSERT(mutex_owned(ST_MUTEX));
13402 
13403 	if (un->un_HeadClean & TAPE_ALERT_NOT_SUPPORTED) {
13404 		return (rval);
13405 	}
13406 
13407 	if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) {
13408 
13409 		rval = st_logpage_supported(un, TAPE_SEQUENTIAL_PAGE);
13410 		if (rval == -1) {
13411 			return (0);
13412 		}
13413 		if (rval == 1) {
13414 
13415 			un->un_HeadClean |= TAPE_SEQUENTIAL_SUPPORTED;
13416 		}
13417 
13418 		rval = st_logpage_supported(un, TAPE_ALERT_PAGE);
13419 		if (rval == -1) {
13420 			return (0);
13421 		}
13422 		if (rval == 1) {
13423 
13424 			un->un_HeadClean |= TAPE_ALERT_SUPPORTED;
13425 		}
13426 
13427 		if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) {
13428 
13429 			un->un_HeadClean = TAPE_ALERT_NOT_SUPPORTED;
13430 		}
13431 	}
13432 
13433 	rval = 0;
13434 
13435 	if (un->un_HeadClean & TAPE_SEQUENTIAL_SUPPORTED) {
13436 
13437 		rval = st_check_sequential_clean_bit(un);
13438 		if (rval == -1) {
13439 			return (0);
13440 		}
13441 	}
13442 
13443 	if ((rval == 0) && (un->un_HeadClean & TAPE_ALERT_SUPPORTED)) {
13444 
13445 		rval = st_check_alert_flags(un);
13446 		if (rval == -1) {
13447 			return (0);
13448 		}
13449 	}
13450 
13451 	if ((rval == 0) && (un->un_dp->options & ST_CLN_MASK)) {
13452 
13453 		rval = st_check_sense_clean_bit(un);
13454 		if (rval == -1) {
13455 			return (0);
13456 		}
13457 	}
13458 
13459 	/*
13460 	 * If found a supported means to check need to clean.
13461 	 */
13462 	if (rval & MTF_TAPE_CLN_SUPPORTED) {
13463 
13464 		/*
13465 		 * head needs to be cleaned.
13466 		 */
13467 		if (rval & MTF_TAPE_HEAD_DIRTY) {
13468 
13469 			/*
13470 			 * Print log message only first time
13471 			 * found needing cleaned.
13472 			 */
13473 			if ((un->un_HeadClean & TAPE_PREVIOUSLY_DIRTY) == 0) {
13474 
13475 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
13476 				    "Periodic head cleaning required");
13477 
13478 				un->un_HeadClean |= TAPE_PREVIOUSLY_DIRTY;
13479 			}
13480 
13481 		} else {
13482 
13483 			un->un_HeadClean &= ~TAPE_PREVIOUSLY_DIRTY;
13484 		}
13485 	}
13486 
13487 	return (rval);
13488 }
13489 
13490 
13491 static int
13492 st_check_sequential_clean_bit(struct scsi_tape *un)
13493 {
13494 	int rval;
13495 	int ix;
13496 	ushort_t parameter;
13497 	struct uscsi_cmd *cmd;
13498 	struct log_sequential_page *sp;
13499 	struct log_sequential_page_parameter *prm;
13500 	struct scsi_arq_status status;
13501 	char cdb[CDB_GROUP1] = {
13502 		SCMD_LOG_SENSE_G1,
13503 		0,
13504 		TAPE_SEQUENTIAL_PAGE | CURRENT_CUMULATIVE_VALUES,
13505 		0,
13506 		0,
13507 		0,
13508 		0,
13509 		(char)(sizeof (struct log_sequential_page) >> 8),
13510 		(char)(sizeof (struct log_sequential_page)),
13511 		0
13512 	};
13513 
13514 	ST_FUNC(ST_DEVINFO, st_check_sequential_clean_bit);
13515 
13516 	cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
13517 	sp  = kmem_zalloc(sizeof (struct log_sequential_page), KM_SLEEP);
13518 
13519 	cmd->uscsi_flags   =
13520 	    USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ;
13521 	cmd->uscsi_timeout = un->un_dp->non_motion_timeout;
13522 	cmd->uscsi_cdb	   = cdb;
13523 	cmd->uscsi_cdblen  = CDB_GROUP1;
13524 	cmd->uscsi_bufaddr = (caddr_t)sp;
13525 	cmd->uscsi_buflen  = sizeof (struct log_sequential_page);
13526 	cmd->uscsi_rqlen   = sizeof (status);
13527 	cmd->uscsi_rqbuf   = (caddr_t)&status;
13528 
13529 	rval = st_uscsi_cmd(un, cmd, FKIOCTL);
13530 
13531 	if (rval || cmd->uscsi_status || cmd->uscsi_resid) {
13532 
13533 		rval = -1;
13534 
13535 	} else if (sp->log_page.code != TAPE_SEQUENTIAL_PAGE) {
13536 
13537 		rval = -1;
13538 	}
13539 
13540 	prm = &sp->param[0];
13541 
13542 	for (ix = 0; rval == 0 && ix < TAPE_SEQUENTIAL_PAGE_PARA; ix++) {
13543 
13544 		if (prm->log_param.length == 0) {
13545 			break;
13546 		}
13547 
13548 		parameter = (((prm->log_param.pc_hi << 8) & 0xff00) +
13549 		    (prm->log_param.pc_lo & 0xff));
13550 
13551 		if (parameter == SEQUENTIAL_NEED_CLN) {
13552 
13553 			rval = MTF_TAPE_CLN_SUPPORTED;
13554 			if (prm->param_value[prm->log_param.length - 1]) {
13555 
13556 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13557 				    "sequential log says head dirty\n");
13558 				rval |= MTF_TAPE_HEAD_DIRTY;
13559 			}
13560 		}
13561 		prm = (struct log_sequential_page_parameter *)
13562 		    &prm->param_value[prm->log_param.length];
13563 	}
13564 
13565 	kmem_free(cmd, sizeof (struct uscsi_cmd));
13566 	kmem_free(sp,  sizeof (struct log_sequential_page));
13567 
13568 	return (rval);
13569 }
13570 
13571 
13572 static int
13573 st_check_alert_flags(struct scsi_tape *un)
13574 {
13575 	struct st_tape_alert *ta;
13576 	struct uscsi_cmd *com;
13577 	struct scsi_arq_status status;
13578 	unsigned ix, length;
13579 	int rval;
13580 	tape_alert_flags flag;
13581 	char cdb[CDB_GROUP1] = {
13582 		SCMD_LOG_SENSE_G1,
13583 		0,
13584 		TAPE_ALERT_PAGE | CURRENT_THRESHOLD_VALUES,
13585 		0,
13586 		0,
13587 		0,
13588 		0,
13589 		(char)(sizeof (struct st_tape_alert) >> 8),
13590 		(char)(sizeof (struct st_tape_alert)),
13591 		0
13592 	};
13593 
13594 	ST_FUNC(ST_DEVINFO, st_check_alert_clean_bit);
13595 
13596 	com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
13597 	ta  = kmem_zalloc(sizeof (struct st_tape_alert), KM_SLEEP);
13598 
13599 	com->uscsi_cdb = cdb;
13600 	com->uscsi_cdblen = CDB_GROUP1;
13601 	com->uscsi_bufaddr = (caddr_t)ta;
13602 	com->uscsi_buflen = sizeof (struct st_tape_alert);
13603 	com->uscsi_rqlen = sizeof (status);
13604 	com->uscsi_rqbuf = (caddr_t)&status;
13605 	com->uscsi_flags =
13606 	    USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ;
13607 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
13608 
13609 	rval = st_uscsi_cmd(un, com, FKIOCTL);
13610 
13611 	if (rval || com->uscsi_status || com->uscsi_resid) {
13612 
13613 		rval = -1; /* uscsi-command failed */
13614 
13615 	} else if (ta->log_page.code != TAPE_ALERT_PAGE) {
13616 
13617 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13618 		"Not Alert Log Page returned 0x%X\n", ta->log_page.code);
13619 		rval = -1;
13620 	}
13621 
13622 	length = (ta->log_page.length_hi << 8) + ta->log_page.length_lo;
13623 
13624 
13625 	if (length != TAPE_ALERT_PARAMETER_LENGTH) {
13626 
13627 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13628 		    "TapeAlert length %d\n", length);
13629 	}
13630 
13631 
13632 	for (ix = 0; ix < TAPE_ALERT_MAX_PARA; ix++) {
13633 
13634 		/*
13635 		 * if rval is bad before the first pass don't bother
13636 		 */
13637 		if (ix == 0 && rval != 0) {
13638 
13639 			break;
13640 		}
13641 
13642 		flag = ((ta->param[ix].log_param.pc_hi << 8) +
13643 		    ta->param[ix].log_param.pc_lo);
13644 
13645 		if ((ta->param[ix].param_value & 1) == 0) {
13646 			continue;
13647 		}
13648 		/*
13649 		 * check to see if current parameter is of interest.
13650 		 * CLEAN_FOR_ERRORS is vendor specific to 9840 9940 stk's.
13651 		 */
13652 		if ((flag == TAF_CLEAN_NOW) ||
13653 		    (flag == TAF_CLEAN_PERIODIC) ||
13654 		    ((flag == CLEAN_FOR_ERRORS) &&
13655 		    (un->un_dp->type == ST_TYPE_STK9840))) {
13656 
13657 			rval = MTF_TAPE_CLN_SUPPORTED;
13658 
13659 
13660 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13661 			    "alert_page drive needs clean %d\n", flag);
13662 			un->un_HeadClean |= TAPE_ALERT_STILL_DIRTY;
13663 			rval |= MTF_TAPE_HEAD_DIRTY;
13664 
13665 		} else if (flag == TAF_CLEANING_MEDIA) {
13666 
13667 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13668 			    "alert_page drive was cleaned\n");
13669 			un->un_HeadClean &= ~TAPE_ALERT_STILL_DIRTY;
13670 		}
13671 
13672 	}
13673 
13674 	/*
13675 	 * Report it as dirty till we see it cleaned
13676 	 */
13677 	if (un->un_HeadClean & TAPE_ALERT_STILL_DIRTY) {
13678 
13679 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13680 		    "alert_page still dirty\n");
13681 		rval |= MTF_TAPE_HEAD_DIRTY;
13682 	}
13683 
13684 	kmem_free(com, sizeof (struct uscsi_cmd));
13685 	kmem_free(ta,  sizeof (struct st_tape_alert));
13686 
13687 	return (rval);
13688 }
13689 
13690 
13691 static int
13692 st_check_sense_clean_bit(struct scsi_tape *un)
13693 {
13694 	uchar_t *sensep;
13695 	char cdb[CDB_GROUP0];
13696 	struct uscsi_cmd *com;
13697 	ushort_t byte_pos;
13698 	uchar_t bit_mask;
13699 	unsigned length;
13700 	int index;
13701 	int rval;
13702 
13703 	ST_FUNC(ST_DEVINFO, st_check_sense_clean_bit);
13704 
13705 	/*
13706 	 * Since this tape does not support Tape Alert,
13707 	 * we now try to get the cleanbit status via
13708 	 * Request Sense.
13709 	 */
13710 
13711 	if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_1) {
13712 
13713 		index = 0;
13714 
13715 	} else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_2) {
13716 
13717 		index = 1;
13718 
13719 	} else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_3) {
13720 
13721 		index = 2;
13722 
13723 	} else {
13724 
13725 		return (-1);
13726 	}
13727 
13728 	byte_pos  = st_cln_bit_position[index].cln_bit_byte;
13729 	bit_mask  = st_cln_bit_position[index].cln_bit_mask;
13730 	length = byte_pos + 1;
13731 
13732 	com    = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
13733 	sensep = kmem_zalloc(length, KM_SLEEP);
13734 
13735 	cdb[0] = SCMD_REQUEST_SENSE;
13736 	cdb[1] = 0;
13737 	cdb[2] = 0;
13738 	cdb[3] = 0;
13739 	cdb[4] = (char)length;
13740 	cdb[5] = 0;
13741 
13742 	com->uscsi_cdb = cdb;
13743 	com->uscsi_cdblen = CDB_GROUP0;
13744 	com->uscsi_bufaddr = (caddr_t)sensep;
13745 	com->uscsi_buflen = length;
13746 	com->uscsi_flags =
13747 	    USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ;
13748 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
13749 
13750 	rval = st_uscsi_cmd(un, com, FKIOCTL);
13751 
13752 	if (rval || com->uscsi_status || com->uscsi_resid) {
13753 
13754 		rval = -1;
13755 
13756 	} else {
13757 
13758 		rval = MTF_TAPE_CLN_SUPPORTED;
13759 		if ((sensep[byte_pos] & bit_mask) == bit_mask) {
13760 
13761 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13762 			    "sense data says head dirty\n");
13763 			rval |= MTF_TAPE_HEAD_DIRTY;
13764 		}
13765 	}
13766 
13767 	kmem_free(com, sizeof (struct uscsi_cmd));
13768 	kmem_free(sensep, length);
13769 	return (rval);
13770 }
13771 
13772 /*
13773  * st_clear_unit_attention
13774  *
13775  *  	run test unit ready's to clear out outstanding
13776  * 	unit attentions.
13777  * 	returns zero for SUCCESS or the errno from st_cmd call
13778  */
13779 static int
13780 st_clear_unit_attentions(dev_t dev_instance, int max_trys)
13781 {
13782 	int	i    = 0;
13783 	int	rval;
13784 
13785 	GET_SOFT_STATE(dev_instance);
13786 	ST_FUNC(ST_DEVINFO, st_clear_unit_attentions);
13787 
13788 	do {
13789 		rval = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
13790 	} while ((rval != 0) && (rval != ENXIO) && (++i < max_trys));
13791 	return (rval);
13792 }
13793 
13794 static void
13795 st_calculate_timeouts(struct scsi_tape *un)
13796 {
13797 	ST_FUNC(ST_DEVINFO, st_calculate_timeouts);
13798 
13799 	if (un->un_dp->non_motion_timeout == 0) {
13800 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
13801 			un->un_dp->non_motion_timeout =
13802 			    st_io_time * st_long_timeout_x;
13803 		} else {
13804 			un->un_dp->non_motion_timeout = (ushort_t)st_io_time;
13805 		}
13806 	}
13807 
13808 	if (un->un_dp->io_timeout == 0) {
13809 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
13810 			un->un_dp->io_timeout = st_io_time * st_long_timeout_x;
13811 		} else {
13812 			un->un_dp->io_timeout = (ushort_t)st_io_time;
13813 		}
13814 	}
13815 
13816 	if (un->un_dp->rewind_timeout == 0) {
13817 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
13818 			un->un_dp->rewind_timeout =
13819 			    st_space_time * st_long_timeout_x;
13820 		} else {
13821 			un->un_dp->rewind_timeout = (ushort_t)st_space_time;
13822 		}
13823 	}
13824 
13825 	if (un->un_dp->space_timeout == 0) {
13826 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
13827 			un->un_dp->space_timeout =
13828 			    st_space_time * st_long_timeout_x;
13829 		} else {
13830 			un->un_dp->space_timeout = (ushort_t)st_space_time;
13831 		}
13832 	}
13833 
13834 	if (un->un_dp->load_timeout == 0) {
13835 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
13836 			un->un_dp->load_timeout =
13837 			    st_space_time * st_long_timeout_x;
13838 		} else {
13839 			un->un_dp->load_timeout = (ushort_t)st_space_time;
13840 		}
13841 	}
13842 
13843 	if (un->un_dp->unload_timeout == 0) {
13844 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
13845 			un->un_dp->unload_timeout =
13846 			    st_space_time * st_long_timeout_x;
13847 		} else {
13848 			un->un_dp->unload_timeout = (ushort_t)st_space_time;
13849 		}
13850 	}
13851 
13852 	if (un->un_dp->erase_timeout == 0) {
13853 		if (un->un_dp->options & ST_LONG_ERASE) {
13854 			un->un_dp->erase_timeout =
13855 			    st_space_time * st_long_space_time_x;
13856 		} else {
13857 			un->un_dp->erase_timeout = (ushort_t)st_space_time;
13858 		}
13859 	}
13860 }
13861 
13862 
13863 static writablity
13864 st_is_not_wormable(struct scsi_tape *un)
13865 {
13866 	ST_FUNC(ST_DEVINFO, st_is_not_wormable);
13867 	return (RDWR);
13868 }
13869 
13870 static writablity
13871 st_is_hp_dat_tape_worm(struct scsi_tape *un)
13872 {
13873 	writablity wrt;
13874 
13875 	ST_FUNC(ST_DEVINFO, st_is_hp_dat_tape_worm);
13876 
13877 	/* Mode sense should be current */
13878 	if (un->un_mspl->media_type == 1) {
13879 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13880 		    "Drive has WORM media loaded\n");
13881 		wrt = WORM;
13882 	} else {
13883 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13884 		    "Drive has non WORM media loaded\n");
13885 		wrt = RDWR;
13886 	}
13887 	return (wrt);
13888 }
13889 
13890 #define	HP_DAT_INQUIRY 0x4A
13891 static writablity
13892 st_is_hp_dat_worm(struct scsi_tape *un)
13893 {
13894 	char *buf;
13895 	int result;
13896 	writablity wrt;
13897 
13898 	ST_FUNC(ST_DEVINFO, st_is_hp_dat_worm);
13899 
13900 	buf = kmem_zalloc(HP_DAT_INQUIRY, KM_SLEEP);
13901 
13902 	result = st_get_special_inquiry(un, HP_DAT_INQUIRY, buf, 0);
13903 
13904 	if (result != 0) {
13905 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13906 		    "Read Standard Inquiry for WORM support failed");
13907 		wrt = FAILED;
13908 	} else if ((buf[40] & 1) == 0) {
13909 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13910 		    "Drive is NOT WORMable\n");
13911 		/* This drive doesn't support it so don't check again */
13912 		un->un_dp->options &= ~ST_WORMABLE;
13913 		wrt = RDWR;
13914 		un->un_wormable = st_is_not_wormable;
13915 	} else {
13916 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13917 		    "Drive supports WORM version %d\n", buf[40] >> 1);
13918 		un->un_wormable = st_is_hp_dat_tape_worm;
13919 		wrt = un->un_wormable(un);
13920 	}
13921 
13922 	kmem_free(buf, HP_DAT_INQUIRY);
13923 
13924 	/*
13925 	 * If drive doesn't support it no point in checking further.
13926 	 */
13927 	return (wrt);
13928 }
13929 
13930 static writablity
13931 st_is_hp_lto_tape_worm(struct scsi_tape *un)
13932 {
13933 	writablity wrt;
13934 
13935 	ST_FUNC(ST_DEVINFO, st_is_hp_lto_tape_worm);
13936 
13937 	/* Mode sense should be current */
13938 	switch (un->un_mspl->media_type) {
13939 	case 0x00:
13940 		switch (un->un_mspl->density) {
13941 		case 0x40:
13942 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13943 			    "Drive has standard Gen I media loaded\n");
13944 			break;
13945 		case 0x42:
13946 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13947 			    "Drive has standard Gen II media loaded\n");
13948 			break;
13949 		case 0x44:
13950 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13951 			    "Drive has standard Gen III media loaded\n");
13952 			break;
13953 		case 0x46:
13954 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13955 			    "Drive has standard Gen IV media loaded\n");
13956 			break;
13957 		default:
13958 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13959 			    "Drive has standard unknown 0x%X media loaded\n",
13960 			    un->un_mspl->density);
13961 		}
13962 		wrt = RDWR;
13963 		break;
13964 	case 0x01:
13965 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13966 		    "Drive has WORM medium loaded\n");
13967 		wrt = WORM;
13968 		break;
13969 	case 0x80:
13970 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13971 		    "Drive has CD-ROM emulation medium loaded\n");
13972 		wrt = WORM;
13973 		break;
13974 	default:
13975 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
13976 		    "Drive has an unexpected medium type 0x%X loaded\n",
13977 		    un->un_mspl->media_type);
13978 		wrt = RDWR;
13979 	}
13980 
13981 	return (wrt);
13982 }
13983 
13984 #define	LTO_REQ_INQUIRY 44
13985 static writablity
13986 st_is_hp_lto_worm(struct scsi_tape *un)
13987 {
13988 	char *buf;
13989 	int result;
13990 	writablity wrt;
13991 
13992 	ST_FUNC(ST_DEVINFO, st_is_hp_lto_worm);
13993 
13994 	buf = kmem_zalloc(LTO_REQ_INQUIRY, KM_SLEEP);
13995 
13996 	result = st_get_special_inquiry(un, LTO_REQ_INQUIRY, buf, 0);
13997 
13998 	if (result != 0) {
13999 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14000 		    "Read Standard Inquiry for WORM support failed");
14001 		wrt = FAILED;
14002 	} else if ((buf[40] & 1) == 0) {
14003 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14004 		    "Drive is NOT WORMable\n");
14005 		/* This drive doesn't support it so don't check again */
14006 		un->un_dp->options &= ~ST_WORMABLE;
14007 		wrt = RDWR;
14008 		un->un_wormable = st_is_not_wormable;
14009 	} else {
14010 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14011 		    "Drive supports WORM version %d\n", buf[40] >> 1);
14012 		un->un_wormable = st_is_hp_lto_tape_worm;
14013 		wrt = un->un_wormable(un);
14014 	}
14015 
14016 	kmem_free(buf, LTO_REQ_INQUIRY);
14017 
14018 	/*
14019 	 * If drive doesn't support it no point in checking further.
14020 	 */
14021 	return (wrt);
14022 }
14023 
14024 static writablity
14025 st_is_t10_worm_device(struct scsi_tape *un)
14026 {
14027 	writablity wrt;
14028 
14029 	ST_FUNC(ST_DEVINFO, st_is_t10_worm_device);
14030 
14031 	if (un->un_mspl->media_type == 0x3c) {
14032 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14033 		    "Drive has WORM media loaded\n");
14034 		wrt = WORM;
14035 	} else {
14036 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14037 		    "Drive has non WORM media loaded\n");
14038 		wrt = RDWR;
14039 	}
14040 	return (wrt);
14041 }
14042 
14043 #define	SEQ_CAP_PAGE	(char)0xb0
14044 static writablity
14045 st_is_t10_worm(struct scsi_tape *un)
14046 {
14047 	char *buf;
14048 	int result;
14049 	writablity wrt;
14050 
14051 	ST_FUNC(ST_DEVINFO, st_is_t10_worm);
14052 
14053 	buf = kmem_zalloc(6, KM_SLEEP);
14054 
14055 	result = st_get_special_inquiry(un, 6, buf, SEQ_CAP_PAGE);
14056 
14057 	if (result != 0) {
14058 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14059 		    "Read Vitial Inquiry for Sequental Capability"
14060 		    " WORM support failed %x", result);
14061 		wrt = FAILED;
14062 	} else if ((buf[4] & 1) == 0) {
14063 		ASSERT(buf[1] == SEQ_CAP_PAGE);
14064 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14065 		    "Drive is NOT WORMable\n");
14066 		/* This drive doesn't support it so don't check again */
14067 		un->un_dp->options &= ~ST_WORMABLE;
14068 		wrt = RDWR;
14069 		un->un_wormable = st_is_not_wormable;
14070 	} else {
14071 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14072 		    "Drive supports WORM\n");
14073 		un->un_wormable = st_is_t10_worm_device;
14074 		wrt = un->un_wormable(un);
14075 	}
14076 
14077 	kmem_free(buf, 6);
14078 
14079 	return (wrt);
14080 }
14081 
14082 
14083 #define	STK_REQ_SENSE 26
14084 
14085 static writablity
14086 st_is_stk_worm(struct scsi_tape *un)
14087 {
14088 	char cdb[CDB_GROUP0] = {SCMD_REQUEST_SENSE, 0, 0, 0, STK_REQ_SENSE, 0};
14089 	struct scsi_extended_sense *sense;
14090 	struct uscsi_cmd *cmd;
14091 	char *buf;
14092 	int result;
14093 	writablity wrt;
14094 
14095 	ST_FUNC(ST_DEVINFO, st_is_stk_worm);
14096 
14097 	cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
14098 	buf = kmem_alloc(STK_REQ_SENSE, KM_SLEEP);
14099 	sense = (struct scsi_extended_sense *)buf;
14100 
14101 	cmd->uscsi_flags = USCSI_READ;
14102 	cmd->uscsi_timeout = un->un_dp->non_motion_timeout;
14103 	cmd->uscsi_cdb = &cdb[0];
14104 	cmd->uscsi_bufaddr = buf;
14105 	cmd->uscsi_buflen = STK_REQ_SENSE;
14106 	cmd->uscsi_cdblen = CDB_GROUP0;
14107 	cmd->uscsi_rqlen = 0;
14108 	cmd->uscsi_rqbuf = NULL;
14109 
14110 	result = st_uscsi_cmd(un, cmd, FKIOCTL);
14111 
14112 	if (result != 0 || cmd->uscsi_status != 0) {
14113 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14114 		    "Request Sense for WORM failed");
14115 		wrt = RDWR;
14116 	} else if (sense->es_add_len + 8 < 24) {
14117 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14118 		    "Drive didn't send enough sense data for WORM byte %d\n",
14119 		    sense->es_add_len + 8);
14120 		wrt = RDWR;
14121 		un->un_wormable = st_is_not_wormable;
14122 	} else if ((buf[24]) & 0x02) {
14123 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14124 		    "Drive has WORM tape loaded\n");
14125 		wrt = WORM;
14126 		un->un_wormable = st_is_stk_worm;
14127 	} else {
14128 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14129 		    "Drive has normal tape loaded\n");
14130 		wrt = RDWR;
14131 		un->un_wormable = st_is_stk_worm;
14132 	}
14133 
14134 	kmem_free(buf, STK_REQ_SENSE);
14135 	kmem_free(cmd, sizeof (struct uscsi_cmd));
14136 	return (wrt);
14137 }
14138 
14139 #define	DLT_INQ_SZ 44
14140 
14141 static writablity
14142 st_is_dlt_tape_worm(struct scsi_tape *un)
14143 {
14144 	caddr_t buf;
14145 	int result;
14146 	writablity wrt;
14147 
14148 	ST_FUNC(ST_DEVINFO, st_is_dlt_tape_worm);
14149 
14150 	buf = kmem_alloc(DLT_INQ_SZ, KM_SLEEP);
14151 
14152 	/* Read Attribute Media Type */
14153 
14154 	result = st_read_attributes(un, 0x0408, buf, 10, st_uscsi_cmd);
14155 
14156 	/*
14157 	 * If this quantum drive is attached via an HBA that cannot
14158 	 * support thr read attributes command return error in the
14159 	 * hope that someday they will support the t10 method.
14160 	 */
14161 	if (result == EINVAL && un->un_max_cdb_sz < CDB_GROUP4) {
14162 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
14163 		    "Read Attribute Command for WORM Media detection is not "
14164 		    "supported on the HBA that this drive is attached to.");
14165 		wrt = RDWR;
14166 		un->un_wormable = st_is_not_wormable;
14167 		goto out;
14168 	}
14169 
14170 	if (result != 0) {
14171 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14172 		    "Read Attribute Command for WORM Media returned 0x%x",
14173 		    result);
14174 		wrt = RDWR;
14175 		un->un_dp->options &= ~ST_WORMABLE;
14176 		goto out;
14177 	}
14178 
14179 	if ((uchar_t)buf[9] == 0x80) {
14180 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14181 		    "Drive media is WORM\n");
14182 		wrt = WORM;
14183 	} else {
14184 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14185 		    "Drive media is not WORM Media 0x%x\n", (uchar_t)buf[9]);
14186 		wrt = RDWR;
14187 	}
14188 
14189 out:
14190 	kmem_free(buf, DLT_INQ_SZ);
14191 	return (wrt);
14192 }
14193 
14194 static writablity
14195 st_is_dlt_worm(struct scsi_tape *un)
14196 {
14197 	caddr_t buf;
14198 	int result;
14199 	writablity wrt;
14200 
14201 	ST_FUNC(ST_DEVINFO, st_is_dlt_worm);
14202 
14203 	buf = kmem_alloc(DLT_INQ_SZ, KM_SLEEP);
14204 
14205 	result = st_get_special_inquiry(un, DLT_INQ_SZ, buf, 0xC0);
14206 
14207 	if (result != 0) {
14208 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14209 		    "Read Vendor Specific Inquiry for WORM support failed");
14210 		wrt = RDWR;
14211 		goto out;
14212 	}
14213 
14214 	if ((buf[2] & 1) == 0) {
14215 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14216 		    "Drive is not WORMable\n");
14217 		wrt = RDWR;
14218 		un->un_dp->options &= ~ST_WORMABLE;
14219 		un->un_wormable = st_is_not_wormable;
14220 		goto out;
14221 	} else {
14222 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14223 		    "Drive is WORMable\n");
14224 		un->un_wormable = st_is_dlt_tape_worm;
14225 		wrt = un->un_wormable(un);
14226 	}
14227 out:
14228 	kmem_free(buf, DLT_INQ_SZ);
14229 
14230 	return (wrt);
14231 }
14232 
14233 typedef struct {
14234 	struct modeheader_seq header;
14235 #if defined(_BIT_FIELDS_LTOH) /* X86 */
14236 	uchar_t pagecode	:6,
14237 				:2;
14238 	uchar_t page_len;
14239 	uchar_t syslogalive	:2,
14240 		device		:1,
14241 		abs		:1,
14242 		ulpbot		:1,
14243 		prth		:1,
14244 		ponej		:1,
14245 		ait		:1;
14246 	uchar_t span;
14247 
14248 	uchar_t			:6,
14249 		worm		:1,
14250 		mic		:1;
14251 	uchar_t worm_cap	:1,
14252 				:7;
14253 	uint32_t		:32;
14254 #else /* SPARC */
14255 	uchar_t			:2,
14256 		pagecode	:6;
14257 	uchar_t page_len;
14258 	uchar_t ait		:1,
14259 		device		:1,
14260 		abs		:1,
14261 		ulpbot		:1,
14262 		prth		:1,
14263 		ponej		:1,
14264 		syslogalive	:2;
14265 	uchar_t span;
14266 	uchar_t mic		:1,
14267 		worm		:1,
14268 				:6;
14269 	uchar_t			:7,
14270 		worm_cap	:1;
14271 	uint32_t		:32;
14272 #endif
14273 }ait_dev_con;
14274 
14275 #define	AIT_DEV_PAGE 0x31
14276 static writablity
14277 st_is_sony_worm(struct scsi_tape *un)
14278 {
14279 	int result;
14280 	writablity wrt;
14281 	ait_dev_con *ait_conf;
14282 
14283 	ST_FUNC(ST_DEVINFO, st_is_sony_worm);
14284 
14285 	ait_conf = kmem_zalloc(sizeof (ait_dev_con), KM_SLEEP);
14286 
14287 	result = st_gen_mode_sense(un, st_uscsi_cmd, AIT_DEV_PAGE,
14288 	    (struct seq_mode *)ait_conf, sizeof (ait_dev_con));
14289 
14290 	if (result == 0) {
14291 
14292 		if (ait_conf->pagecode != AIT_DEV_PAGE) {
14293 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14294 			    "returned page 0x%x not 0x%x AIT_DEV_PAGE\n",
14295 			    ait_conf->pagecode, AIT_DEV_PAGE);
14296 			wrt = RDWR;
14297 			un->un_wormable = st_is_not_wormable;
14298 
14299 		} else if (ait_conf->worm_cap) {
14300 
14301 			un->un_wormable = st_is_sony_worm;
14302 
14303 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14304 			    "Drives is WORMable\n");
14305 			if (ait_conf->worm) {
14306 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14307 				    "Media is WORM\n");
14308 				wrt = WORM;
14309 			} else {
14310 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14311 				    "Media is not WORM\n");
14312 				wrt = RDWR;
14313 			}
14314 
14315 		} else {
14316 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14317 			    "Drives not is WORMable\n");
14318 			wrt = RDWR;
14319 			/* No further checking required */
14320 			un->un_dp->options &= ~ST_WORMABLE;
14321 		}
14322 
14323 	} else {
14324 
14325 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14326 		    "AIT device config mode sense page read command failed"
14327 		    " result = %d ", result);
14328 		wrt = FAILED;
14329 		un->un_wormable = st_is_not_wormable;
14330 	}
14331 
14332 	kmem_free(ait_conf, sizeof (ait_dev_con));
14333 	return (wrt);
14334 }
14335 
14336 static writablity
14337 st_is_drive_worm(struct scsi_tape *un)
14338 {
14339 	writablity wrt;
14340 
14341 	ST_FUNC(ST_DEVINFO, st_is_sony_worm);
14342 
14343 	switch (un->un_dp->type) {
14344 	case MT_ISDLT:
14345 		wrt = st_is_dlt_worm(un);
14346 		break;
14347 
14348 	case MT_ISSTK9840:
14349 		wrt = st_is_stk_worm(un);
14350 		break;
14351 
14352 	case MT_IS8MM:
14353 	case MT_ISAIT:
14354 		wrt = st_is_sony_worm(un);
14355 		break;
14356 
14357 	case MT_LTO:
14358 		if (strncmp("HP ", un->un_dp->vid, 3) == 0) {
14359 			wrt = st_is_hp_lto_worm(un);
14360 		} else {
14361 			wrt = st_is_t10_worm(un);
14362 		}
14363 		break;
14364 
14365 	case MT_ISDAT:
14366 		if (strncmp("HP ", un->un_dp->vid, 3) == 0) {
14367 			wrt = st_is_hp_dat_worm(un);
14368 		} else {
14369 			wrt = st_is_t10_worm(un);
14370 		}
14371 		break;
14372 
14373 	default:
14374 		wrt = FAILED;
14375 		break;
14376 	}
14377 
14378 	/*
14379 	 * If any of the above failed try the t10 standard method.
14380 	 */
14381 	if (wrt == FAILED) {
14382 		wrt = st_is_t10_worm(un);
14383 	}
14384 
14385 	/*
14386 	 * Unknown method for detecting WORM media.
14387 	 */
14388 	if (wrt == FAILED) {
14389 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14390 		    "Unknown method for WORM media detection\n");
14391 		wrt = RDWR;
14392 		un->un_dp->options &= ~ST_WORMABLE;
14393 	}
14394 
14395 	return (wrt);
14396 }
14397 
14398 static int
14399 st_read_attributes(struct scsi_tape *un, uint16_t attribute, void *pnt,
14400     size_t size, ubufunc_t bufunc)
14401 {
14402 	char cdb[CDB_GROUP4];
14403 	int result;
14404 	struct uscsi_cmd *cmd;
14405 	struct scsi_arq_status status;
14406 
14407 	caddr_t buf = (caddr_t)pnt;
14408 
14409 	ST_FUNC(ST_DEVINFO, st_read_attributes);
14410 
14411 	if (un->un_sd->sd_inq->inq_ansi < 3) {
14412 		return (ENOTTY);
14413 	}
14414 
14415 	cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
14416 
14417 	cdb[0] = (char)SCMD_READ_ATTRIBUTE;
14418 	cdb[1] = 0;
14419 	cdb[2] = 0;
14420 	cdb[3] = 0;
14421 	cdb[4] = 0;
14422 	cdb[5] = 0;
14423 	cdb[6] = 0;
14424 	cdb[7] = 0;
14425 	cdb[8] = (char)(attribute >> 8);
14426 	cdb[9] = (char)(attribute);
14427 	cdb[10] = (char)(size >> 24);
14428 	cdb[11] = (char)(size >> 16);
14429 	cdb[12] = (char)(size >> 8);
14430 	cdb[13] = (char)(size);
14431 	cdb[14] = 0;
14432 	cdb[15] = 0;
14433 
14434 
14435 	cmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE | USCSI_DIAGNOSE;
14436 	cmd->uscsi_timeout = un->un_dp->non_motion_timeout;
14437 	cmd->uscsi_cdb = &cdb[0];
14438 	cmd->uscsi_bufaddr = (caddr_t)buf;
14439 	cmd->uscsi_buflen = size;
14440 	cmd->uscsi_cdblen = sizeof (cdb);
14441 	cmd->uscsi_rqlen = sizeof (status);
14442 	cmd->uscsi_rqbuf = (caddr_t)&status;
14443 
14444 	result = bufunc(un, cmd, FKIOCTL);
14445 
14446 	if (result != 0 || cmd->uscsi_status != 0) {
14447 		ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
14448 		    "st_read_attribute failed: result %d status %d\n",
14449 		    result, cmd->uscsi_status);
14450 		/*
14451 		 * If this returns invalid operation code don't try again.
14452 		 */
14453 		if (un->un_sd->sd_sense->es_key == KEY_ILLEGAL_REQUEST &&
14454 		    un->un_sd->sd_sense->es_add_code == 0x20) {
14455 			result = ENOTTY;
14456 		} else if (result == 0) {
14457 			result = EIO;
14458 		}
14459 
14460 	} else {
14461 
14462 		/*
14463 		 * The attribute retured should match the attribute requested.
14464 		 */
14465 		if (buf[4] != cdb[8] || buf[5] != cdb[9]) {
14466 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
14467 			    "st_read_attribute got wrong data back expected "
14468 			    "0x%x got 0x%x\n", attribute, buf[6] << 8 | buf[7]);
14469 			st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
14470 			    "bad? data", buf, size);
14471 			result = EIO;
14472 		}
14473 	}
14474 
14475 	kmem_free(cmd, sizeof (struct uscsi_cmd));
14476 
14477 	return (result);
14478 }
14479 
14480 static int
14481 st_get_special_inquiry(struct scsi_tape *un, uchar_t size, caddr_t dest,
14482     uchar_t page)
14483 {
14484 	char cdb[CDB_GROUP0];
14485 	struct scsi_extended_sense *sense;
14486 	struct uscsi_cmd *cmd;
14487 	int result;
14488 
14489 	ST_FUNC(ST_DEVINFO, st_get_special_inquiry);
14490 
14491 	cdb[0] = SCMD_INQUIRY;
14492 	cdb[1] = page ? 1 : 0;
14493 	cdb[2] = page;
14494 	cdb[3] = 0;
14495 	cdb[4] = size;
14496 	cdb[5] = 0;
14497 
14498 	cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
14499 	sense = kmem_alloc(sizeof (struct scsi_extended_sense), KM_SLEEP);
14500 
14501 	cmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE;
14502 	cmd->uscsi_timeout = un->un_dp->non_motion_timeout;
14503 	cmd->uscsi_cdb = &cdb[0];
14504 	cmd->uscsi_bufaddr = dest;
14505 	cmd->uscsi_buflen = size;
14506 	cmd->uscsi_cdblen = CDB_GROUP0;
14507 	cmd->uscsi_rqlen = sizeof (struct scsi_extended_sense);
14508 	cmd->uscsi_rqbuf = (caddr_t)sense;
14509 
14510 	result = st_uscsi_cmd(un, cmd, FKIOCTL);
14511 
14512 	if (result != 0 || cmd->uscsi_status != 0) {
14513 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
14514 		    "st_get_special_inquiry() failed for page %x", page);
14515 		if (result == 0) {
14516 			result = EIO;
14517 		}
14518 	}
14519 
14520 	kmem_free(sense, sizeof (struct scsi_extended_sense));
14521 	kmem_free(cmd, sizeof (struct uscsi_cmd));
14522 
14523 	return (result);
14524 }
14525 
14526 
14527 static int
14528 st_update_block_pos(struct scsi_tape *un, bufunc_t bf, int post_space)
14529 {
14530 	int rval = ENOTTY;
14531 	uchar_t status = un->un_status;
14532 	posmode previous_pmode = un->un_running.pmode;
14533 
14534 	ST_FUNC(ST_DEVINFO, st_update_block_pos);
14535 
14536 	while (un->un_read_pos_type != NO_POS) {
14537 		rval = bf(un, SCMD_READ_POSITION, 32, SYNC_CMD);
14538 
14539 		/*
14540 		 * If read position command returned good status
14541 		 * Parse the data to see if the position can be interpreted.
14542 		 */
14543 		if ((rval == 0) &&
14544 		    ((rval = st_interpret_read_pos(un, &un->un_pos,
14545 		    un->un_read_pos_type, 32, (caddr_t)un->un_read_pos_data,
14546 		    post_space)) == 0)) {
14547 			/*
14548 			 * Update the running position as well if un_pos was
14549 			 * ok. But only if recovery is enabled.
14550 			 */
14551 			if (st_recov_sz != sizeof (recov_info)) {
14552 				break;
14553 			}
14554 			rval = st_interpret_read_pos(un, &un->un_running,
14555 			    un->un_read_pos_type, 32,
14556 			    (caddr_t)un->un_read_pos_data, post_space);
14557 			un->un_status = status;
14558 			break;
14559 		} else if (un->un_status == KEY_UNIT_ATTENTION) {
14560 			un->un_running.pmode = previous_pmode;
14561 			continue;
14562 		} else if (un->un_status != KEY_ILLEGAL_REQUEST) {
14563 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
14564 			    "st_update_block_pos() read position cmd 0x%x"
14565 			    " returned 0x%x un_status = %d",
14566 			    un->un_read_pos_type, rval, un->un_status);
14567 			/* ENOTTY means it read garbage. try something else. */
14568 			if (rval == ENOTTY) {
14569 				rval = EIO; /* so ENOTTY is not final rval */
14570 			} else {
14571 				break;
14572 			}
14573 		} else {
14574 			ST_DEBUG4(ST_DEVINFO, st_label, CE_NOTE,
14575 			    "st_update_block_pos() read position cmd %x"
14576 			    " returned %x", un->un_read_pos_type, rval);
14577 			un->un_running.pmode = previous_pmode;
14578 		}
14579 
14580 		switch (un->un_read_pos_type) {
14581 		case SHORT_POS:
14582 			un->un_read_pos_type = NO_POS;
14583 			break;
14584 
14585 		case LONG_POS:
14586 			un->un_read_pos_type = EXT_POS;
14587 			break;
14588 
14589 		case EXT_POS:
14590 			un->un_read_pos_type = SHORT_POS;
14591 			break;
14592 
14593 		default:
14594 			ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
14595 			    "Unexpected read position type 0x%x",
14596 			    un->un_read_pos_type);
14597 		}
14598 		un->un_status = KEY_NO_SENSE;
14599 	}
14600 
14601 	return (rval);
14602 }
14603 
14604 static int
14605 st_get_read_pos(struct scsi_tape *un, buf_t *bp)
14606 {
14607 	int result;
14608 	size_t d_sz;
14609 	caddr_t pos_info;
14610 	struct uscsi_cmd *cmd = (struct uscsi_cmd *)bp->b_back;
14611 
14612 	ST_FUNC(ST_DEVINFO, st_get_read_pos);
14613 
14614 	if (cmd->uscsi_bufaddr == NULL || cmd->uscsi_buflen <= 0) {
14615 		return (0);
14616 	}
14617 
14618 	if (bp_mapin_common(bp, VM_NOSLEEP) == NULL) {
14619 
14620 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
14621 		    "bp_mapin_common() failed");
14622 
14623 		return (EIO);
14624 	}
14625 
14626 	d_sz = bp->b_bcount - bp->b_resid;
14627 	if (d_sz == 0) {
14628 		bp_mapout(bp);
14629 		return (EIO);
14630 	}
14631 
14632 	/*
14633 	 * Copy the buf to a double-word aligned memory that can hold the
14634 	 * tape_position_t data structure.
14635 	 */
14636 	if ((pos_info = kmem_alloc(d_sz, KM_NOSLEEP)) == NULL) {
14637 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
14638 		    "kmem_alloc() failed");
14639 		bp_mapout(bp);
14640 		return (EIO);
14641 	}
14642 	bcopy(bp->b_un.b_addr, pos_info, d_sz);
14643 
14644 #ifdef STDEBUG
14645 	if ((st_debug & 0x7) > 2) {
14646 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
14647 		    "st_get_read_pos() position info",
14648 		    pos_info, bp->b_bcount);
14649 	}
14650 #endif
14651 
14652 	result = st_interpret_read_pos(un, &un->un_pos, cmd->uscsi_cdb[1],
14653 	    d_sz, pos_info, 0);
14654 
14655 	COPY_POS(&un->un_running, &un->un_pos);
14656 
14657 	kmem_free(pos_info, d_sz);
14658 	bp_mapout(bp);
14659 
14660 	return (result);
14661 }
14662 
14663 #if defined(_BIG_ENDIAN)
14664 
14665 #define	FIX_ENDIAN16(x)
14666 #define	FIX_ENDIAN32(x)
14667 #define	FIX_ENDIAN64(x)
14668 
14669 #elif defined(_LITTLE_ENDIAN)
14670 
14671 static void
14672 st_swap16(uint16_t *val)
14673 {
14674 	uint16_t tmp;
14675 
14676 	tmp = (*val >>  8) & 0xff;
14677 	tmp |= (*val <<  8) & 0xff00;
14678 
14679 	*val = tmp;
14680 }
14681 
14682 static void
14683 st_swap32(uint32_t *val)
14684 {
14685 	uint32_t tmp;
14686 
14687 	tmp =  (*val >> 24) & 0xff;
14688 	tmp |= (*val >>  8) & 0xff00;
14689 	tmp |= (*val <<  8) & 0xff0000;
14690 	tmp |= (*val << 24) & 0xff000000;
14691 
14692 	*val = tmp;
14693 }
14694 
14695 static void
14696 st_swap64(uint64_t *val)
14697 {
14698 	uint32_t low;
14699 	uint32_t high;
14700 
14701 	low =  (uint32_t)(*val);
14702 	high = (uint32_t)(*val >> 32);
14703 
14704 	st_swap32(&low);
14705 	st_swap32(&high);
14706 
14707 	*val =  high;
14708 	*val |= ((uint64_t)low << 32);
14709 }
14710 
14711 #define	FIX_ENDIAN16(x) st_swap16(x)
14712 #define	FIX_ENDIAN32(x) st_swap32(x)
14713 #define	FIX_ENDIAN64(x) st_swap64(x)
14714 #endif
14715 
14716 /*
14717  * st_interpret_read_pos()
14718  *
14719  * Returns:
14720  *	0	If secsessful.
14721  *	EIO	If read postion responce data was unuseable or invalid.
14722  *	ERANGE	If the position of the drive is too large for the read_p_type.
14723  *	ENOTTY	If the responce data looks invalid for the read position type.
14724  */
14725 
14726 static int
14727 st_interpret_read_pos(struct scsi_tape const *un, tapepos_t *dest,
14728     read_p_types type, size_t data_sz, const caddr_t responce, int post_space)
14729 {
14730 	int rval = 0;
14731 	int flag = 0;
14732 	tapepos_t org;
14733 
14734 	ST_FUNC(ST_DEVINFO, st_interpret_read_pos);
14735 
14736 	/*
14737 	 * We expect the position value to change after a space command.
14738 	 * So if post_space is set we don't print out what has changed.
14739 	 */
14740 	if ((dest != &un->un_pos) && (post_space == 0) &&
14741 	    (st_recov_sz == sizeof (recov_info))) {
14742 		COPY_POS(&org, dest);
14743 		flag = 1;
14744 	}
14745 
14746 	/*
14747 	 * See what kind of read position was requested.
14748 	 */
14749 	switch (type) {
14750 
14751 	case SHORT_POS: /* Short data format */
14752 	{
14753 		tape_position_t *pos_info = (tape_position_t *)responce;
14754 		uint32_t value;
14755 
14756 		/* If reserved fields are non zero don't use the data */
14757 		if (pos_info->reserved0 || pos_info->reserved1 ||
14758 		    pos_info->reserved2[0] || pos_info->reserved2[1] ||
14759 		    pos_info->reserved3) {
14760 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14761 			    "Invalid Read Short Position Data returned\n");
14762 			rval = EIO;
14763 			break;
14764 		}
14765 		/*
14766 		 * Position is to large to use this type of read position.
14767 		 */
14768 		if (pos_info->posi_err == 1) {
14769 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14770 			    "Drive reported position error\n");
14771 			rval = ERANGE;
14772 			break;
14773 		}
14774 		/*
14775 		 * If your at the begining of partition and end at the same
14776 		 * time it's very small partition or bad data.
14777 		 */
14778 		if (pos_info->begin_of_part && pos_info->end_of_part) {
14779 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14780 			    "SHORT_POS returned begin and end of"
14781 			    " partition\n");
14782 			rval = EIO;
14783 			break;
14784 		}
14785 
14786 		if (pos_info->blk_posi_unkwn == 0) {
14787 
14788 			value = pos_info->host_block;
14789 			FIX_ENDIAN32(&value);
14790 
14791 			/*
14792 			 * If the tape is rewound the host blcok should be 0.
14793 			 */
14794 			if ((pos_info->begin_of_part == 1) &&
14795 			    (value != 0)) {
14796 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14797 				    "SHORT_POS returned begin of partition"
14798 				    " but host block was 0x%x\n", value);
14799 				rval = EIO;
14800 				break;
14801 			}
14802 
14803 			if (dest->lgclblkno != value) {
14804 				if (flag)
14805 					flag++;
14806 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14807 				    "SHORT_POS current logical 0x%"PRIx64" read"
14808 				    " 0x%x\n", dest->lgclblkno, value);
14809 			}
14810 
14811 			dest->lgclblkno = (uint64_t)value;
14812 
14813 			/*
14814 			 * If the begining of partition is true and the
14815 			 * block number is zero we will beleive that it is
14816 			 * rewound. Promote the pmode to legacy.
14817 			 */
14818 			if ((pos_info->begin_of_part == 1) &&
14819 			    (value == 0)) {
14820 				dest->blkno = 0;
14821 				dest->fileno = 0;
14822 				if (dest->pmode != legacy)
14823 					dest->pmode = legacy;
14824 			/*
14825 			 * otherwise if the pmode was invalid,
14826 			 * promote it to logical.
14827 			 */
14828 			} else if (dest->pmode == invalid) {
14829 				dest->pmode = logical;
14830 			}
14831 
14832 			if (dest->partition != pos_info->partition_number) {
14833 				if (flag)
14834 					flag++;
14835 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14836 				    "SHORT_POS current partition %d read %d\n",
14837 				    dest->partition,
14838 				    pos_info->partition_number);
14839 			}
14840 
14841 			dest->partition = pos_info->partition_number;
14842 
14843 		} else {
14844 			dest->pmode = invalid;
14845 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14846 			    "Tape drive reported block position as unknown\n");
14847 		}
14848 		break;
14849 	}
14850 
14851 	case LONG_POS: /* Long data format */
14852 	{
14853 		uint64_t value;
14854 		tape_position_long_t *long_pos_info =
14855 		    (tape_position_long_t *)responce;
14856 
14857 		/* If reserved fields are non zero don't use the data */
14858 		if ((long_pos_info->reserved0) ||
14859 		    (long_pos_info->reserved1) ||
14860 		    (long_pos_info->reserved2)) {
14861 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14862 			    "Invalid Read Long Position Data returned\n");
14863 			rval = ENOTTY;
14864 			break;
14865 		}
14866 
14867 		/* Is position Valid */
14868 		if (long_pos_info->blk_posi_unkwn == 0) {
14869 			uint32_t part;
14870 
14871 			value = long_pos_info->block_number;
14872 			FIX_ENDIAN64(&value);
14873 
14874 			/*
14875 			 * If it says we are at the begining of partition
14876 			 * the block value better be 0.
14877 			 */
14878 			if ((long_pos_info->begin_of_part == 1) &&
14879 			    (value != 0)) {
14880 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14881 				    "LONG_POS returned begin of partition but"
14882 				    " block number was 0x%"PRIx64"\n", value);
14883 				rval = ENOTTY;
14884 				break;
14885 			}
14886 			/*
14887 			 * Can't be at the start and the end of the partition
14888 			 * at the same time if the partition is larger the 0.
14889 			 */
14890 			if (long_pos_info->begin_of_part &&
14891 			    long_pos_info->end_of_part) {
14892 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14893 				    "LONG_POS returned begin and end of"
14894 				    " partition\n");
14895 				rval = ENOTTY;
14896 				break;
14897 			}
14898 
14899 			/*
14900 			 * If the logical block number is not what we expected.
14901 			 */
14902 			if (dest->lgclblkno != value) {
14903 				if (flag)
14904 					flag++;
14905 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14906 				    "LONG_POS current logical 0x%"PRIx64
14907 				    " read 0x%"PRIx64"\n",
14908 				    dest->lgclblkno, value);
14909 			}
14910 			dest->lgclblkno = value;
14911 
14912 			/*
14913 			 * If the begining of partition is true and the
14914 			 * block number is zero we will beleive that it is
14915 			 * rewound. Promote the pmode to legacy.
14916 			 */
14917 			if ((long_pos_info->begin_of_part == 1) &&
14918 			    (long_pos_info->block_number == 0)) {
14919 				dest->blkno = 0;
14920 				dest->fileno = 0;
14921 				if (dest->pmode != legacy)
14922 					dest->pmode = legacy;
14923 			/*
14924 			 * otherwise if the pmode was invalid,
14925 			 * promote it to logical.
14926 			 */
14927 			} else if (dest->pmode == invalid) {
14928 				dest->pmode = logical;
14929 			}
14930 
14931 			part = long_pos_info->partition;
14932 			FIX_ENDIAN32(&part);
14933 			if (dest->partition != part) {
14934 				if (flag)
14935 					flag++;
14936 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14937 				    "LONG_POS current partition %d"
14938 				    " read %d\n", dest->partition, part);
14939 			}
14940 			dest->partition = part;
14941 		} else {
14942 			/*
14943 			 * If the drive doesn't know location,
14944 			 * we don't either.
14945 			 */
14946 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14947 			    "Tape drive reported block position as unknown\n");
14948 			dest->pmode = invalid;
14949 		}
14950 
14951 		/* Is file position valid */
14952 		if (long_pos_info->mrk_posi_unkwn == 0) {
14953 			value = long_pos_info->file_number;
14954 			FIX_ENDIAN64(&value);
14955 			/*
14956 			 * If it says we are at the begining of partition
14957 			 * the block value better be 0.
14958 			 */
14959 			if ((long_pos_info->begin_of_part == 1) &&
14960 			    (value != 0)) {
14961 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14962 				    "LONG_POS returned begin of partition but"
14963 				    " block number was 0x%"PRIx64"\n", value);
14964 				rval = ENOTTY;
14965 				break;
14966 			}
14967 			if (((dest->pmode == legacy) ||
14968 			    (dest->pmode == logical)) &&
14969 			    (dest->fileno != value)) {
14970 				if (flag)
14971 					flag++;
14972 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
14973 				    "LONG_POS fileno 0x%"PRIx64
14974 				    " not un_pos %x\n", value,
14975 				    dest->fileno);
14976 			} else if (dest->pmode == invalid) {
14977 				dest->pmode = logical;
14978 			}
14979 			dest->fileno = (int32_t)value;
14980 		}
14981 
14982 		if (dest->pmode != invalid && long_pos_info->end_of_part) {
14983 			dest->eof = ST_EOT;
14984 		}
14985 
14986 		break;
14987 	}
14988 
14989 	case EXT_POS: /* Extended data format */
14990 	{
14991 		uint64_t value;
14992 		uint16_t len;
14993 		tape_position_ext_t *ext_pos_info =
14994 		    (tape_position_ext_t *)responce;
14995 
14996 		/* Make sure that there is enough data there */
14997 		if (data_sz < 16) {
14998 			break;
14999 		}
15000 
15001 		/* If reserved fields are non zero don't use the data */
15002 		if (ext_pos_info->reserved0 || ext_pos_info->reserved1) {
15003 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
15004 			    "EXT_POS reserved fields not zero\n");
15005 			rval = ENOTTY;
15006 			break;
15007 		}
15008 
15009 		/*
15010 		 * In the unlikely event of overflowing 64 bits of position.
15011 		 */
15012 		if (ext_pos_info->posi_err != 0) {
15013 			rval = ERANGE;
15014 			break;
15015 		}
15016 
15017 		len = ext_pos_info->parameter_len;
15018 		FIX_ENDIAN16(&len);
15019 
15020 		if (len != 0x1c) {
15021 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
15022 			    "EXT_POS parameter_len should be 0x1c was 0x%x\n",
15023 			    len);
15024 			rval = ENOTTY;
15025 			break;
15026 		}
15027 
15028 		/* Is block position information valid */
15029 		if (ext_pos_info->blk_posi_unkwn == 0) {
15030 
15031 			value = ext_pos_info->host_block;
15032 			FIX_ENDIAN64(&value);
15033 			if ((ext_pos_info->begin_of_part == 1) &&
15034 			    (value != 0)) {
15035 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
15036 				    "EXT_POS returned begining of partition but"
15037 				    " the host block was 0x%"PRIx64"\n", value);
15038 				rval = ENOTTY;
15039 				break;
15040 			}
15041 
15042 			if (dest->lgclblkno != value) {
15043 				if (flag)
15044 					flag++;
15045 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
15046 				    "EXT_POS current logical 0x%"PRIx64
15047 				    " read 0x%"PRIx64"\n",
15048 				    dest->lgclblkno, value);
15049 			}
15050 			dest->lgclblkno = value;
15051 
15052 			/*
15053 			 * If the begining of partition is true and the
15054 			 * block number is zero we will beleive that it is
15055 			 * rewound. Promote the pmode to legacy.
15056 			 */
15057 			if ((ext_pos_info->begin_of_part == 1) &&
15058 			    (ext_pos_info->host_block == 0)) {
15059 				dest->blkno = 0;
15060 				dest->fileno = 0;
15061 				if (dest->pmode != legacy) {
15062 					dest->pmode = legacy;
15063 				}
15064 			/*
15065 			 * otherwise if the pmode was invalid,
15066 			 * promote it to logical.
15067 			 */
15068 			} else if (dest->pmode == invalid) {
15069 				dest->pmode = logical;
15070 			}
15071 
15072 			if (dest->partition != ext_pos_info->partition) {
15073 				if (flag)
15074 					flag++;
15075 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
15076 				    "EXT_POS current partition %d read %d\n",
15077 				    dest->partition,
15078 				    ext_pos_info->partition);
15079 			}
15080 			dest->partition = ext_pos_info->partition;
15081 
15082 		} else {
15083 			dest->pmode = invalid;
15084 		}
15085 		break;
15086 	}
15087 
15088 	default:
15089 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
15090 		    "Got unexpected SCMD_READ_POSITION type %d\n", type);
15091 		rval = EIO;
15092 	}
15093 
15094 	if ((flag > 1) && (rval == 0) && (org.pmode != invalid)) {
15095 		st_print_position(ST_DEVINFO, st_label, CE_NOTE,
15096 		    "position read in", &org);
15097 		st_print_position(ST_DEVINFO, st_label, CE_NOTE,
15098 		    "position read out", dest);
15099 	}
15100 
15101 	return (rval);
15102 }
15103 
15104 static int
15105 st_logical_block_locate(struct scsi_tape *un, ubufunc_t ubf, tapepos_t *pos,
15106     uint64_t lblk, uchar_t partition)
15107 {
15108 	int rval;
15109 	char cdb[CDB_GROUP4];
15110 	struct uscsi_cmd *cmd;
15111 	struct scsi_extended_sense sense;
15112 	bufunc_t bf = (ubf == st_uscsi_cmd) ? st_cmd : st_rcmd;
15113 
15114 	ST_FUNC(ST_DEVINFO, st_logical_block_locate);
15115 	/*
15116 	 * Not sure what to do when doing recovery and not wanting
15117 	 * to update un_pos
15118 	 */
15119 
15120 	cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
15121 
15122 	if (lblk <= INT32_MAX) {
15123 		cmd->uscsi_cdblen = CDB_GROUP1;
15124 		cdb[0] = SCMD_LOCATE;
15125 		cdb[1] = pos->partition == partition ? 0 : 2;
15126 		cdb[2] = 0;
15127 		cdb[3] = (char)(lblk >> 24);
15128 		cdb[4] = (char)(lblk >> 16);
15129 		cdb[5] = (char)(lblk >> 8);
15130 		cdb[6] = (char)(lblk);
15131 		cdb[7] = 0;
15132 		cdb[8] = partition;
15133 		cdb[9] = 0;
15134 	} else {
15135 		/*
15136 		 * If the drive doesn't give a 64 bit read position data
15137 		 * it is unlikely it will accept 64 bit locates.
15138 		 */
15139 		if (un->un_read_pos_type != LONG_POS) {
15140 			kmem_free(cmd, sizeof (struct uscsi_cmd));
15141 			return (ERANGE);
15142 		}
15143 		cmd->uscsi_cdblen = CDB_GROUP4;
15144 		cdb[0] = (char)SCMD_LOCATE_G4;
15145 		cdb[1] = pos->partition == partition ? 0 : 2;
15146 		cdb[2] = 0;
15147 		cdb[3] = partition;
15148 		cdb[4] = (char)(lblk >> 56);
15149 		cdb[5] = (char)(lblk >> 48);
15150 		cdb[6] = (char)(lblk >> 40);
15151 		cdb[7] = (char)(lblk >> 32);
15152 		cdb[8] = (char)(lblk >> 24);
15153 		cdb[9] = (char)(lblk >> 16);
15154 		cdb[10] = (char)(lblk >> 8);
15155 		cdb[11] = (char)(lblk);
15156 		cdb[12] = 0;
15157 		cdb[13] = 0;
15158 		cdb[14] = 0;
15159 		cdb[15] = 0;
15160 	}
15161 
15162 
15163 	cmd->uscsi_flags = USCSI_WRITE | USCSI_DIAGNOSE | USCSI_RQENABLE;
15164 	cmd->uscsi_rqbuf = (caddr_t)&sense;
15165 	cmd->uscsi_rqlen = sizeof (sense);
15166 	cmd->uscsi_timeout = un->un_dp->space_timeout;
15167 	cmd->uscsi_cdb = cdb;
15168 
15169 	rval = ubf(un, cmd, FKIOCTL);
15170 
15171 	pos->pmode = logical;
15172 	pos->eof = ST_NO_EOF;
15173 
15174 	if (lblk > INT32_MAX) {
15175 		/*
15176 		 * XXX This is a work around till we handle Descriptor format
15177 		 * sense data. Since we are sending a command where the standard
15178 		 * sense data can not correctly represent a correct residual in
15179 		 * 4 bytes.
15180 		 */
15181 		if (un->un_status == KEY_ILLEGAL_REQUEST) {
15182 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
15183 			    "Big LOCATE ILLEGAL_REQUEST: rval = %d\n", rval);
15184 			/* Doesn't like big locate command */
15185 			un->un_status = 0;
15186 			rval = ERANGE;
15187 		} else if ((un->un_pos.pmode == invalid) || (rval != 0)) {
15188 			/* Aborted big locate command */
15189 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
15190 			    "Big LOCATE resulted in invalid pos: rval = %d\n",
15191 			    rval);
15192 			un->un_status = 0;
15193 			rval = EIO;
15194 		} else if (st_update_block_pos(un, bf, 1)) {
15195 			/* read position failed */
15196 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
15197 			    "Big LOCATE and read pos: rval = %d\n", rval);
15198 			rval = EIO;
15199 		} else if (lblk > un->un_pos.lgclblkno) {
15200 			/* read position worked but position was not expected */
15201 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
15202 			    "Big LOCATE and recover read less then desired 0x%"
15203 			    PRIx64"\n", un->un_pos.lgclblkno);
15204 			un->un_err_resid = lblk - un->un_pos.lgclblkno;
15205 			un->un_status = KEY_BLANK_CHECK;
15206 			rval = ESPIPE;
15207 		} else if (lblk == un->un_pos.lgclblkno) {
15208 			/* read position was what was expected */
15209 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
15210 			    "Big LOCATE and recover seems to have worked\n");
15211 			un->un_err_resid = 0;
15212 			rval = 0;
15213 		} else {
15214 			ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
15215 			    "BIGLOCATE end up going backwards");
15216 			un->un_err_resid = lblk;
15217 			rval = EIO;
15218 		}
15219 
15220 	} else if (rval == 0) {
15221 		/* Worked as requested */
15222 		pos->lgclblkno = lblk;
15223 
15224 	} else if (((cmd->uscsi_status & ST_STATUS_MASK) == STATUS_CHECK) &&
15225 	    (cmd->uscsi_resid != 0)) {
15226 		/* Got part way there but wasn't enough blocks on tape */
15227 		pos->lgclblkno = lblk - cmd->uscsi_resid;
15228 		un->un_err_resid = cmd->uscsi_resid;
15229 		un->un_status = KEY_BLANK_CHECK;
15230 		rval = ESPIPE;
15231 
15232 	} else if (st_update_block_pos(un, bf, 1) == 0) {
15233 		/* Got part way there but drive didn't tell what we missed by */
15234 		un->un_err_resid = lblk - pos->lgclblkno;
15235 		un->un_status = KEY_BLANK_CHECK;
15236 		rval = ESPIPE;
15237 
15238 	} else {
15239 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
15240 		    "Failed LOCATE and recover pos: rval = %d status = %d\n",
15241 		    rval, cmd->uscsi_status);
15242 		un->un_err_resid = lblk;
15243 		un->un_status = KEY_ILLEGAL_REQUEST;
15244 		pos->pmode = invalid;
15245 		rval = EIO;
15246 	}
15247 
15248 	kmem_free(cmd, sizeof (struct uscsi_cmd));
15249 
15250 	return (rval);
15251 }
15252 
15253 static int
15254 st_mtfsf_ioctl(struct scsi_tape *un, int64_t files)
15255 {
15256 	int rval;
15257 
15258 	ST_FUNC(ST_DEVINFO, st_mtfsf_ioctl);
15259 
15260 
15261 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15262 	    "st_mtfsf_ioctl: count=%"PRIx64", eof=%x\n", files, un->un_pos.eof);
15263 #if 0
15264 	if ((IN_EOF(un->un_pos)) && (files == 1)) {
15265 		un->un_pos.fileno++;
15266 		un->un_pos.blkno = 0;
15267 		return (0);
15268 	}
15269 #endif
15270 	/* pmode == invalid already handled */
15271 	if (un->un_pos.pmode == legacy) {
15272 		/*
15273 		 * forward space over filemark
15274 		 *
15275 		 * For ASF we allow a count of 0 on fsf which means
15276 		 * we just want to go to beginning of current file.
15277 		 * Equivalent to "nbsf(0)" or "bsf(1) + fsf".
15278 		 * Allow stepping over double fmk with reel
15279 		 */
15280 		if ((un->un_pos.eof >= ST_EOT) &&
15281 		    (files > 0) &&
15282 		    ((un->un_dp->options & ST_REEL) == 0)) {
15283 			/* we're at EOM */
15284 			un->un_err_resid = files;
15285 			un->un_status = KEY_BLANK_CHECK;
15286 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15287 			    "st_mtfsf_ioctl: EIO : MTFSF at EOM");
15288 			return (EIO);
15289 		}
15290 
15291 		/*
15292 		 * physical tape position may not be what we've been
15293 		 * telling the user; adjust the request accordingly
15294 		 */
15295 		if (IN_EOF(un->un_pos)) {
15296 			un->un_pos.fileno++;
15297 			un->un_pos.blkno = 0;
15298 			/*
15299 			 * For positive direction case, we're now covered.
15300 			 * For zero or negative direction, we're covered
15301 			 * (almost)
15302 			 */
15303 			files--;
15304 		}
15305 
15306 	}
15307 
15308 	if (st_check_density_or_wfm(un->un_dev, 1, B_READ, STEPBACK)) {
15309 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15310 		    "st_mtfsf_ioctl: EIO : MTFSF density/wfm failed");
15311 		return (EIO);
15312 	}
15313 
15314 
15315 	/*
15316 	 * Forward space file marks.
15317 	 * We leave ourselves at block zero
15318 	 * of the target file number.
15319 	 */
15320 	if (files < 0) {
15321 		rval = st_backward_space_files(un, -files, 0);
15322 	} else {
15323 		rval = st_forward_space_files(un, files);
15324 	}
15325 
15326 	return (rval);
15327 }
15328 
15329 static int
15330 st_forward_space_files(struct scsi_tape *un, int64_t count)
15331 {
15332 	int rval;
15333 
15334 	ST_FUNC(ST_DEVINFO, st_forward_space_files);
15335 
15336 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15337 	    "fspace: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof);
15338 
15339 	ASSERT(count >= 0);
15340 	ASSERT(un->un_pos.pmode != invalid);
15341 
15342 	/*
15343 	 * A space with a count of zero means take me to the start of file.
15344 	 */
15345 	if (count == 0) {
15346 
15347 		/* Hay look were already there */
15348 		if (un->un_pos.pmode == legacy && un->un_pos.blkno == 0) {
15349 			un->un_err_resid = 0;
15350 			COPY_POS(&un->un_err_pos, &un->un_pos);
15351 			return (0);
15352 		}
15353 
15354 		/*
15355 		 * Well we are in the first file.
15356 		 * A rewind will get to the start.
15357 		 */
15358 		if (un->un_pos.pmode == legacy && un->un_pos.fileno == 0) {
15359 			rval = st_cmd(un, SCMD_REWIND, 0, SYNC_CMD);
15360 
15361 		/*
15362 		 * Can we backspace to get there?
15363 		 * This should work in logical mode.
15364 		 */
15365 		} else if (un->un_dp->options & ST_BSF) {
15366 			rval = st_space_to_begining_of_file(un);
15367 
15368 		/*
15369 		 * Can't back space but current file number is known,
15370 		 * So rewind and space from the begining of the partition.
15371 		 */
15372 		} else if (un->un_pos.pmode == legacy) {
15373 			rval = st_scenic_route_to_begining_of_file(un,
15374 			    un->un_pos.fileno);
15375 
15376 		/*
15377 		 * pmode is logical and ST_BSF is not set.
15378 		 * The LONG_POS read position contains the fileno.
15379 		 * If the read position works, rewind and space.
15380 		 */
15381 		} else if (un->un_read_pos_type == LONG_POS) {
15382 			rval = st_cmd(un, SCMD_READ_POSITION, 0, SYNC_CMD);
15383 			if (rval) {
15384 				/*
15385 				 * We didn't get the file position from the
15386 				 * read position command.
15387 				 * We are going to trust the drive to backspace
15388 				 * and then position after the filemark.
15389 				 */
15390 				rval = st_space_to_begining_of_file(un);
15391 			}
15392 			rval = st_interpret_read_pos(un, &un->un_pos, LONG_POS,
15393 			    32, (caddr_t)un->un_read_pos_data, 0);
15394 			if ((rval) && (un->un_pos.pmode == invalid)) {
15395 				rval = st_space_to_begining_of_file(un);
15396 			} else {
15397 				rval = st_scenic_route_to_begining_of_file(un,
15398 				    un->un_pos.fileno);
15399 			}
15400 		} else {
15401 			rval = EIO;
15402 		}
15403 		/*
15404 		 * If something didn't work we are lost
15405 		 */
15406 		if (rval != 0) {
15407 			un->un_pos.pmode = invalid;
15408 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15409 			    "st_mtioctop : EIO : fspace pmode invalid");
15410 
15411 			rval = EIO;
15412 		}
15413 
15414 	} else {
15415 		rval = st_space_fmks(un, count);
15416 	}
15417 
15418 	if (rval != EIO && count < 0) {
15419 		/*
15420 		 * we came here with a count < 0; we now need
15421 		 * to skip back to end up before the filemark
15422 		 */
15423 		rval = st_backward_space_files(un, 1, 1);
15424 	}
15425 
15426 	return (rval);
15427 }
15428 
15429 static int
15430 st_scenic_route_to_begining_of_file(struct scsi_tape *un, int32_t fileno)
15431 {
15432 	int rval;
15433 
15434 	ST_FUNC(ST_DEVINFO, st_scenic_route_to_begining_of_file);
15435 
15436 	if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) {
15437 		rval = EIO;
15438 	} else if (st_cmd(un, SCMD_SPACE, Fmk(fileno), SYNC_CMD)) {
15439 		rval = EIO;
15440 	}
15441 
15442 	return (rval);
15443 }
15444 
15445 static int
15446 st_space_to_begining_of_file(struct scsi_tape *un)
15447 {
15448 	int rval;
15449 
15450 	ST_FUNC(ST_DEVINFO, st_space_to_begining_of_file);
15451 
15452 	/*
15453 	 * Back space of the file at the begining of the file.
15454 	 */
15455 	rval = st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD);
15456 	if (rval) {
15457 		rval = EIO;
15458 		return (rval);
15459 	}
15460 
15461 	/*
15462 	 * Other interesting answers might be crashed BOT which isn't bad.
15463 	 */
15464 	if (un->un_status == SUN_KEY_BOT) {
15465 		return (rval);
15466 	}
15467 
15468 	un->un_running.pmode = invalid;
15469 
15470 	/*
15471 	 * Now we are on the BOP side of the filemark. Forward space to
15472 	 * the EOM side and we are at the begining of the file.
15473 	 */
15474 	rval = st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD);
15475 	if (rval) {
15476 		rval = EIO;
15477 	}
15478 
15479 	return (rval);
15480 }
15481 
15482 static int
15483 st_mtfsr_ioctl(struct scsi_tape *un, int64_t count)
15484 {
15485 
15486 	ST_FUNC(ST_DEVINFO, st_mtfsr_ioctl);
15487 
15488 	/*
15489 	 * forward space to inter-record gap
15490 	 *
15491 	 */
15492 
15493 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15494 	    "st_ioctl_fsr: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof);
15495 
15496 	if (un->un_pos.pmode == legacy) {
15497 		/*
15498 		 * If were are at end of tape and count is forward.
15499 		 * Return blank check.
15500 		 */
15501 		if ((un->un_pos.eof >= ST_EOT) && (count > 0)) {
15502 			/* we're at EOM */
15503 			un->un_err_resid = count;
15504 			un->un_status = KEY_BLANK_CHECK;
15505 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15506 			    "st_mtfsr_ioctl: EIO : MTFSR eof > ST_EOT");
15507 			return (EIO);
15508 		}
15509 
15510 		/*
15511 		 * If count is zero there is nothing to do.
15512 		 */
15513 		if (count == 0) {
15514 			un->un_err_pos.fileno = un->un_pos.fileno;
15515 			un->un_err_pos.blkno = un->un_pos.blkno;
15516 			un->un_err_resid = 0;
15517 			if (IN_EOF(un->un_pos) && SVR4_BEHAVIOR) {
15518 				un->un_status = SUN_KEY_EOF;
15519 			}
15520 			return (0);
15521 		}
15522 
15523 		/*
15524 		 * physical tape position may not be what we've been
15525 		 * telling the user; adjust the position accordingly
15526 		 */
15527 		if (IN_EOF(un->un_pos)) {
15528 			daddr_t blkno = un->un_pos.blkno;
15529 			int fileno = un->un_pos.fileno;
15530 
15531 			optype lastop = un->un_lastop;
15532 			if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)
15533 			    == -1) {
15534 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15535 				    "st_mtfsr_ioctl:EIO:MTFSR count && IN_EOF");
15536 				return (EIO);
15537 			}
15538 
15539 			un->un_pos.blkno = blkno;
15540 			un->un_pos.fileno = fileno;
15541 			un->un_lastop = lastop;
15542 		}
15543 	}
15544 
15545 	if (st_check_density_or_wfm(un->un_dev, 1, B_READ, STEPBACK)) {
15546 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15547 		    "st_mtfsr_ioctl: EIO : MTFSR st_check_den");
15548 		return (EIO);
15549 	}
15550 
15551 	return (st_space_records(un, count));
15552 }
15553 
15554 static int
15555 st_space_records(struct scsi_tape *un, int64_t count)
15556 {
15557 	int64_t dblk;
15558 	int rval = 0;
15559 
15560 	ST_FUNC(ST_DEVINFO, st_space_records);
15561 
15562 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15563 	    "st_space_records: count=%"PRIx64", eof=%x\n",
15564 	    count, un->un_pos.eof);
15565 
15566 	if (un->un_pos.pmode == logical) {
15567 		rval = st_cmd(un, SCMD_SPACE, Blk(count), SYNC_CMD);
15568 		if (rval != 0) {
15569 			rval = EIO;
15570 		}
15571 		return (rval);
15572 	}
15573 
15574 	dblk = count + un->un_pos.blkno;
15575 
15576 	/* Already there */
15577 	if (dblk == un->un_pos.blkno) {
15578 		un->un_err_resid = 0;
15579 		COPY_POS(&un->un_err_pos, &un->un_pos);
15580 		return (0);
15581 	}
15582 
15583 	/*
15584 	 * If the destination block is forward
15585 	 * or the drive will backspace records.
15586 	 */
15587 	if (un->un_pos.blkno < dblk || (un->un_dp->options & ST_BSR)) {
15588 		/*
15589 		 * If we're spacing forward, or the device can
15590 		 * backspace records, we can just use the SPACE
15591 		 * command.
15592 		 */
15593 		dblk -= un->un_pos.blkno;
15594 		if (st_cmd(un, SCMD_SPACE, Blk(dblk), SYNC_CMD)) {
15595 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15596 			    "st_space_records:EIO:space_records can't spc");
15597 			rval = EIO;
15598 		} else if (un->un_pos.eof >= ST_EOF_PENDING) {
15599 			/*
15600 			 * check if we hit BOT/EOT
15601 			 */
15602 			if (dblk < 0 && un->un_pos.eof == ST_EOM) {
15603 				un->un_status = SUN_KEY_BOT;
15604 				un->un_pos.eof = ST_NO_EOF;
15605 			} else if (dblk < 0 &&
15606 			    un->un_pos.eof == ST_EOF_PENDING) {
15607 				int residue = un->un_err_resid;
15608 				/*
15609 				 * we skipped over a filemark
15610 				 * and need to go forward again
15611 				 */
15612 				if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) {
15613 					ST_DEBUG2(ST_DEVINFO, st_label,
15614 					    SCSI_DEBUG, "st_space_records: EIO"
15615 					    " : can't space #2");
15616 					rval = EIO;
15617 				}
15618 				un->un_err_resid = residue;
15619 			}
15620 			if (rval == 0) {
15621 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15622 				    "st_space_records: EIO : space_rec rval"
15623 				    " == 0");
15624 				rval = EIO;
15625 			}
15626 		}
15627 	} else {
15628 		/*
15629 		 * else we rewind, space forward across filemarks to
15630 		 * the desired file, and then space records to the
15631 		 * desired block.
15632 		 */
15633 
15634 		int dfile = un->un_pos.fileno;	/* save current file */
15635 
15636 		if (dblk < 0) {
15637 			/*
15638 			 * Wups - we're backing up over a filemark
15639 			 */
15640 			if (un->un_pos.blkno != 0 &&
15641 			    (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) ||
15642 			    st_cmd(un, SCMD_SPACE, Fmk(dfile), SYNC_CMD))) {
15643 				un->un_pos.pmode = invalid;
15644 			}
15645 			un->un_err_resid = -dblk;
15646 			if (un->un_pos.fileno == 0 && un->un_pos.blkno == 0) {
15647 				un->un_status = SUN_KEY_BOT;
15648 				un->un_pos.eof = ST_NO_EOF;
15649 			} else if (un->un_pos.fileno > 0) {
15650 				un->un_status = SUN_KEY_EOF;
15651 				un->un_pos.eof = ST_NO_EOF;
15652 			}
15653 			COPY_POS(&un->un_err_pos, &un->un_pos);
15654 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15655 			    "st_space_records:EIO:space_records : dblk < 0");
15656 			rval = EIO;
15657 		} else if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) ||
15658 		    st_cmd(un, SCMD_SPACE, Fmk(dfile), SYNC_CMD) ||
15659 		    st_cmd(un, SCMD_SPACE, Blk(dblk), SYNC_CMD)) {
15660 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15661 			    "st_space_records: EIO :space_records : rewind "
15662 			    "and space failed");
15663 			un->un_pos.pmode = invalid;
15664 			rval = EIO;
15665 		}
15666 	}
15667 
15668 	return (rval);
15669 }
15670 
15671 static int
15672 st_mtbsf_ioctl(struct scsi_tape *un, int64_t files)
15673 {
15674 	ST_FUNC(ST_DEVINFO, st_mtbsf_ioctl);
15675 
15676 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15677 	    "st_mtbsf_ioctl: count=%"PRIx64", eof=%x\n", files, un->un_pos.eof);
15678 	/*
15679 	 * backward space of file filemark (1/2" and 8mm)
15680 	 * tape position will end on the beginning of tape side
15681 	 * of the desired file mark
15682 	 */
15683 	if ((un->un_dp->options & ST_BSF) == 0) {
15684 		return (ENOTTY);
15685 	}
15686 
15687 	if (un->un_pos.pmode == legacy) {
15688 
15689 		/*
15690 		 * If a negative count (which implies a forward space op)
15691 		 * is specified, and we're at logical or physical eot,
15692 		 * bounce the request.
15693 		 */
15694 
15695 		if (un->un_pos.eof >= ST_EOT && files < 0) {
15696 			un->un_err_resid = files;
15697 			un->un_status = SUN_KEY_EOT;
15698 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15699 			    "st_ioctl_mt_bsf : EIO : MTBSF : eof > ST_EOF");
15700 			return (EIO);
15701 		}
15702 		/*
15703 		 * physical tape position may not be what we've been
15704 		 * telling the user; adjust the request accordingly
15705 		 */
15706 		if (IN_EOF(un->un_pos)) {
15707 			un->un_pos.fileno++;
15708 			un->un_pos.blkno = 0;
15709 			files++;
15710 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15711 			    "st_mtbsf_ioctl in eof: count=%"PRIx64", op=%x\n",
15712 			    files, MTBSF);
15713 
15714 		}
15715 	}
15716 
15717 	if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) {
15718 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15719 		    "st_ioctl : EIO : MTBSF : check den wfm");
15720 		return (EIO);
15721 	}
15722 
15723 	if (files <= 0) {
15724 		/*
15725 		 * for a negative count, we need to step forward
15726 		 * first and then step back again
15727 		 */
15728 		files = -files + 1;
15729 		return (st_forward_space_files(un, files));
15730 	}
15731 	return (st_backward_space_files(un, files, 1));
15732 }
15733 
15734 static int
15735 st_backward_space_files(struct scsi_tape *un, int64_t count, int infront)
15736 {
15737 	int64_t end_fileno;
15738 	int64_t skip_cnt;
15739 	int rval = 0;
15740 
15741 	ST_FUNC(ST_DEVINFO, st_backward_space_files);
15742 
15743 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15744 	    "st_backward_space_files: count=%"PRIx64" eof=%x\n",
15745 	    count, un->un_pos.eof);
15746 	/*
15747 	 * Backspace files (MTNBSF): infront == 0
15748 	 *
15749 	 *	For tapes that can backspace, backspace
15750 	 *	count+1 filemarks and then run forward over
15751 	 *	a filemark
15752 	 *
15753 	 *	For tapes that can't backspace,
15754 	 *		calculate desired filenumber
15755 	 *		(un->un_pos.fileno - count), rewind,
15756 	 *		and then space forward this amount
15757 	 *
15758 	 * Backspace filemarks (MTBSF) infront == 1
15759 	 *
15760 	 *	For tapes that can backspace, backspace count
15761 	 *	filemarks
15762 	 *
15763 	 *	For tapes that can't backspace, calculate
15764 	 *	desired filenumber (un->un_pos.fileno - count),
15765 	 *	add 1, rewind, space forward this amount,
15766 	 *	and mark state as ST_EOF_PENDING appropriately.
15767 	 */
15768 
15769 	if (un->un_pos.pmode == logical) {
15770 
15771 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15772 		    "st_backward_space_files: mt_op=%x count=%"PRIx64
15773 		    "lgclblkno=%"PRIx64"\n", infront?MTBSF:MTNBSF, count,
15774 		    un->un_pos.lgclblkno);
15775 
15776 
15777 		/* In case a drive that won't back space gets in logical mode */
15778 		if ((un->un_dp->options & ST_BSF) == 0) {
15779 			rval = EIO;
15780 			return (rval);
15781 		}
15782 		if ((infront == 1) &&
15783 		    (st_cmd(un, SCMD_SPACE, Fmk(-count), SYNC_CMD))) {
15784 			rval = EIO;
15785 			return (rval);
15786 		} else if ((infront == 0) &&
15787 		    (st_cmd(un, SCMD_SPACE, Fmk((-count)-1), SYNC_CMD)) &&
15788 		    (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD))) {
15789 			rval = EIO;
15790 			return (rval);
15791 		}
15792 		return (rval);
15793 	}
15794 
15795 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15796 	    "st_backward_space_files: mt_op=%x count=%"PRIx64
15797 	    "fileno=%x blkno=%x\n",
15798 	    infront?MTBSF:MTNBSF, count, un->un_pos.fileno, un->un_pos.blkno);
15799 
15800 
15801 
15802 	/*
15803 	 * Handle the simple case of BOT
15804 	 * playing a role in these cmds.
15805 	 * We do this by calculating the
15806 	 * ending file number. If the ending
15807 	 * file is < BOT, rewind and set an
15808 	 * error and mark resid appropriately.
15809 	 * If we're backspacing a file (not a
15810 	 * filemark) and the target file is
15811 	 * the first file on the tape, just
15812 	 * rewind.
15813 	 */
15814 
15815 	/* figure expected destination of this SPACE command */
15816 	end_fileno = un->un_pos.fileno - count;
15817 
15818 	/*
15819 	 * Would the end effect of this SPACE be the same as rewinding?
15820 	 * If so just rewind instead.
15821 	 */
15822 	if ((infront != 0) && (end_fileno < 0) ||
15823 	    (infront == 0) && (end_fileno <= 0)) {
15824 		if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) {
15825 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15826 			    "st_backward_space_files: EIO : "
15827 			    "rewind in lou of BSF failed\n");
15828 			rval = EIO;
15829 		}
15830 		if (end_fileno < 0) {
15831 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15832 			    "st_backward_space_files: EIO : "
15833 			    "back space file greater then fileno\n");
15834 			rval = EIO;
15835 			un->un_err_resid = -end_fileno;
15836 			un->un_status = SUN_KEY_BOT;
15837 		}
15838 		return (rval);
15839 	}
15840 
15841 	if (un->un_dp->options & ST_BSF) {
15842 		skip_cnt = 1 - infront;
15843 		/*
15844 		 * If we are going to end up at the beginning
15845 		 * of the file, we have to space one extra file
15846 		 * first, and then space forward later.
15847 		 */
15848 		end_fileno = -(count + skip_cnt);
15849 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
15850 		    "skip_cnt=%"PRIx64", tmp=%"PRIx64"\n",
15851 		    skip_cnt, end_fileno);
15852 		if (st_cmd(un, SCMD_SPACE, Fmk(end_fileno), SYNC_CMD)) {
15853 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15854 			    "st_backward_space_files:EIO:back space fm failed");
15855 			rval = EIO;
15856 		}
15857 	} else {
15858 		if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) {
15859 			rval = EIO;
15860 		} else {
15861 			skip_cnt = end_fileno + infront;
15862 		}
15863 	}
15864 
15865 	/*
15866 	 * If we have to space forward, do so...
15867 	 */
15868 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
15869 	    "space forward skip_cnt=%"PRIx64", rval=%x\n", skip_cnt, rval);
15870 
15871 	if (rval == 0 && skip_cnt) {
15872 		if (st_cmd(un, SCMD_SPACE, Fmk(skip_cnt), SYNC_CMD)) {
15873 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15874 			    "st_backward_space_files:EIO:space fm skip count");
15875 			rval = EIO;
15876 		} else if (infront) {
15877 			/*
15878 			 * If we had to space forward, and we're
15879 			 * not a tape that can backspace, mark state
15880 			 * as if we'd just seen a filemark during a
15881 			 * a read.
15882 			 */
15883 			if ((un->un_dp->options & ST_BSF) == 0) {
15884 				un->un_pos.eof = ST_EOF_PENDING;
15885 				un->un_pos.fileno -= 1;
15886 				un->un_pos.blkno = LASTBLK;
15887 				un->un_running.pmode = invalid;
15888 			}
15889 		}
15890 	}
15891 
15892 	if (rval != 0) {
15893 		un->un_pos.pmode = invalid;
15894 	}
15895 
15896 	return (rval);
15897 }
15898 
15899 static int
15900 st_mtnbsf_ioctl(struct scsi_tape *un, int64_t count)
15901 {
15902 	int rval;
15903 
15904 	ST_FUNC(ST_DEVINFO, st_mtnbsf_ioctl);
15905 
15906 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15907 	    "nbsf: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof);
15908 
15909 	if (un->un_pos.pmode == legacy) {
15910 		/*
15911 		 * backward space file to beginning of file
15912 		 *
15913 		 * If a negative count (which implies a forward space op)
15914 		 * is specified, and we're at logical or physical eot,
15915 		 * bounce the request.
15916 		 */
15917 
15918 		if (un->un_pos.eof >= ST_EOT && count < 0) {
15919 			un->un_err_resid = count;
15920 			un->un_status = SUN_KEY_EOT;
15921 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15922 			    "st_ioctl : EIO : > EOT and count < 0");
15923 			return (EIO);
15924 		}
15925 		/*
15926 		 * physical tape position may not be what we've been
15927 		 * telling the user; adjust the request accordingly
15928 		 */
15929 		if (IN_EOF(un->un_pos)) {
15930 			un->un_pos.fileno++;
15931 			un->un_pos.blkno = 0;
15932 			count++;
15933 		}
15934 	}
15935 
15936 	if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) {
15937 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15938 		    "st_ioctl : EIO : MTNBSF check den and wfm");
15939 		return (EIO);
15940 	}
15941 
15942 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15943 	    "mtnbsf: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof);
15944 
15945 	if (count <= 0) {
15946 		rval = st_forward_space_files(un, -count);
15947 	} else {
15948 		rval = st_backward_space_files(un, count, 0);
15949 	}
15950 	return (rval);
15951 }
15952 
15953 static int
15954 st_mtbsr_ioctl(struct scsi_tape *un, int64_t num)
15955 {
15956 	ST_FUNC(ST_DEVINFO, st_mtbsr_ioctl);
15957 
15958 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
15959 	    "bsr: count=%"PRIx64", eof=%x\n", num, un->un_pos.eof);
15960 
15961 	if (un->un_pos.pmode == legacy) {
15962 		/*
15963 		 * backward space into inter-record gap
15964 		 *
15965 		 * If a negative count (which implies a forward space op)
15966 		 * is specified, and we're at logical or physical eot,
15967 		 * bounce the request.
15968 		 */
15969 		if (un->un_pos.eof >= ST_EOT && num < 0) {
15970 			un->un_err_resid = num;
15971 			un->un_status = SUN_KEY_EOT;
15972 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
15973 			    "st_ioctl : EIO : MTBSR > EOT");
15974 			return (EIO);
15975 		}
15976 
15977 		if (num == 0) {
15978 			COPY_POS(&un->un_err_pos, &un->un_pos);
15979 			un->un_err_resid = 0;
15980 			if (IN_EOF(un->un_pos) && SVR4_BEHAVIOR) {
15981 				un->un_status = SUN_KEY_EOF;
15982 			}
15983 			return (0);
15984 		}
15985 
15986 		/*
15987 		 * physical tape position may not be what we've been
15988 		 * telling the user; adjust the position accordingly.
15989 		 * bsr can not skip filemarks and continue to skip records
15990 		 * therefore if we are logically before the filemark but
15991 		 * physically at the EOT side of the filemark, we need to step
15992 		 * back; this allows fsr N where N > number of blocks in file
15993 		 * followed by bsr 1 to position at the beginning of last block
15994 		 */
15995 		if (IN_EOF(un->un_pos)) {
15996 			tapepos_t save;
15997 			optype lastop = un->un_lastop;
15998 
15999 			COPY_POS(&save, &un->un_pos);
16000 			if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD) == -1) {
16001 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
16002 				    "st_mtbsr_ioctl: EIO : MTBSR can't space");
16003 				return (EIO);
16004 			}
16005 
16006 			COPY_POS(&un->un_pos, &save);
16007 			un->un_lastop = lastop;
16008 		}
16009 	}
16010 
16011 	un->un_pos.eof = ST_NO_EOF;
16012 
16013 	if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) {
16014 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
16015 		    "st_ioctl : EIO : MTBSR : can't set density or wfm");
16016 		return (EIO);
16017 	}
16018 
16019 	num = -num;
16020 	return (st_space_records(un, num));
16021 }
16022 
16023 static int
16024 st_mtfsfm_ioctl(struct scsi_tape *un, int64_t cnt)
16025 {
16026 	int rval;
16027 
16028 	ST_FUNC(ST_DEVINFO, st_mtfsfm_ioctl);
16029 
16030 	rval = st_cmd(un, SCMD_SPACE, SPACE(SP_SQFLM, cnt), SYNC_CMD);
16031 	if (rval == 0) {
16032 		un->un_pos.pmode = logical;
16033 	} else if ((un->un_status == KEY_ILLEGAL_REQUEST) &&
16034 	    (un->un_sd->sd_sense->es_add_code == 0x24)) {
16035 		/*
16036 		 * Drive says invalid field in cdb.
16037 		 * Doesn't like space multiple. Position isn't lost.
16038 		 */
16039 		un->un_err_resid = cnt;
16040 		un->un_status = 0;
16041 		rval = ENOTTY;
16042 	} else {
16043 		un->un_err_resid = cnt;
16044 		un->un_pos.pmode = invalid;
16045 	}
16046 	return (rval);
16047 }
16048 
16049 static int
16050 st_mtbsfm_ioctl(struct scsi_tape *un, int64_t cnt)
16051 {
16052 	int rval;
16053 
16054 	ST_FUNC(ST_DEVINFO, st_mtbsfm_ioctl);
16055 
16056 	rval = st_cmd(un, SCMD_SPACE, SPACE(SP_SQFLM, -cnt), SYNC_CMD);
16057 	if (rval == 0) {
16058 		un->un_pos.pmode = logical;
16059 	} else if ((un->un_status == KEY_ILLEGAL_REQUEST) &&
16060 	    (un->un_sd->sd_sense->es_add_code == 0x24)) {
16061 		/*
16062 		 * Drive says invalid field in cdb.
16063 		 * Doesn't like space multiple. Position isn't lost.
16064 		 */
16065 		un->un_err_resid = cnt;
16066 		un->un_status = 0;
16067 		rval = ENOTTY;
16068 	} else {
16069 		un->un_err_resid = cnt;
16070 		un->un_pos.pmode = invalid;
16071 	}
16072 	return (rval);
16073 }
16074 
16075 #ifdef	__x86
16076 
16077 /*
16078  * release contig_mem and wake up waiting thread, if any
16079  */
16080 static void
16081 st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp)
16082 {
16083 	mutex_enter(ST_MUTEX);
16084 
16085 	ST_FUNC(ST_DEVINFO, st_release_contig_mem);
16086 
16087 	cp->cm_next = un->un_contig_mem;
16088 	un->un_contig_mem = cp;
16089 	un->un_contig_mem_available_num++;
16090 	cv_broadcast(&un->un_contig_mem_cv);
16091 
16092 	mutex_exit(ST_MUTEX);
16093 }
16094 
16095 /*
16096  * St_get_contig_mem will return a contig_mem if there is one available
16097  * in current system. Otherwise, it will try to alloc one, if the total
16098  * number of contig_mem is within st_max_contig_mem_num.
16099  * It will sleep, if allowed by caller or return NULL, if no contig_mem
16100  * is available for now.
16101  */
16102 static struct contig_mem *
16103 st_get_contig_mem(struct scsi_tape *un, size_t len, int alloc_flags)
16104 {
16105 	size_t rlen;
16106 	struct contig_mem *cp = NULL;
16107 	ddi_acc_handle_t acc_hdl;
16108 	caddr_t addr;
16109 	int big_enough = 0;
16110 	int (*dma_alloc_cb)() = (alloc_flags == KM_SLEEP) ?
16111 	    DDI_DMA_SLEEP : DDI_DMA_DONTWAIT;
16112 
16113 	/* Try to get one available contig_mem */
16114 	mutex_enter(ST_MUTEX);
16115 
16116 	ST_FUNC(ST_DEVINFO, st_get_contig_mem);
16117 
16118 	if (un->un_contig_mem_available_num > 0) {
16119 		ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough);
16120 	} else if (un->un_contig_mem_total_num < st_max_contig_mem_num) {
16121 		/*
16122 		 * we failed to get one. we're going to
16123 		 * alloc one more contig_mem for this I/O
16124 		 */
16125 		mutex_exit(ST_MUTEX);
16126 		cp = (struct contig_mem *)kmem_zalloc(
16127 		    sizeof (struct contig_mem) + biosize(),
16128 		    alloc_flags);
16129 		if (cp == NULL) {
16130 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
16131 			    "alloc contig_mem failure\n");
16132 			return (NULL); /* cannot get one */
16133 		}
16134 		cp->cm_bp = (struct buf *)
16135 		    (((caddr_t)cp) + sizeof (struct contig_mem));
16136 		bioinit(cp->cm_bp);
16137 		mutex_enter(ST_MUTEX);
16138 		un->un_contig_mem_total_num++; /* one more available */
16139 	} else {
16140 		/*
16141 		 * we failed to get one and we're NOT allowed to
16142 		 * alloc more contig_mem
16143 		 */
16144 		if (alloc_flags == KM_SLEEP) {
16145 			while (un->un_contig_mem_available_num <= 0) {
16146 				cv_wait(&un->un_contig_mem_cv, ST_MUTEX);
16147 			}
16148 			ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough);
16149 		} else {
16150 			mutex_exit(ST_MUTEX);
16151 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
16152 			    "alloc contig_mem failure\n");
16153 			return (NULL); /* cannot get one */
16154 		}
16155 	}
16156 	mutex_exit(ST_MUTEX);
16157 
16158 	/* We need to check if this block of mem is big enough for this I/O */
16159 	if (cp->cm_len < len) {
16160 		/* not big enough, need to alloc a new one */
16161 		if (ddi_dma_mem_alloc(un->un_contig_mem_hdl, len, &st_acc_attr,
16162 		    DDI_DMA_STREAMING, dma_alloc_cb, NULL,
16163 		    &addr, &rlen, &acc_hdl) != DDI_SUCCESS) {
16164 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
16165 			    "alloc contig_mem failure: not enough mem\n");
16166 			st_release_contig_mem(un, cp);
16167 			cp = NULL;
16168 		} else {
16169 			if (cp->cm_addr) {
16170 				/* release previous one before attach new one */
16171 				ddi_dma_mem_free(&cp->cm_acc_hdl);
16172 			}
16173 			mutex_enter(ST_MUTEX);
16174 			un->un_max_contig_mem_len =
16175 			    un->un_max_contig_mem_len >= len ?
16176 			    un->un_max_contig_mem_len : len;
16177 			mutex_exit(ST_MUTEX);
16178 
16179 			/* attach new mem to this cp */
16180 			cp->cm_addr = addr;
16181 			cp->cm_acc_hdl = acc_hdl;
16182 			cp->cm_len = len;
16183 
16184 			goto alloc_ok; /* get one usable cp */
16185 		}
16186 	} else {
16187 		goto alloc_ok; /* get one usable cp */
16188 	}
16189 
16190 	/* cannot find/alloc a usable cp, when we get here */
16191 
16192 	mutex_enter(ST_MUTEX);
16193 	if ((un->un_max_contig_mem_len < len) ||
16194 	    (alloc_flags != KM_SLEEP)) {
16195 		mutex_exit(ST_MUTEX);
16196 		return (NULL);
16197 	}
16198 
16199 	/*
16200 	 * we're allowed to sleep, and there is one big enough
16201 	 * contig mem in the system, which is currently in use,
16202 	 * wait for it...
16203 	 */
16204 	big_enough = 1;
16205 	do {
16206 		cv_wait(&un->un_contig_mem_cv, ST_MUTEX);
16207 		ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough);
16208 	} while (cp == NULL);
16209 	mutex_exit(ST_MUTEX);
16210 
16211 	/* we get the big enough contig mem, finally */
16212 
16213 alloc_ok:
16214 	/* init bp attached to this cp */
16215 	bioreset(cp->cm_bp);
16216 	cp->cm_bp->b_un.b_addr = cp->cm_addr;
16217 	cp->cm_bp->b_private = (void *)cp;
16218 
16219 	return (cp);
16220 }
16221 
16222 /*
16223  * this is the biodone func for the bp used in big block I/O
16224  */
16225 static int
16226 st_bigblk_xfer_done(struct buf *bp)
16227 {
16228 	struct contig_mem *cp;
16229 	struct buf *orig_bp;
16230 	int ioerr;
16231 	struct scsi_tape *un;
16232 
16233 	/* sanity check */
16234 	if (bp == NULL) {
16235 		return (DDI_FAILURE);
16236 	}
16237 
16238 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
16239 	if (un == NULL) {
16240 		return (DDI_FAILURE);
16241 	}
16242 
16243 	ST_FUNC(ST_DEVINFO, st_bigblk_xfer_done);
16244 
16245 	cp = (struct contig_mem *)bp->b_private;
16246 	orig_bp = cp->cm_bp; /* get back the bp we have replaced */
16247 	cp->cm_bp = bp;
16248 
16249 	/* special handling for special I/O */
16250 	if (cp->cm_use_sbuf) {
16251 #ifndef __lock_lint
16252 		ASSERT(un->un_sbuf_busy);
16253 #endif
16254 		un->un_sbufp = orig_bp;
16255 		cp->cm_use_sbuf = 0;
16256 	}
16257 
16258 	orig_bp->b_resid = bp->b_resid;
16259 	ioerr = geterror(bp);
16260 	if (ioerr != 0) {
16261 		bioerror(orig_bp, ioerr);
16262 	} else if (orig_bp->b_flags & B_READ) {
16263 		/* copy data back to original bp */
16264 		(void) bp_copyout(bp->b_un.b_addr, orig_bp, 0,
16265 		    bp->b_bcount - bp->b_resid);
16266 	}
16267 
16268 	st_release_contig_mem(un, cp);
16269 
16270 	biodone(orig_bp);
16271 
16272 	return (DDI_SUCCESS);
16273 }
16274 
16275 /*
16276  * We use this func to replace original bp that may not be able to do I/O
16277  * in big block size with one that can
16278  */
16279 static struct buf *
16280 st_get_bigblk_bp(struct buf *bp)
16281 {
16282 	struct contig_mem *cp;
16283 	struct scsi_tape *un;
16284 	struct buf *cont_bp;
16285 
16286 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
16287 	if (un == NULL) {
16288 		return (bp);
16289 	}
16290 
16291 	ST_FUNC(ST_DEVINFO, st_get_bigblk_bp);
16292 
16293 	/* try to get one contig_mem */
16294 	cp = st_get_contig_mem(un, bp->b_bcount, KM_SLEEP);
16295 	if (!cp) {
16296 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
16297 		    "Cannot alloc contig buf for I/O for %lu blk size",
16298 		    bp->b_bcount);
16299 		return (bp);
16300 	}
16301 	cont_bp = cp->cm_bp;
16302 	cp->cm_bp = bp;
16303 
16304 	/* make sure that we "are" using un_sbufp for special I/O */
16305 	if (bp == un->un_sbufp) {
16306 #ifndef __lock_lint
16307 		ASSERT(un->un_sbuf_busy);
16308 #endif
16309 		un->un_sbufp = cont_bp;
16310 		cp->cm_use_sbuf = 1;
16311 	}
16312 
16313 	/* clone bp */
16314 	cont_bp->b_bcount = bp->b_bcount;
16315 	cont_bp->b_resid = bp->b_resid;
16316 	cont_bp->b_iodone = st_bigblk_xfer_done;
16317 	cont_bp->b_file = bp->b_file;
16318 	cont_bp->b_offset = bp->b_offset;
16319 	cont_bp->b_dip = bp->b_dip;
16320 	cont_bp->b_error = 0;
16321 	cont_bp->b_proc = NULL;
16322 	cont_bp->b_flags = bp->b_flags & ~(B_PAGEIO | B_PHYS | B_SHADOW);
16323 	cont_bp->b_shadow = NULL;
16324 	cont_bp->b_pages = NULL;
16325 	cont_bp->b_edev = bp->b_edev;
16326 	cont_bp->b_dev = bp->b_dev;
16327 	cont_bp->b_lblkno = bp->b_lblkno;
16328 	cont_bp->b_forw = bp->b_forw;
16329 	cont_bp->b_back = bp->b_back;
16330 	cont_bp->av_forw = bp->av_forw;
16331 	cont_bp->av_back = bp->av_back;
16332 	cont_bp->b_bufsize = bp->b_bufsize;
16333 
16334 	/* get data in original bp */
16335 	if (bp->b_flags & B_WRITE) {
16336 		(void) bp_copyin(bp, cont_bp->b_un.b_addr, 0, bp->b_bcount);
16337 	}
16338 
16339 	return (cont_bp);
16340 }
16341 #else
16342 #ifdef __lock_lint
16343 static int
16344 st_bigblk_xfer_done(struct buf *bp)
16345 {
16346 	return (0);
16347 }
16348 #endif
16349 #endif
16350 
16351 static const char *eof_status[] =
16352 {
16353 	"NO_EOF",
16354 	"EOF_PENDING",
16355 	"EOF",
16356 	"EOT_PENDING",
16357 	"EOT",
16358 	"EOM",
16359 	"AFTER_EOM"
16360 };
16361 static const char *mode[] = {
16362 	"invalid",
16363 	"legacy",
16364 	"logical"
16365 };
16366 
16367 static void
16368 st_print_position(dev_info_t *dev, char *label, uint_t level,
16369 const char *comment, tapepos_t *pos)
16370 {
16371 	ST_FUNC(dev, st_print_position);
16372 
16373 	scsi_log(dev, label, level,
16374 	    "%s Position data:\n", comment);
16375 	scsi_log(dev, label, CE_CONT,
16376 	    "Positioning mode = %s", mode[pos->pmode]);
16377 	scsi_log(dev, label, CE_CONT,
16378 	    "End Of File/Tape = %s", eof_status[pos->eof]);
16379 	scsi_log(dev, label, CE_CONT,
16380 	    "File Number      = 0x%x", pos->fileno);
16381 	scsi_log(dev, label, CE_CONT,
16382 	    "Block Number     = 0x%x", pos->blkno);
16383 	scsi_log(dev, label, CE_CONT,
16384 	    "Logical Block    = 0x%"PRIx64, pos->lgclblkno);
16385 	scsi_log(dev, label, CE_CONT,
16386 	    "Partition Number = 0x%x", pos->partition);
16387 }
16388 static int
16389 st_check_if_media_changed(struct scsi_tape *un, caddr_t data, int size)
16390 {
16391 
16392 	int result = 0;
16393 	int i;
16394 	ST_FUNC(ST_DEVINFO, st_check_if_media_changed);
16395 
16396 	/*
16397 	 * find non alpha numeric working from the end.
16398 	 */
16399 	for (i = size - 1; i >= 0; i--) {
16400 		if (ISALNUM(data[i]) == 0 || data[i] == ' ') {
16401 			data[i] = 0;
16402 			size = i;
16403 		}
16404 	}
16405 
16406 	if (size == 1) {
16407 		/*
16408 		 * Drive seems to think its returning useful data
16409 		 * but it looks like all junk
16410 		 */
16411 		return (result);
16412 	}
16413 
16414 	size++;
16415 
16416 	/*
16417 	 * Actually got a valid serial number.
16418 	 * If never stored one before alloc space for it.
16419 	 */
16420 	if (un->un_media_id_len == 0) {
16421 		un->un_media_id = kmem_zalloc(size, KM_SLEEP);
16422 		un->un_media_id_len = size;
16423 		(void) strncpy(un->un_media_id, data, min(size, strlen(data)));
16424 		un->un_media_id[min(size, strlen(data))] = 0;
16425 		ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG,
16426 		    "Found Media Id %s length = %d\n", un->un_media_id, size);
16427 	} else if (size > un->un_media_id_len) {
16428 		if (strncmp(un->un_media_id, data, size) != 0) {
16429 			result = ESPIPE;
16430 		}
16431 		ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG,
16432 		    "Longer Media Id old ID:%s new ID:%s\n",
16433 		    un->un_media_id, data);
16434 		kmem_free(un->un_media_id, un->un_media_id_len);
16435 		un->un_media_id = kmem_zalloc(size, KM_SLEEP);
16436 		un->un_media_id_len = size;
16437 		(void) strncpy(un->un_media_id, data, size);
16438 		un->un_media_id[size] = 0;
16439 	} else if (strncmp(data, un->un_media_id,
16440 	    min(size, un->un_media_id_len)) != 0) {
16441 		ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG,
16442 		    "Old Media Id %s length = %d New %s length = %d\n",
16443 		    un->un_media_id, un->un_media_id_len, data, size);
16444 		bzero(un->un_media_id, un->un_media_id_len);
16445 		(void) strncpy(un->un_media_id, data, min(size, strlen(data)));
16446 		un->un_media_id[min(size, strlen(data))] = 0;
16447 		result = ESPIPE;
16448 	} else {
16449 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
16450 		    "Media Id still %s\n", un->un_media_id);
16451 	}
16452 
16453 	ASSERT(strlen(un->un_media_id) <= size);
16454 
16455 	return (result);
16456 }
16457 #define	ID_SIZE 32
16458 typedef struct
16459 {
16460 	uchar_t avilable_data0;
16461 	uchar_t avilable_data1;
16462 	uchar_t avilable_data2;
16463 	uchar_t avilable_data3;
16464 	uchar_t attribute_msb;
16465 	uchar_t attribute_lsb;
16466 #ifdef _BIT_FIELDS_LTOH
16467 	uchar_t format		: 2,
16468 				: 5,
16469 		read_only	: 1;
16470 #else
16471 	uchar_t read_only	: 1,
16472 				: 5,
16473 		format		: 2;
16474 #endif
16475 	uchar_t attribute_len_msb;
16476 	uchar_t attribute_len_lsb;
16477 }attribute_header;
16478 
16479 typedef struct {
16480 	attribute_header header;
16481 	char data[1];
16482 }mam_attribute;
16483 
16484 static int
16485 st_handle_hex_media_id(struct scsi_tape *un, void *pnt, int size)
16486 {
16487 	int result;
16488 	int newsize = (size << 1) + 3; /* extra for leading 0x and null term */
16489 	int i;
16490 	uchar_t byte;
16491 	char *format;
16492 	uchar_t *data = (uchar_t *)pnt;
16493 	char *buf = kmem_alloc(newsize, KM_SLEEP);
16494 
16495 	ST_FUNC(ST_DEVINFO, st_handle_hex_media_id);
16496 
16497 	(void) sprintf(buf, "0x");
16498 	for (i = 0; i < size; i++) {
16499 		byte = data[i];
16500 		if (byte < 0x10)
16501 			format = "0%x";
16502 		else
16503 			format = "%x";
16504 		(void) sprintf(&buf[(int)strlen(buf)], format, byte);
16505 	}
16506 	result = st_check_if_media_changed(un, buf, newsize);
16507 
16508 	kmem_free(buf, newsize);
16509 
16510 	return (result);
16511 }
16512 
16513 
16514 static int
16515 st_get_media_id_via_read_attribute(struct scsi_tape *un, ubufunc_t bufunc)
16516 {
16517 	int result;
16518 	mam_attribute *buffer;
16519 	int size;
16520 	int newsize;
16521 
16522 	ST_FUNC(ST_DEVINFO, st_get_media_id_via_read_attribute);
16523 	size = sizeof (attribute_header) + max(un->un_media_id_len, ID_SIZE);
16524 again:
16525 	buffer = kmem_zalloc(size, KM_SLEEP);
16526 	result = st_read_attributes(un, 0x0401, buffer, size, bufunc);
16527 	if (result == 0) {
16528 
16529 		newsize = (buffer->header.attribute_len_msb << 8) |
16530 		    buffer->header.attribute_len_lsb;
16531 
16532 		if (newsize + sizeof (attribute_header) > size) {
16533 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
16534 			    "resizing read attribute data from %d to %d format"
16535 			    " %d\n", size, (int)sizeof (attribute_header) +
16536 			    newsize, buffer->header.format);
16537 			kmem_free(buffer, size);
16538 			size = newsize + sizeof (attribute_header);
16539 			goto again;
16540 		}
16541 
16542 		un->un_media_id_method = st_get_media_id_via_read_attribute;
16543 		if (buffer->header.format == 0) {
16544 			result =
16545 			    st_handle_hex_media_id(un, buffer->data, newsize);
16546 		} else {
16547 			result = st_check_if_media_changed(un, buffer->data,
16548 			    newsize);
16549 		}
16550 	} else if (result == EINVAL && un->un_max_cdb_sz < CDB_GROUP4) {
16551 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
16552 		    "Read Attribute Command for Media Identification is not "
16553 		    "supported on the HBA that this drive is attached to.");
16554 		result = ENOTTY;
16555 	}
16556 
16557 	kmem_free(buffer, size);
16558 	un->un_status = 0;
16559 
16560 	return (result);
16561 }
16562 
16563 
16564 static int
16565 st_get_media_id_via_media_serial_cmd(struct scsi_tape *un, ubufunc_t bufunc)
16566 {
16567 	char cdb[CDB_GROUP5];
16568 	struct uscsi_cmd *ucmd;
16569 	struct scsi_extended_sense sense;
16570 	int rval;
16571 	int size = max(un->un_media_id_len, ID_SIZE);
16572 	caddr_t buf;
16573 
16574 	ST_FUNC(ST_DEVINFO, st_get_media_id_via_media_serial_cmd);
16575 
16576 	if (un->un_sd->sd_inq->inq_ansi < 3) {
16577 		return (ENOTTY);
16578 	}
16579 
16580 	ucmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
16581 upsize:
16582 	buf = kmem_alloc(size, KM_SLEEP);
16583 
16584 	cdb[0] = (char)SCMD_SVC_ACTION_IN_G5;
16585 	cdb[1] = SSVC_ACTION_READ_MEDIA_SERIAL;
16586 	cdb[2] = 0;
16587 	cdb[3] = 0;
16588 	cdb[4] = 0;
16589 	cdb[5] = 0;
16590 	cdb[6] = (char)(size >> 24);
16591 	cdb[7] = (char)(size >> 16);
16592 	cdb[8] = (char)(size >> 8);
16593 	cdb[9] = (char)(size);
16594 	cdb[10] = 0;
16595 	cdb[11] = 0;
16596 
16597 	ucmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE;
16598 	ucmd->uscsi_timeout = un->un_dp->non_motion_timeout;
16599 	ucmd->uscsi_cdb = &cdb[0];
16600 	ucmd->uscsi_cdblen = sizeof (cdb);
16601 	ucmd->uscsi_bufaddr = buf;
16602 	ucmd->uscsi_buflen = size;
16603 	ucmd->uscsi_rqbuf = (caddr_t)&sense;
16604 	ucmd->uscsi_rqlen = sizeof (sense);
16605 
16606 	rval = bufunc(un, ucmd, FKIOCTL);
16607 
16608 	if (rval || ucmd->uscsi_status != 0) {
16609 		ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
16610 		    "media serial command returned %d scsi_status %d"
16611 		    " rqstatus %d", rval, ucmd->uscsi_status,
16612 		    ucmd->uscsi_rqstatus);
16613 		/*
16614 		 * If this returns invalid operation code don't try again.
16615 		 */
16616 		if (sense.es_key == KEY_ILLEGAL_REQUEST &&
16617 		    sense.es_add_code == 0x20) {
16618 			rval = ENOTTY;
16619 		} else if (rval == 0) {
16620 			rval = EIO;
16621 		}
16622 		un->un_status = 0;
16623 	} else {
16624 		int act_size;
16625 
16626 		/*
16627 		 * get reported size.
16628 		 */
16629 		act_size = (int)buf[3] | (int)(buf[2] << 8) |
16630 		    (int)(buf[1] << 16) | (int)(buf[0] << 24);
16631 
16632 		/* documentation says mod 4. */
16633 		while (act_size & 3) {
16634 			act_size++;
16635 		}
16636 
16637 		/*
16638 		 * If reported size is larger that we our buffer.
16639 		 * Free the old one and allocate one that is larger
16640 		 * enough and re-issuse the command.
16641 		 */
16642 		if (act_size + 4 > size) {
16643 			kmem_free(buf, size);
16644 			size = act_size + 4;
16645 			goto upsize;
16646 		}
16647 
16648 		if (act_size == 0) {
16649 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
16650 			    "media serial number is not available");
16651 			un->un_status = 0;
16652 			rval = 0;
16653 		} else {
16654 			/*
16655 			 * set data pointer to point to the start
16656 			 * of that serial number.
16657 			 */
16658 			un->un_media_id_method =
16659 			    st_get_media_id_via_media_serial_cmd;
16660 			rval =
16661 			    st_check_if_media_changed(un, &buf[4], act_size);
16662 		}
16663 	}
16664 
16665 	kmem_free(ucmd, sizeof (struct uscsi_cmd));
16666 	kmem_free(buf, size);
16667 
16668 	return (rval);
16669 }
16670 
16671 
16672 /* ARGSUSED */
16673 static int
16674 st_bogus_media_id(struct scsi_tape *un, ubufunc_t bufunc)
16675 {
16676 	ST_FUNC(ST_DEVINFO, st_bogus_media_id);
16677 
16678 	ASSERT(un->un_media_id == NULL || un->un_media_id == bogusID);
16679 	ASSERT(un->un_media_id_len == 0);
16680 	un->un_media_id = (char *)bogusID;
16681 	un->un_media_id_len = 0;
16682 	return (0);
16683 }
16684 
16685 typedef int (*media_chk_function)(struct scsi_tape *, ubufunc_t bufunc);
16686 
16687 media_chk_function media_chk_functions[] = {
16688 	st_get_media_id_via_media_serial_cmd,
16689 	st_get_media_id_via_read_attribute,
16690 	st_bogus_media_id
16691 };
16692 
16693 static int
16694 st_get_media_identification(struct scsi_tape *un, ubufunc_t bufunc)
16695 {
16696 	int result = 0;
16697 	int i;
16698 
16699 	ST_FUNC(ST_DEVINFO, st_get_media_identification);
16700 
16701 	for (i = 0; i < ST_NUM_MEMBERS(media_chk_functions); i++) {
16702 		if (result == ENOTTY) {
16703 			/*
16704 			 * Last operation type not supported by this device.
16705 			 * Make so next time it doesn`t do that again.
16706 			 */
16707 			un->un_media_id_method = media_chk_functions[i];
16708 		} else if (un->un_media_id_method != media_chk_functions[i] &&
16709 		    un->un_media_id_method != st_get_media_identification) {
16710 			continue;
16711 		}
16712 		result = media_chk_functions[i](un, bufunc);
16713 		/*
16714 		 * If result indicates the function was successful or
16715 		 * that the media is not the same as last known, break.
16716 		 */
16717 		if (result == 0 || result == ESPIPE) {
16718 			break;
16719 		}
16720 	}
16721 
16722 	return (result);
16723 }
16724 
16725 static errstate
16726 st_command_recovery(struct scsi_tape *un, struct scsi_pkt *pkt,
16727     errstate onentry)
16728 {
16729 
16730 	int ret;
16731 	st_err_info *errinfo;
16732 	recov_info *ri = (recov_info *)pkt->pkt_private;
16733 
16734 	ST_FUNC(ST_DEVINFO, st_command_recovery);
16735 
16736 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
16737 
16738 	ASSERT(un->un_recov_buf_busy == 0);
16739 
16740 	/*
16741 	 * Don't try and recover a reset that this device sent.
16742 	 */
16743 	if (un->un_rsvd_status & ST_INITIATED_RESET &&
16744 	    onentry == DEVICE_RESET) {
16745 		return (COMMAND_DONE_ERROR);
16746 	}
16747 
16748 	/*
16749 	 * See if expected position was passed with scsi_pkt.
16750 	 */
16751 	if (ri->privatelen == sizeof (recov_info)) {
16752 
16753 		/*
16754 		 * Not for this command.
16755 		 */
16756 		if (ri->cmd_attrib->do_not_recover) {
16757 			return (COMMAND_DONE_ERROR);
16758 		}
16759 
16760 		/*
16761 		 * Create structure to hold all error state info.
16762 		 */
16763 		errinfo = kmem_zalloc(ST_ERR_INFO_SIZE, KM_SLEEP);
16764 		errinfo->ei_error_type = onentry;
16765 		errinfo->ei_failing_bp = ri->cmd_bp;
16766 		COPY_POS(&errinfo->ei_expected_pos, &ri->pos);
16767 	} else {
16768 		/* disabled */
16769 		return (COMMAND_DONE_ERROR);
16770 	}
16771 
16772 	bcopy(pkt, &errinfo->ei_failed_pkt, scsi_pkt_size());
16773 	bcopy(pkt->pkt_scbp, &errinfo->ei_failing_status, SECMDS_STATUS_SIZE);
16774 	ret = ddi_taskq_dispatch(un->un_recov_taskq, st_recover, errinfo,
16775 	    DDI_NOSLEEP);
16776 	ASSERT(ret == DDI_SUCCESS);
16777 	if (ret != DDI_SUCCESS) {
16778 		kmem_free(errinfo, ST_ERR_INFO_SIZE);
16779 		return (COMMAND_DONE_ERROR);
16780 	}
16781 	return (JUST_RETURN); /* release calling thread */
16782 }
16783 
16784 
16785 static void
16786 st_recov_ret(struct scsi_tape *un, st_err_info *errinfo, errstate err)
16787 {
16788 	int error_number;
16789 	buf_t *bp;
16790 
16791 
16792 	ST_FUNC(ST_DEVINFO, st_recov_ret);
16793 
16794 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
16795 #if !defined(lint)
16796 	_NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex))
16797 #endif
16798 
16799 	bp = errinfo->ei_failing_bp;
16800 	kmem_free(errinfo, ST_ERR_INFO_SIZE);
16801 
16802 	switch (err) {
16803 	case JUST_RETURN:
16804 		mutex_exit(&un->un_sd->sd_mutex);
16805 		return;
16806 
16807 	case COMMAND_DONE:
16808 	case COMMAND_DONE_ERROR_RECOVERED:
16809 		ST_DO_KSTATS(bp, kstat_runq_exit);
16810 		error_number = 0;
16811 		break;
16812 
16813 	default:
16814 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
16815 		    "st_recov_ret with unhandled errstat %d\n", err);
16816 		/* FALLTHROUGH */
16817 	case COMMAND_DONE_ERROR:
16818 		un->un_pos.pmode = invalid;
16819 		un->un_running.pmode = invalid;
16820 		/* FALLTHROUGH */
16821 	case COMMAND_DONE_EACCES:
16822 		ST_DO_KSTATS(bp, kstat_waitq_exit);
16823 		ST_DO_ERRSTATS(un, st_transerrs);
16824 		error_number = EIO;
16825 		st_set_pe_flag(un);
16826 		break;
16827 
16828 	}
16829 
16830 	st_bioerror(bp, error_number);
16831 	st_done_and_mutex_exit(un, bp);
16832 }
16833 
16834 
16835 static void
16836 st_recover(void *arg)
16837 {
16838 	st_err_info *const errinfo = (st_err_info *)arg;
16839 	uchar_t com = errinfo->ei_failed_pkt.pkt_cdbp[0];
16840 	struct scsi_tape *un;
16841 	tapepos_t cur_pos;
16842 	int rval;
16843 	errstate status = COMMAND_DONE_ERROR;
16844 	recov_info *rcv;
16845 	buf_t *bp;
16846 
16847 
16848 	rcv = errinfo->ei_failed_pkt.pkt_private;
16849 	ASSERT(rcv->privatelen == sizeof (recov_info));
16850 	bp = rcv->cmd_bp;
16851 
16852 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
16853 
16854 	ASSERT(un != NULL);
16855 
16856 	mutex_enter(ST_MUTEX);
16857 
16858 	ST_FUNC(ST_DEVINFO, st_recover);
16859 
16860 	ST_CDB(ST_DEVINFO, "Recovering command",
16861 	    (caddr_t)errinfo->ei_failed_pkt.pkt_cdbp);
16862 	ST_SENSE(ST_DEVINFO, "sense status for failed command",
16863 	    (caddr_t)&errinfo->ei_failing_status,
16864 	    sizeof (struct scsi_arq_status));
16865 	ST_POS(ST_DEVINFO, rcv->cmd_attrib->recov_pos_type == POS_STARTING ?
16866 	    "starting position for recovery command" :
16867 	    "expected position for recovery command",
16868 	    &errinfo->ei_expected_pos);
16869 
16870 	rval = st_test_path_to_device(un);
16871 
16872 	ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
16873 	    "st_recover called with %s, TUR returned %d\n",
16874 	    errstatenames[errinfo->ei_error_type], rval);
16875 	/*
16876 	 * If the drive responed to the TUR lets try and get it to sync
16877 	 * any data it might have in the buffer.
16878 	 */
16879 	if (rval == 0 && rcv->cmd_attrib->chg_tape_data) {
16880 		rval = st_rcmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD);
16881 		if (rval) {
16882 			ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
16883 			    "st_recover failed to flush, returned %d\n", rval);
16884 			st_recov_ret(un, errinfo, COMMAND_DONE_ERROR);
16885 			return;
16886 		}
16887 	}
16888 	switch (errinfo->ei_error_type) {
16889 	case ATTEMPT_RETRY:
16890 	case COMMAND_TIMEOUT:
16891 	case DEVICE_RESET:
16892 	case PATH_FAILED:
16893 		/*
16894 		 * For now if we can't talk to the device we are done.
16895 		 * If the drive is reserved we can try to get it back.
16896 		 */
16897 		if (rval != 0 && rval != EACCES) {
16898 			st_recov_ret(un, errinfo, COMMAND_DONE_ERROR);
16899 			return;
16900 		}
16901 
16902 		/*
16903 		 * If reservation conflict and do a preempt, fail it.
16904 		 */
16905 		if ((un->un_rsvd_status &
16906 		    (ST_APPLICATION_RESERVATIONS | ST_RESERVE)) != 0) {
16907 			if ((errinfo->ei_failed_pkt.pkt_cdbp[0] ==
16908 			    SCMD_PERSISTENT_RESERVE_OUT) &&
16909 			    (errinfo->ei_failed_pkt.pkt_cdbp[1] ==
16910 			    ST_SA_SCSI3_PREEMPT) &&
16911 			    (SCBP_C(&errinfo->ei_failed_pkt) ==
16912 			    STATUS_RESERVATION_CONFLICT)) {
16913 				st_recov_ret(un, errinfo, COMMAND_DONE_ERROR);
16914 				return;
16915 			}
16916 		}
16917 
16918 		/*
16919 		 * If we have already set a scsi II reserve and get a
16920 		 * conflict on a scsi III type reserve fail without
16921 		 * any attempt to recover.
16922 		 */
16923 		if ((un->un_rsvd_status & ST_RESERVE | ST_PRESERVE_RESERVE) &&
16924 		    (errinfo->ei_failed_pkt.pkt_cdbp[0] ==
16925 		    SCMD_PERSISTENT_RESERVE_OUT) ||
16926 		    (errinfo->ei_failed_pkt.pkt_cdbp[0] ==
16927 		    SCMD_PERSISTENT_RESERVE_IN)) {
16928 			st_recov_ret(un, errinfo, COMMAND_DONE_EACCES);
16929 			return;
16930 		}
16931 
16932 		/*
16933 		 * If scsi II lost reserve try and get it back.
16934 		 */
16935 		if ((((un->un_rsvd_status &
16936 		    (ST_LOST_RESERVE | ST_APPLICATION_RESERVATIONS)) ==
16937 		    ST_LOST_RESERVE)) &&
16938 		    (errinfo->ei_failed_pkt.pkt_cdbp[0] != SCMD_RELEASE)) {
16939 			rval = st_reserve_release(un, ST_RESERVE,
16940 			    st_uscsi_rcmd);
16941 			if (rval != 0) {
16942 				if (st_take_ownership(un, st_uscsi_rcmd) != 0) {
16943 					st_recov_ret(un, errinfo,
16944 					    COMMAND_DONE_EACCES);
16945 					return;
16946 				}
16947 			}
16948 			un->un_rsvd_status |= ST_RESERVE;
16949 			un->un_rsvd_status &= ~(ST_RELEASE | ST_LOST_RESERVE |
16950 			    ST_RESERVATION_CONFLICT | ST_INITIATED_RESET);
16951 		}
16952 		rval = st_make_sure_mode_data_is_correct(un, st_uscsi_rcmd);
16953 		if (rval) {
16954 			st_recov_ret(un, errinfo, COMMAND_DONE_ERROR);
16955 			return;
16956 		}
16957 		break;
16958 	case DEVICE_TAMPER:
16959 		/*
16960 		 * Check if the ASC/ASCQ says mode data has changed.
16961 		 */
16962 		if ((errinfo->ei_failing_status.sts_sensedata.es_add_code ==
16963 		    0x2a) &&
16964 		    (errinfo->ei_failing_status.sts_sensedata.es_qual_code ==
16965 		    0x01)) {
16966 			/*
16967 			 * See if mode sense changed.
16968 			 */
16969 			rval = st_make_sure_mode_data_is_correct(un,
16970 			    st_uscsi_rcmd);
16971 			if (rval) {
16972 				st_recov_ret(un, errinfo, COMMAND_DONE_ERROR);
16973 				return;
16974 			}
16975 		}
16976 		/*
16977 		 * if we have a media id and its not bogus.
16978 		 * Check to see if it the same.
16979 		 */
16980 		if (un->un_media_id != NULL && un->un_media_id != bogusID) {
16981 			rval = st_get_media_identification(un, st_uscsi_rcmd);
16982 			if (rval == ESPIPE) {
16983 				st_recov_ret(un, errinfo, COMMAND_DONE_EACCES);
16984 				return;
16985 			}
16986 		}
16987 		break;
16988 	default:
16989 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
16990 		    "Unhandled error type %s in st_recover() 0x%x\n",
16991 		    errstatenames[errinfo->ei_error_type], com);
16992 	}
16993 
16994 	/*
16995 	 * if command is retriable retry it.
16996 	 * Special case here. The command attribute for SCMD_REQUEST_SENSE
16997 	 * does not say that it is retriable. That because if you reissue a
16998 	 * request sense and the target responds the sense data will have
16999 	 * been consumed and no long be valid. If we get a busy status on
17000 	 * request sense while the state is ST_STATE_SENSING this will
17001 	 * reissue that pkt.
17002 	 *
17003 	 * XXX If this request sense gets sent to a different port then
17004 	 * the original command that failed was sent on it will not get
17005 	 * valid sense data for that command.
17006 	 */
17007 	if (rcv->cmd_attrib->retriable || un->un_rqs_bp == bp) {
17008 		status = st_recover_reissue_pkt(un, &errinfo->ei_failed_pkt);
17009 
17010 	/*
17011 	 * if drive doesn't support read position we are done
17012 	 */
17013 	} else if (un->un_read_pos_type == NO_POS) {
17014 		status = COMMAND_DONE_ERROR;
17015 	/*
17016 	 * If this command results in a changed tape position,
17017 	 * lets see where we are.
17018 	 */
17019 	} else if (rcv->cmd_attrib->chg_tape_pos) {
17020 		/*
17021 		 * XXX May be a reason to choose a different type here.
17022 		 * Long format has file position information.
17023 		 * Short and Extended have information about whats
17024 		 * in the buffer. St's positioning assumes in the buffer
17025 		 * to be the same as on tape.
17026 		 */
17027 		rval = st_compare_expected_position(un, errinfo,
17028 		    rcv->cmd_attrib, &cur_pos);
17029 		if (rval == 0) {
17030 			status = COMMAND_DONE;
17031 		} else if (rval == EAGAIN) {
17032 			status = st_recover_reissue_pkt(un,
17033 			    &errinfo->ei_failed_pkt);
17034 		} else {
17035 			status = COMMAND_DONE_ERROR;
17036 		}
17037 	} else {
17038 		ASSERT(0);
17039 	}
17040 
17041 	st_recov_ret(un, errinfo, status);
17042 }
17043 
17044 static void
17045 st_recov_cb(struct scsi_pkt *pkt)
17046 {
17047 	struct scsi_tape *un;
17048 	struct buf *bp;
17049 	recov_info *rcv;
17050 	errstate action = COMMAND_DONE_ERROR;
17051 	int timout = ST_TRAN_BUSY_TIMEOUT; /* short (default) timeout */
17052 
17053 	/*
17054 	 * Get the buf from the packet.
17055 	 */
17056 	rcv = pkt->pkt_private;
17057 	ASSERT(rcv->privatelen == sizeof (recov_info));
17058 	bp = rcv->cmd_bp;
17059 
17060 	/*
17061 	 * get the unit from the buf.
17062 	 */
17063 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
17064 	ASSERT(un != NULL);
17065 
17066 	ST_FUNC(ST_DEVINFO, st_recov_cb);
17067 
17068 	mutex_enter(ST_MUTEX);
17069 
17070 	ASSERT(bp == un->un_recov_buf);
17071 
17072 
17073 	switch (pkt->pkt_reason) {
17074 	case CMD_CMPLT:
17075 		if (un->un_arq_enabled && pkt->pkt_state & STATE_ARQ_DONE) {
17076 			action = st_handle_autosense(un, bp, &rcv->pos);
17077 		} else  if ((SCBP(pkt)->sts_busy) ||
17078 		    (SCBP(pkt)->sts_chk) ||
17079 		    (SCBP(pkt)->sts_vu7)) {
17080 			action = st_check_error(un, pkt);
17081 		} else {
17082 			action = COMMAND_DONE;
17083 		}
17084 		break;
17085 	case CMD_TIMEOUT:
17086 		action = COMMAND_TIMEOUT;
17087 		break;
17088 	case CMD_TRAN_ERR:
17089 		action = QUE_COMMAND;
17090 		break;
17091 	case CMD_DEV_GONE:
17092 		if (un->un_multipath)
17093 			action = PATH_FAILED;
17094 		else
17095 			action = COMMAND_DONE_ERROR;
17096 		break;
17097 	default:
17098 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
17099 		    "pkt_reason not handled yet %s",
17100 		    scsi_rname(pkt->pkt_reason));
17101 		action = COMMAND_DONE_ERROR;
17102 	}
17103 
17104 	/*
17105 	 * check for undetected path failover.
17106 	 */
17107 	if (un->un_multipath) {
17108 		if (scsi_pkt_allocated_correctly(pkt) &&
17109 		    (un->un_last_path_instance != pkt->pkt_path_instance)) {
17110 			if (un->un_state > ST_STATE_OPENING) {
17111 				ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17112 				    "Failover detected in recovery, action is "
17113 				    "%s\n", errstatenames[action]);
17114 			}
17115 			un->un_last_path_instance = pkt->pkt_path_instance;
17116 		}
17117 	}
17118 
17119 	ST_RECOV(ST_DEVINFO, st_label, CE_WARN,
17120 	    "Recovery call back got %s status on %s\n",
17121 	    errstatenames[action], st_print_scsi_cmd(pkt->pkt_cdbp[0]));
17122 
17123 	switch (action) {
17124 	case COMMAND_DONE:
17125 		break;
17126 
17127 	case COMMAND_DONE_EACCES:
17128 		bioerror(bp, EACCES);
17129 		break;
17130 
17131 	case COMMAND_DONE_ERROR_RECOVERED: /* XXX maybe wrong */
17132 		ASSERT(0);
17133 		break;
17134 
17135 	case COMMAND_TIMEOUT:
17136 	case COMMAND_DONE_ERROR:
17137 		bioerror(bp, EIO);
17138 		break;
17139 
17140 	case DEVICE_RESET:
17141 	case QUE_BUSY_COMMAND:
17142 	case PATH_FAILED:
17143 		/* longish timeout */
17144 		timout = ST_STATUS_BUSY_TIMEOUT;
17145 		/* FALLTHRU */
17146 	case QUE_COMMAND:
17147 	case DEVICE_TAMPER:
17148 	case ATTEMPT_RETRY:
17149 		/*
17150 		 * let st_handle_intr_busy put this bp back on waitq and make
17151 		 * checks to see if it is ok to requeue the command.
17152 		 */
17153 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
17154 
17155 		/*
17156 		 * Save the throttle before setting up the timeout
17157 		 */
17158 		if (un->un_throttle) {
17159 			un->un_last_throttle = un->un_throttle;
17160 		}
17161 		mutex_exit(ST_MUTEX);
17162 		if (st_handle_intr_busy(un, bp, timout) == 0) {
17163 			return;		/* timeout is setup again */
17164 		}
17165 		mutex_enter(ST_MUTEX);
17166 		un->un_pos.pmode = invalid;
17167 		un->un_err_resid = bp->b_resid = bp->b_bcount;
17168 		st_bioerror(bp, EIO);
17169 		st_set_pe_flag(un);
17170 		break;
17171 
17172 	default:
17173 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
17174 		    "Unhandled recovery state 0x%x\n", action);
17175 		un->un_pos.pmode = invalid;
17176 		un->un_err_resid = bp->b_resid = bp->b_bcount;
17177 		st_bioerror(bp, EIO);
17178 		st_set_pe_flag(un);
17179 		break;
17180 	}
17181 
17182 	st_done_and_mutex_exit(un, bp);
17183 }
17184 
17185 static int
17186 st_rcmd(struct scsi_tape *un, int com, int64_t count, int wait)
17187 {
17188 	struct buf *bp;
17189 	int err;
17190 
17191 	ST_FUNC(ST_DEVINFO, st_rcmd);
17192 
17193 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
17194 	    "st_rcmd(un = 0x%p, com = 0x%x, count = %"PRIx64", wait = %d)\n",
17195 	    (void *)un, com, count, wait);
17196 
17197 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
17198 	ASSERT(mutex_owned(ST_MUTEX));
17199 
17200 #ifdef STDEBUG
17201 	if ((st_debug & 0x7)) {
17202 		st_debug_cmds(un, com, count, wait);
17203 	}
17204 #endif
17205 
17206 	while (un->un_recov_buf_busy)
17207 		cv_wait(&un->un_recov_buf_cv, ST_MUTEX);
17208 	un->un_recov_buf_busy = 1;
17209 
17210 	bp = un->un_recov_buf;
17211 	bzero(bp, sizeof (buf_t));
17212 
17213 	bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC;
17214 
17215 	err = st_setup_cmd(un, bp, com, count);
17216 
17217 	un->un_recov_buf_busy = 0;
17218 
17219 	cv_signal(&un->un_recov_buf_cv);
17220 
17221 	return (err);
17222 }
17223 
17224 /* args used */
17225 static int
17226 st_uscsi_rcmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, int flag)
17227 {
17228 	int rval;
17229 	buf_t *bp;
17230 
17231 	ST_FUNC(ST_DEVINFO, st_uscsi_rcmd);
17232 	ASSERT(flag == FKIOCTL);
17233 
17234 	/*
17235 	 * Get buffer resources...
17236 	 */
17237 	while (un->un_recov_buf_busy)
17238 		cv_wait(&un->un_recov_buf_cv, ST_MUTEX);
17239 	un->un_recov_buf_busy = 1;
17240 
17241 	bp = un->un_recov_buf;
17242 	bzero(bp, sizeof (buf_t));
17243 
17244 	bp->b_forw = (struct buf *)(uintptr_t)ucmd->uscsi_cdb[0];
17245 	bp->b_back = (struct buf *)ucmd;
17246 
17247 	mutex_exit(ST_MUTEX);
17248 	rval = scsi_uscsi_handle_cmd(un->un_dev, UIO_SYSSPACE, ucmd,
17249 	    st_strategy, bp, NULL);
17250 	mutex_enter(ST_MUTEX);
17251 
17252 	ucmd->uscsi_resid = bp->b_resid;
17253 
17254 	/*
17255 	 * Free resources
17256 	 */
17257 	un->un_recov_buf_busy = 0;
17258 	cv_signal(&un->un_recov_buf_cv);
17259 
17260 	return (rval);
17261 }
17262 
17263 /*
17264  * Add data to scsi_pkt to help know what to do if the command fails.
17265  */
17266 static void
17267 st_add_recovery_info_to_pkt(struct scsi_tape *un, buf_t *bp,
17268     struct scsi_pkt *pkt)
17269 {
17270 	uint64_t count;
17271 	recov_info *rinfo = (recov_info *)pkt->pkt_private;
17272 
17273 	ST_FUNC(ST_DEVINFO, st_add_recovery_info_to_pkt);
17274 
17275 	ASSERT(rinfo->privatelen == sizeof (pkt_info) ||
17276 	    rinfo->privatelen == sizeof (recov_info));
17277 
17278 	SET_BP_PKT(bp, pkt);
17279 	rinfo->cmd_bp = bp;
17280 
17281 	if (rinfo->privatelen != sizeof (recov_info)) {
17282 		return;
17283 	}
17284 
17285 	rinfo->cmd_bp = bp;
17286 
17287 	rinfo->cmd_attrib = NULL;
17288 
17289 	/*
17290 	 * lookup the command attributes and add them to the recovery info.
17291 	 */
17292 	rinfo->cmd_attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]);
17293 
17294 	ASSERT(rinfo->cmd_attrib);
17295 
17296 	/*
17297 	 * For commands that there is no way to figure the expected position
17298 	 * once completed, we save the position the command was started from
17299 	 * so that if they fail we can position back and try again.
17300 	 * This has already been done in st_cmd() or st_iscsi_cmd().
17301 	 */
17302 	if (rinfo->cmd_attrib->recov_pos_type == POS_STARTING) {
17303 		/* save current position as the starting position. */
17304 		COPY_POS(&rinfo->pos, &un->un_pos);
17305 		un->un_running.pmode = invalid;
17306 		return;
17307 	}
17308 
17309 	/*
17310 	 * Don't want to update the running position for recovery.
17311 	 */
17312 	if (bp == un->un_recov_buf) {
17313 		rinfo->pos.pmode = un->un_running.pmode;
17314 		return;
17315 	}
17316 	/*
17317 	 * If running position is invalid copy the current position.
17318 	 * Running being set invalid means we are not in a read, write
17319 	 * or write filemark sequence.
17320 	 * We'll copy the current position and start from there.
17321 	 */
17322 	if (un->un_running.pmode == invalid) {
17323 		COPY_POS(&un->un_running, &un->un_pos);
17324 		COPY_POS(&rinfo->pos, &un->un_running);
17325 	} else {
17326 		COPY_POS(&rinfo->pos, &un->un_running);
17327 		if (rinfo->pos.pmode == legacy) {
17328 			/*
17329 			 * Always should be more logical blocks then
17330 			 * data blocks and files marks.
17331 			 */
17332 			ASSERT((rinfo->pos.blkno >= 0) ?
17333 			    rinfo->pos.lgclblkno >=
17334 			    (rinfo->pos.blkno + rinfo->pos.fileno) : 1);
17335 		}
17336 	}
17337 
17338 	/*
17339 	 * If the command is not expected to change the drive position
17340 	 * then the running position should be the expected position.
17341 	 */
17342 	if (rinfo->cmd_attrib->chg_tape_pos == 0) {
17343 		ASSERT(rinfo->cmd_attrib->chg_tape_direction == DIR_NONE);
17344 		return;
17345 	}
17346 
17347 	if (rinfo->cmd_attrib->explicit_cmd_set) {
17348 		ASSERT(rinfo->pos.pmode != invalid);
17349 		ASSERT(rinfo->cmd_attrib->get_cnt);
17350 		count = rinfo->cmd_attrib->get_cnt(pkt->pkt_cdbp);
17351 		/*
17352 		 * This is a user generated CDB.
17353 		 */
17354 		if (bp == un->un_sbufp) {
17355 			uint64_t lbn;
17356 
17357 			lbn = rinfo->cmd_attrib->get_lba(pkt->pkt_cdbp);
17358 
17359 			/*
17360 			 * See if this CDB will generate a locate or change
17361 			 * partition.
17362 			 */
17363 			if ((lbn != un->un_running.lgclblkno) ||
17364 			    (pkt->pkt_cdbp[3] != un->un_running.partition)) {
17365 				rinfo->pos.partition = pkt->pkt_cdbp[3];
17366 				rinfo->pos.pmode = logical;
17367 				rinfo->pos.lgclblkno = lbn;
17368 				un->un_running.partition = pkt->pkt_cdbp[3];
17369 				un->un_running.pmode = logical;
17370 				un->un_running.lgclblkno = lbn;
17371 			}
17372 		} else {
17373 			uint64_t lbn = un->un_running.lgclblkno;
17374 
17375 			pkt->pkt_cdbp[3]  = (uchar_t)un->un_running.partition;
17376 
17377 			pkt->pkt_cdbp[4]  = (uchar_t)(lbn >> 56);
17378 			pkt->pkt_cdbp[5]  = (uchar_t)(lbn >> 48);
17379 			pkt->pkt_cdbp[6]  = (uchar_t)(lbn >> 40);
17380 			pkt->pkt_cdbp[7]  = (uchar_t)(lbn >> 32);
17381 			pkt->pkt_cdbp[8]  = (uchar_t)(lbn >> 24);
17382 			pkt->pkt_cdbp[9]  = (uchar_t)(lbn >> 16);
17383 			pkt->pkt_cdbp[10] = (uchar_t)(lbn >> 8);
17384 			pkt->pkt_cdbp[11] = (uchar_t)(lbn);
17385 		}
17386 		rinfo->pos.lgclblkno += count;
17387 		rinfo->pos.blkno += count;
17388 		un->un_running.lgclblkno += count;
17389 		return;
17390 	}
17391 
17392 	if (rinfo->cmd_attrib->chg_tape_pos) {
17393 
17394 		/* should not have got an invalid position from running. */
17395 		if (un->un_mediastate == MTIO_INSERTED) {
17396 			ASSERT(rinfo->pos.pmode != invalid);
17397 		}
17398 
17399 		/* should have either a get count or or get lba function */
17400 		ASSERT(rinfo->cmd_attrib->get_cnt != NULL ||
17401 		    rinfo->cmd_attrib->get_lba != NULL);
17402 
17403 		/* only explicit commands have both and they're handled above */
17404 		ASSERT(!(rinfo->cmd_attrib->get_cnt != NULL &&
17405 		    rinfo->cmd_attrib->get_lba != NULL));
17406 
17407 		/* if it has a get count function */
17408 		if (rinfo->cmd_attrib->get_cnt != NULL) {
17409 			count = rinfo->cmd_attrib->get_cnt(pkt->pkt_cdbp);
17410 			if (count == 0) {
17411 				return;
17412 			}
17413 			/*
17414 			 * Changes position but doesn't transfer data.
17415 			 * i.e. rewind, write_file_mark and load.
17416 			 */
17417 			if (rinfo->cmd_attrib->transfers_data == TRAN_NONE) {
17418 				switch (rinfo->cmd_attrib->chg_tape_direction) {
17419 				case DIR_NONE: /* Erase */
17420 					ASSERT(rinfo->cmd_attrib->cmd ==
17421 					    SCMD_ERASE);
17422 					break;
17423 				case DIR_FORW: /* write_file_mark */
17424 					rinfo->pos.fileno += count;
17425 					rinfo->pos.lgclblkno += count;
17426 					rinfo->pos.blkno = 0;
17427 					un->un_running.fileno += count;
17428 					un->un_running.lgclblkno += count;
17429 					un->un_running.blkno = 0;
17430 					break;
17431 				case DIR_REVC: /* rewind */
17432 					rinfo->pos.fileno = 0;
17433 					rinfo->pos.lgclblkno = 0;
17434 					rinfo->pos.blkno = 0;
17435 					rinfo->pos.eof = ST_NO_EOF;
17436 					rinfo->pos.pmode = legacy;
17437 					un->un_running.fileno = 0;
17438 					un->un_running.lgclblkno = 0;
17439 					un->un_running.blkno = 0;
17440 					un->un_running.eof = ST_NO_EOF;
17441 					if (un->un_running.pmode != legacy)
17442 						un->un_running.pmode = legacy;
17443 					break;
17444 				case DIR_EITH: /* Load unload */
17445 					ASSERT(rinfo->cmd_attrib->cmd ==
17446 					    SCMD_LOAD);
17447 					switch (count & (LD_LOAD | LD_RETEN |
17448 					    LD_RETEN | LD_HOLD)) {
17449 					case LD_UNLOAD:
17450 					case LD_RETEN:
17451 					case LD_HOLD:
17452 					case LD_LOAD | LD_HOLD:
17453 					case LD_EOT | LD_HOLD:
17454 					case LD_RETEN | LD_HOLD:
17455 						rinfo->pos.pmode = invalid;
17456 						un->un_running.pmode = invalid;
17457 						break;
17458 					case LD_EOT:
17459 					case LD_LOAD | LD_EOT:
17460 						rinfo->pos.eof = ST_EOT;
17461 						rinfo->pos.pmode = invalid;
17462 						un->un_running.eof = ST_EOT;
17463 						un->un_running.pmode = invalid;
17464 						break;
17465 					case LD_LOAD:
17466 					case LD_RETEN | LD_LOAD:
17467 						rinfo->pos.fileno = 0;
17468 						rinfo->pos.lgclblkno = 0;
17469 						rinfo->pos.blkno = 0;
17470 						rinfo->pos.eof = ST_NO_EOF;
17471 						rinfo->pos.pmode = legacy;
17472 						un->un_running.fileno = 0;
17473 						un->un_running.lgclblkno = 0;
17474 						un->un_running.blkno = 0;
17475 						un->un_running.eof = ST_NO_EOF;
17476 						break;
17477 					default:
17478 						ASSERT(0);
17479 					}
17480 					break;
17481 				default:
17482 					ASSERT(0);
17483 					break;
17484 				}
17485 			} else {
17486 				/*
17487 				 * Changes position and does transfer data.
17488 				 * i.e. read or write.
17489 				 */
17490 				switch (rinfo->cmd_attrib->chg_tape_direction) {
17491 				case DIR_FORW:
17492 					rinfo->pos.lgclblkno += count;
17493 					rinfo->pos.blkno += count;
17494 					un->un_running.lgclblkno += count;
17495 					un->un_running.blkno += count;
17496 					break;
17497 				case DIR_REVC:
17498 					rinfo->pos.lgclblkno -= count;
17499 					rinfo->pos.blkno -= count;
17500 					un->un_running.lgclblkno -= count;
17501 					un->un_running.blkno -= count;
17502 					break;
17503 				default:
17504 					ASSERT(0);
17505 					break;
17506 				}
17507 			}
17508 		} else if (rinfo->cmd_attrib->get_lba != NULL) {
17509 			/* Have a get LBA fuction. i.e. Locate */
17510 			ASSERT(rinfo->cmd_attrib->chg_tape_direction ==
17511 			    DIR_EITH);
17512 			count = rinfo->cmd_attrib->get_lba(pkt->pkt_cdbp);
17513 			un->un_running.lgclblkno = count;
17514 			un->un_running.blkno = 0;
17515 			un->un_running.fileno = 0;
17516 			un->un_running.pmode = logical;
17517 			rinfo->pos.lgclblkno = count;
17518 			rinfo->pos.pmode = invalid;
17519 		} else {
17520 			ASSERT(0);
17521 		}
17522 		return;
17523 	}
17524 
17525 	ST_CDB(ST_DEVINFO, "Unhanded CDB for position prediction",
17526 	    (char *)pkt->pkt_cdbp);
17527 
17528 }
17529 
17530 static int
17531 st_make_sure_mode_data_is_correct(struct scsi_tape *un, ubufunc_t ubf)
17532 {
17533 	int rval;
17534 
17535 	ST_FUNC(ST_DEVINFO, st_make_sure_mode_data_is_correct);
17536 
17537 	/*
17538 	 * check to see if mode data has changed.
17539 	 */
17540 	rval = st_check_mode_for_change(un, ubf);
17541 	if (rval) {
17542 		rval = st_gen_mode_select(un, ubf, un->un_mspl,
17543 		    sizeof (struct seq_mode));
17544 	}
17545 	if (un->un_tlr_flag != TLR_NOT_SUPPORTED) {
17546 		rval |= st_set_target_TLR_mode(un, ubf);
17547 	}
17548 	return (rval);
17549 }
17550 
17551 static int
17552 st_check_mode_for_change(struct scsi_tape *un, ubufunc_t ubf)
17553 {
17554 	struct seq_mode *current;
17555 	int rval;
17556 	int i;
17557 	caddr_t this;
17558 	caddr_t that;
17559 
17560 	ST_FUNC(ST_DEVINFO, st_check_mode_for_change);
17561 
17562 	/* recovery called with mode tamper before mode selection */
17563 	if (un->un_comp_page == (ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE)) {
17564 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17565 		    "Mode Select not done yet");
17566 		return (0);
17567 	}
17568 
17569 	current = kmem_zalloc(sizeof (struct seq_mode), KM_SLEEP);
17570 
17571 	rval = st_gen_mode_sense(un, ubf, un->un_comp_page, current,
17572 	    sizeof (struct seq_mode));
17573 	if (rval != 0) {
17574 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17575 		    "Mode Sense for mode verification failed");
17576 		kmem_free(current, sizeof (struct seq_mode));
17577 		return (rval);
17578 	}
17579 
17580 	this = (caddr_t)current;
17581 	that = (caddr_t)un->un_mspl;
17582 
17583 	rval = bcmp(this, that, sizeof (struct seq_mode));
17584 	if (rval == 0) {
17585 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17586 		    "Found no changes in mode data");
17587 	}
17588 #ifdef STDEBUG
17589 	else {
17590 		for (i = 1; i < sizeof (struct seq_mode); i++) {
17591 			if (this[i] != that[i]) {
17592 				ST_RECOV(ST_DEVINFO, st_label, CE_CONT,
17593 				    "sense data changed at byte %d was "
17594 				    "0x%x now 0x%x", i,
17595 				    (uchar_t)that[i], (uchar_t)this[i]);
17596 			}
17597 		}
17598 	}
17599 #endif
17600 	kmem_free(current, sizeof (struct seq_mode));
17601 
17602 	return (rval);
17603 }
17604 
17605 static int
17606 st_test_path_to_device(struct scsi_tape *un)
17607 {
17608 	int rval = 0;
17609 	int limit = st_retry_count;
17610 
17611 	ST_FUNC(ST_DEVINFO, st_test_path_to_device);
17612 
17613 	/*
17614 	 * XXX Newer drives may not RESEVATION CONFLICT a TUR.
17615 	 */
17616 	do {
17617 		if (rval != 0) {
17618 			mutex_exit(ST_MUTEX);
17619 			delay(drv_usectohz(1000000));
17620 			mutex_enter(ST_MUTEX);
17621 		}
17622 		rval = st_rcmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
17623 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17624 		    "ping TUR returned 0x%x", rval);
17625 		limit--;
17626 	} while (((rval == EACCES) || (rval == EBUSY)) && limit);
17627 
17628 	if (un->un_status == KEY_NOT_READY || un->un_mediastate == MTIO_EJECTED)
17629 		rval = 0;
17630 
17631 	return (rval);
17632 }
17633 
17634 /*
17635  * Does read position using recov_buf and doesn't update un_pos.
17636  * Does what ever kind of read position you want.
17637  */
17638 static int
17639 st_recovery_read_pos(struct scsi_tape *un, read_p_types type,
17640     read_pos_data_t *raw)
17641 {
17642 	int rval;
17643 	struct uscsi_cmd cmd;
17644 	struct scsi_arq_status status;
17645 	char cdb[CDB_GROUP1];
17646 
17647 	ST_FUNC(ST_DEVINFO, st_recovery_read_pos);
17648 	bzero(&cmd, sizeof (cmd));
17649 
17650 	cdb[0] = SCMD_READ_POSITION;
17651 	cdb[1] = type;
17652 	cdb[2] = 0;
17653 	cdb[3] = 0;
17654 	cdb[4] = 0;
17655 	cdb[5] = 0;
17656 	cdb[6] = 0;
17657 	cdb[7] = 0;
17658 	cdb[8] = (type == EXT_POS) ? 28 : 0;
17659 	cdb[9] = 0;
17660 
17661 	cmd.uscsi_flags = USCSI_READ | USCSI_RQENABLE;
17662 	cmd.uscsi_timeout = un->un_dp->non_motion_timeout;
17663 	cmd.uscsi_cdb = cdb;
17664 	cmd.uscsi_cdblen = sizeof (cdb);
17665 	cmd.uscsi_rqlen = sizeof (status);
17666 	cmd.uscsi_rqbuf = (caddr_t)&status;
17667 	cmd.uscsi_bufaddr = (caddr_t)raw;
17668 	switch (type) {
17669 	case SHORT_POS:
17670 		cmd.uscsi_buflen = sizeof (tape_position_t);
17671 		break;
17672 	case LONG_POS:
17673 		cmd.uscsi_buflen = sizeof (tape_position_long_t);
17674 		break;
17675 	case EXT_POS:
17676 		cmd.uscsi_buflen = sizeof (tape_position_ext_t);
17677 		break;
17678 	default:
17679 		ASSERT(0);
17680 	}
17681 
17682 	rval = st_uscsi_rcmd(un, &cmd, FKIOCTL);
17683 	if (cmd.uscsi_status) {
17684 		rval = EIO;
17685 	}
17686 	return (rval);
17687 }
17688 
17689 static int
17690 st_recovery_get_position(struct scsi_tape *un, tapepos_t *read,
17691     read_pos_data_t *raw)
17692 {
17693 	int rval;
17694 	read_p_types type = un->un_read_pos_type;
17695 
17696 	ST_FUNC(ST_DEVINFO, st_recovery_get_position);
17697 
17698 	do {
17699 		rval = st_recovery_read_pos(un, type, raw);
17700 		if (rval != 0) {
17701 			switch (type) {
17702 			case SHORT_POS:
17703 				type = NO_POS;
17704 				break;
17705 
17706 			case LONG_POS:
17707 				type = EXT_POS;
17708 				break;
17709 
17710 			case EXT_POS:
17711 				type = SHORT_POS;
17712 				break;
17713 
17714 			default:
17715 				type = LONG_POS;
17716 				break;
17717 
17718 			}
17719 		} else {
17720 			if (type != un->un_read_pos_type) {
17721 				un->un_read_pos_type = type;
17722 			}
17723 			break;
17724 		}
17725 	} while (type != NO_POS);
17726 
17727 	if (rval == 0) {
17728 		rval = st_interpret_read_pos(un, read, type,
17729 		    sizeof (read_pos_data_t), (caddr_t)raw, 1);
17730 	}
17731 	return (rval);
17732 }
17733 
17734 /*
17735  * based on the command do we retry, continue or give up?
17736  * possable return values?
17737  *	zero do nothing looks fine.
17738  *	EAGAIN retry.
17739  *	EIO failed makes no sense.
17740  */
17741 static int
17742 st_compare_expected_position(struct scsi_tape *un, st_err_info *ei,
17743     cmd_attribute const * cmd_att, tapepos_t *read)
17744 {
17745 	int rval;
17746 	read_pos_data_t *readp_datap;
17747 
17748 	ST_FUNC(ST_DEVINFO, st_compare_expected_position);
17749 
17750 	ASSERT(un != NULL);
17751 	ASSERT(ei != NULL);
17752 	ASSERT(read != NULL);
17753 	ASSERT(cmd_att->chg_tape_pos);
17754 
17755 	COPY_POS(read, &ei->ei_expected_pos);
17756 
17757 	readp_datap = kmem_zalloc(sizeof (read_pos_data_t), KM_SLEEP);
17758 
17759 	rval = st_recovery_get_position(un, read, readp_datap);
17760 
17761 	kmem_free(readp_datap, sizeof (read_pos_data_t));
17762 
17763 	if (rval != 0) {
17764 		return (EIO);
17765 	}
17766 
17767 	ST_POS(ST_DEVINFO, "st_compare_expected_position", read);
17768 
17769 	if ((read->pmode == invalid) ||
17770 	    (ei->ei_expected_pos.pmode == invalid)) {
17771 		return (EIO);
17772 	}
17773 
17774 	/*
17775 	 * Command that changes tape position and have an expected position
17776 	 * if it were to chave completed sucessfully.
17777 	 */
17778 	if (cmd_att->recov_pos_type == POS_EXPECTED) {
17779 		uint32_t count;
17780 		int64_t difference;
17781 		uchar_t reposition = 0;
17782 
17783 		ASSERT(cmd_att->get_cnt);
17784 		count = cmd_att->get_cnt(ei->ei_failed_pkt.pkt_cdbp);
17785 
17786 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17787 		    "Got count from CDB and it was %d\n", count);
17788 
17789 		/*
17790 		 * At expected?
17791 		 */
17792 		if (read->lgclblkno == ei->ei_expected_pos.lgclblkno) {
17793 			ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17794 			    "Found drive to be at expected position\n");
17795 
17796 			/*
17797 			 * If the command should move tape and it got a busy
17798 			 * it shouldn't be in the expected position.
17799 			 */
17800 			if (ei->ei_failing_status.sts_status.sts_busy != 0) {
17801 				reposition = 1;
17802 
17803 			/*
17804 			 * If the command doesn't transfer data should be good.
17805 			 */
17806 			} else if (cmd_att->transfers_data == TRAN_NONE) {
17807 				return (0); /* Good */
17808 
17809 			/*
17810 			 * Command transfers data, should have done so.
17811 			 */
17812 			} else if (ei->ei_failed_pkt.pkt_state &
17813 			    STATE_XFERRED_DATA) {
17814 				return (0); /* Good */
17815 			} else {
17816 				reposition = 1;
17817 			}
17818 		}
17819 
17820 		if (cmd_att->chg_tape_direction == DIR_FORW) {
17821 			difference =
17822 			    ei->ei_expected_pos.lgclblkno - read->lgclblkno;
17823 
17824 			ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17825 			    "difference between expected and actual is %"
17826 			    PRId64"\n", difference);
17827 			if (count == difference && reposition == 0) {
17828 				ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17829 				    "Found failed FORW command, retrying\n");
17830 				return (EAGAIN);
17831 			}
17832 
17833 			/*
17834 			 * If rewound or somewhere between the starting position
17835 			 * and the expected position (partial read or write).
17836 			 * Locate to the starting position and try the whole
17837 			 * thing over again.
17838 			 */
17839 			if ((read->lgclblkno == 0) ||
17840 			    ((difference > 0) && (difference < count))) {
17841 				rval = st_logical_block_locate(un,
17842 				    st_uscsi_rcmd, read,
17843 				    ei->ei_expected_pos.lgclblkno - count,
17844 				    ei->ei_expected_pos.partition);
17845 				if (rval == 0) {
17846 					ST_RECOV(ST_DEVINFO, st_label,
17847 					    CE_NOTE, "reestablished FORW"
17848 					    " command retrying\n");
17849 					return (EAGAIN);
17850 				}
17851 			/*
17852 			 * This handles flushed read ahead on the drive or
17853 			 * an aborted read that presents as a busy and advanced
17854 			 * the tape position.
17855 			 */
17856 			} else if ((cmd_att->transfers_data == TRAN_READ) &&
17857 			    ((difference < 0) || (reposition == 1))) {
17858 				rval = st_logical_block_locate(un,
17859 				    st_uscsi_rcmd, read,
17860 				    ei->ei_expected_pos.lgclblkno - count,
17861 				    ei->ei_expected_pos.partition);
17862 				if (rval == 0) {
17863 					ST_RECOV(ST_DEVINFO, st_label,
17864 					    CE_NOTE, "reestablished FORW"
17865 					    " read command retrying\n");
17866 					return (EAGAIN);
17867 				}
17868 			/*
17869 			 * XXX swag seeing difference of 2 on write filemark.
17870 			 * If the space to the starting position works on a
17871 			 * write that means the previous write made it to tape.
17872 			 * If not we lost data and have to give up.
17873 			 *
17874 			 * The plot thickens. Now I am attempting to cover a
17875 			 * count of 1 and a differance of 2 on a write.
17876 			 */
17877 			} else if ((difference > count) || (reposition == 1)) {
17878 				rval = st_logical_block_locate(un,
17879 				    st_uscsi_rcmd, read,
17880 				    ei->ei_expected_pos.lgclblkno - count,
17881 				    ei->ei_expected_pos.partition);
17882 				if (rval == 0) {
17883 					ST_RECOV(ST_DEVINFO, st_label,
17884 					    CE_NOTE, "reestablished FORW"
17885 					    " write command retrying\n");
17886 					return (EAGAIN);
17887 				}
17888 				ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17889 				    "Seek to block %"PRId64" returned %d\n",
17890 				    ei->ei_expected_pos.lgclblkno - count,
17891 				    rval);
17892 			} else {
17893 				ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17894 				    "Not expected transfers_data = %d "
17895 				    "difference = %"PRId64,
17896 				    cmd_att->transfers_data, difference);
17897 			}
17898 
17899 			return (EIO);
17900 
17901 		} else if (cmd_att->chg_tape_direction == DIR_REVC) {
17902 			/* Don't think we can write backwards */
17903 			ASSERT(cmd_att->transfers_data != TRAN_WRTE);
17904 			difference =
17905 			    read->lgclblkno - ei->ei_expected_pos.lgclblkno;
17906 			ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17907 			    "difference between expected and actual is %"
17908 			    PRId64"\n", difference);
17909 			if (count == difference && reposition == 0) {
17910 				ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17911 				    "Found failed REVC command, retrying\n");
17912 				return (EAGAIN);
17913 			}
17914 			if ((read->lgclblkno == 0) ||
17915 			    ((difference > 0) && (difference < count))) {
17916 				rval = st_logical_block_locate(un,
17917 				    st_uscsi_rcmd, read,
17918 				    ei->ei_expected_pos.lgclblkno + count,
17919 				    ei->ei_expected_pos.partition);
17920 				if (rval == 0) {
17921 					ST_RECOV(ST_DEVINFO, st_label,
17922 					    CE_NOTE, "reestablished REVC"
17923 					    " command retrying\n");
17924 					return (EAGAIN);
17925 				}
17926 			/* This handles read ahead in reverse direction */
17927 			} else if ((cmd_att->transfers_data == TRAN_READ) &&
17928 			    (difference < 0) || (reposition == 1)) {
17929 				rval = st_logical_block_locate(un,
17930 				    st_uscsi_rcmd, read,
17931 				    ei->ei_expected_pos.lgclblkno - count,
17932 				    ei->ei_expected_pos.partition);
17933 				if (rval == 0) {
17934 					ST_RECOV(ST_DEVINFO, st_label,
17935 					    CE_NOTE, "reestablished REVC"
17936 					    " read command retrying\n");
17937 					return (EAGAIN);
17938 				}
17939 			} else {
17940 				ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17941 				    "Not expected transfers_data = %d "
17942 				    "difference = %"PRId64,
17943 				    cmd_att->transfers_data, difference);
17944 			}
17945 			return (EIO);
17946 
17947 		} else {
17948 			/*
17949 			 * Commands that change tape position either
17950 			 * direction or don't change position should not
17951 			 * get here.
17952 			 */
17953 			ASSERT(0);
17954 		}
17955 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17956 		    "Didn't find a recoverable position, Failing\n");
17957 
17958 	/*
17959 	 * Command that changes tape position and can only be recovered
17960 	 * by going back to the point of origin and retrying.
17961 	 *
17962 	 * Example SCMD_SPACE.
17963 	 */
17964 	} else if (cmd_att->recov_pos_type == POS_STARTING) {
17965 		/*
17966 		 * This type of command stores the starting position.
17967 		 * If the read position is the starting position,
17968 		 * reissue the command.
17969 		 */
17970 		if (ei->ei_expected_pos.lgclblkno == read->lgclblkno) {
17971 			ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17972 			    "Found Space command at starting position, "
17973 			    "Reissuing\n");
17974 			return (EAGAIN);
17975 		}
17976 		/*
17977 		 * Not in the position that the command was originally issued,
17978 		 * Attempt to locate to that position.
17979 		 */
17980 		rval = st_logical_block_locate(un, st_uscsi_rcmd, read,
17981 		    ei->ei_expected_pos.lgclblkno,
17982 		    ei->ei_expected_pos.partition);
17983 		if (rval) {
17984 			ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17985 			    "Found Space at an unexpected position and locate "
17986 			    "back to starting position failed\n");
17987 			return (EIO);
17988 		}
17989 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
17990 		    "Found Space at an unexpected position and locate "
17991 		    "back to starting position worked, Reissuing\n");
17992 		return (EAGAIN);
17993 	}
17994 	st_print_position(ST_DEVINFO, st_label, CE_NOTE,
17995 	    "Unhandled attribute/expected position", &ei->ei_expected_pos);
17996 	st_print_position(ST_DEVINFO, st_label, CE_NOTE,
17997 	    "Read position above did not make sense", read);
17998 	ASSERT(0);
17999 	return (EIO);
18000 }
18001 
18002 static errstate
18003 st_recover_reissue_pkt(struct scsi_tape *un, struct scsi_pkt *oldpkt)
18004 {
18005 	buf_t *bp;
18006 	buf_t *pkt_bp;
18007 	struct scsi_pkt *newpkt;
18008 	cmd_attribute const *attrib;
18009 	recov_info *rcv = oldpkt->pkt_private;
18010 	uint_t cdblen;
18011 	int queued = 0;
18012 	int rval;
18013 	int flags = 0;
18014 	int stat_size =
18015 	    (un->un_arq_enabled ? sizeof (struct scsi_arq_status) : 1);
18016 
18017 	ST_FUNC(ST_DEVINFO, st_recover_reissue_pkt);
18018 
18019 	bp = rcv->cmd_bp;
18020 
18021 	if (rcv->privatelen == sizeof (recov_info)) {
18022 		attrib = rcv->cmd_attrib;
18023 	} else {
18024 		attrib = st_lookup_cmd_attribute(oldpkt->pkt_cdbp[0]);
18025 	}
18026 
18027 	/*
18028 	 * Some non-uscsi commands use the b_bcount for values that
18029 	 * have nothing to do with how much data is transfered.
18030 	 * In those cases we need to hide the buf_t from scsi_init_pkt().
18031 	 */
18032 	if ((BP_UCMD(bp)) && (bp->b_bcount)) {
18033 		pkt_bp = bp;
18034 	} else if (attrib->transfers_data == TRAN_NONE) {
18035 		pkt_bp = NULL;
18036 	} else {
18037 		pkt_bp = bp;
18038 	}
18039 
18040 	/*
18041 	 * if this is a queued command make sure it the only one in the
18042 	 * run queue.
18043 	 */
18044 	if (bp != un->un_sbufp && bp != un->un_recov_buf) {
18045 		ASSERT(un->un_runqf == un->un_runql);
18046 		ASSERT(un->un_runqf == bp);
18047 		queued = 1;
18048 	}
18049 
18050 	cdblen = scsi_cdb_size[CDB_GROUPID(oldpkt->pkt_cdbp[0])];
18051 
18052 	if (pkt_bp == un->un_rqs_bp) {
18053 		flags |= PKT_CONSISTENT;
18054 		stat_size = 1;
18055 	}
18056 
18057 	newpkt = scsi_init_pkt(ROUTE, NULL, pkt_bp, cdblen,
18058 	    stat_size, rcv->privatelen, flags, NULL_FUNC, NULL);
18059 	if (newpkt == NULL) {
18060 		ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
18061 		    "Reissue pkt scsi_init_pkt() failure\n");
18062 		return (COMMAND_DONE_ERROR);
18063 	}
18064 
18065 	ASSERT(newpkt->pkt_resid == 0);
18066 	bp->b_flags &= ~(B_DONE);
18067 	bp->b_resid = 0;
18068 	st_bioerror(bp, 0);
18069 
18070 	bcopy(oldpkt->pkt_private, newpkt->pkt_private, rcv->privatelen);
18071 
18072 	newpkt->pkt_comp = oldpkt->pkt_comp;
18073 	newpkt->pkt_time = oldpkt->pkt_time;
18074 
18075 	bzero(newpkt->pkt_scbp, stat_size);
18076 	bcopy(oldpkt->pkt_cdbp, newpkt->pkt_cdbp, cdblen);
18077 
18078 	newpkt->pkt_state = 0;
18079 	newpkt->pkt_statistics = 0;
18080 
18081 	/*
18082 	 * oldpkt passed in was a copy of the original.
18083 	 * to distroy we need the address of the original.
18084 	 */
18085 	oldpkt = BP_PKT(bp);
18086 
18087 	if (oldpkt == un->un_rqs) {
18088 		ASSERT(bp == un->un_rqs_bp);
18089 		un->un_rqs = newpkt;
18090 	}
18091 
18092 	SET_BP_PKT(bp, newpkt);
18093 
18094 	scsi_destroy_pkt(oldpkt);
18095 
18096 	rval = st_transport(un, newpkt);
18097 	if (rval == TRAN_ACCEPT) {
18098 		return (JUST_RETURN);
18099 	}
18100 	ST_RECOV(ST_DEVINFO, st_label, CE_NOTE,
18101 	    "Reissue pkt st_transport(0x%x) failure\n", rval);
18102 	if (rval != TRAN_BUSY) {
18103 		return (COMMAND_DONE_ERROR);
18104 	}
18105 	mutex_exit(ST_MUTEX);
18106 	rval = st_handle_start_busy(un, bp, ST_TRAN_BUSY_TIMEOUT, queued);
18107 	mutex_enter(ST_MUTEX);
18108 	if (rval) {
18109 		return (COMMAND_DONE_ERROR);
18110 	}
18111 
18112 	return (JUST_RETURN);
18113 }
18114 
18115 static int
18116 st_transport(struct scsi_tape *un, struct scsi_pkt *pkt)
18117 {
18118 	int status;
18119 
18120 	ST_FUNC(ST_DEVINFO, st_transport);
18121 
18122 	ST_CDB(ST_DEVINFO, "transport CDB", (caddr_t)pkt->pkt_cdbp);
18123 
18124 	mutex_exit(ST_MUTEX);
18125 
18126 	status = scsi_transport(pkt);
18127 
18128 	mutex_enter(ST_MUTEX);
18129 
18130 	return (status);
18131 }
18132 
18133 /*
18134  * Removed the buf_t bp from the queue referenced to by head and tail.
18135  * Returns the buf_t pointer if it is found in the queue.
18136  * Returns NULL if it is not found.
18137  */
18138 static buf_t *
18139 st_remove_from_queue(buf_t **head, buf_t **tail, buf_t *bp)
18140 {
18141 	buf_t *runqbp;
18142 	buf_t *prevbp = NULL;
18143 
18144 	for (runqbp = *head; runqbp != 0; runqbp = runqbp->av_forw) {
18145 		if (runqbp == bp) {
18146 			/* found it, is it at the head? */
18147 			if (runqbp == *head) {
18148 				*head = bp->av_forw;
18149 			} else {
18150 				prevbp->av_forw = bp->av_forw;
18151 			}
18152 			if (*tail == bp) {
18153 				*tail = prevbp;
18154 			}
18155 			bp->av_forw = NULL;
18156 			return (bp); /* found and removed */
18157 		}
18158 		prevbp = runqbp;
18159 	}
18160 	return (NULL);
18161 }
18162 
18163 /*
18164  * Adds a buf_t to the queue pointed to by head and tail.
18165  * Adds it either to the head end or the tail end based on which
18166  * the passed variable end (head or tail) points at.
18167  */
18168 static void
18169 st_add_to_queue(buf_t **head, buf_t **tail, buf_t *end, buf_t *bp)
18170 {
18171 
18172 	bp->av_forw = NULL;
18173 	if (*head) {
18174 		/* Queue is not empty */
18175 		if (end == *head) {
18176 			/* Add at front of queue */
18177 			bp->av_forw = *head;
18178 			*head = bp;
18179 		} else if (end == *tail) {
18180 			/* Add at end of queue */
18181 			(*tail)->av_forw = bp;
18182 			*tail = bp;
18183 		} else {
18184 			ASSERT(0);
18185 		}
18186 	} else {
18187 		/* Queue is empty */
18188 		*head = bp;
18189 		*tail = bp;
18190 	}
18191 }
18192 
18193 
18194 static uint64_t
18195 st_get_cdb_g0_rw_count(uchar_t *cdb)
18196 {
18197 	uint64_t count;
18198 
18199 	if ((cdb[1]) & 1) {
18200 		/* fixed block mode, the count is the number of blocks */
18201 		count =
18202 		    cdb[2] << 16 |
18203 		    cdb[3] << 8 |
18204 		    cdb[4];
18205 	} else {
18206 		/* variable block mode, the count is the block size */
18207 		count = 1;
18208 	}
18209 	return (count);
18210 }
18211 
18212 static uint64_t
18213 st_get_cdb_g0_sign_count(uchar_t *cdb)
18214 {
18215 	uint64_t count;
18216 
18217 	count =
18218 	    cdb[2] << 16 |
18219 	    cdb[3] << 8 |
18220 	    cdb[4];
18221 	/*
18222 	 * If the sign bit of the 3 byte value is set, extended it.
18223 	 */
18224 	if (count & 0x800000) {
18225 		count |= 0xffffffffff000000;
18226 	}
18227 	return (count);
18228 }
18229 
18230 static uint64_t
18231 st_get_cdb_g0_count(uchar_t *cdb)
18232 {
18233 	uint64_t count;
18234 
18235 	count =
18236 	    cdb[2] << 16 |
18237 	    cdb[3] << 8 |
18238 	    cdb[4];
18239 	return (count);
18240 }
18241 
18242 static uint64_t
18243 st_get_cdb_g5_rw_cnt(uchar_t *cdb)
18244 {
18245 	uint64_t count;
18246 
18247 	if ((cdb[1]) & 1) {
18248 		/* fixed block mode */
18249 		count =
18250 		    cdb[12] << 16 |
18251 		    cdb[13] << 8 |
18252 		    cdb[14];
18253 	} else {
18254 		/* variable block mode */
18255 		count = 1;
18256 	}
18257 	return (count);
18258 }
18259 
18260 static uint64_t
18261 st_get_no_count(uchar_t *cdb)
18262 {
18263 	ASSERT(cdb[0] == SCMD_REWIND);
18264 	return ((uint64_t)cdb[0]);
18265 }
18266 
18267 static uint64_t
18268 st_get_load_options(uchar_t *cdb)
18269 {
18270 	return ((uint64_t)(cdb[4] | (LD_HOLD << 1)));
18271 }
18272 
18273 static uint64_t
18274 st_get_erase_options(uchar_t *cdb)
18275 {
18276 	return (cdb[1] | (cdb[0] << 8));
18277 }
18278 
18279 static uint64_t
18280 st_get_cdb_g1_lba(uchar_t *cdb)
18281 {
18282 	uint64_t lba;
18283 
18284 	lba =
18285 	    cdb[3] << 24 |
18286 	    cdb[4] << 16 |
18287 	    cdb[5] << 8 |
18288 	    cdb[6];
18289 	return (lba);
18290 }
18291 
18292 static uint64_t
18293 st_get_cdb_g5_count(uchar_t *cdb)
18294 {
18295 	uint64_t count =
18296 	    cdb[12] << 16 |
18297 	    cdb[13] << 8 |
18298 	    cdb[14];
18299 
18300 	return (count);
18301 }
18302 
18303 static uint64_t
18304 st_get_cdb_g4g5_cnt(uchar_t *cdb)
18305 {
18306 	uint64_t lba;
18307 
18308 	lba =
18309 	    (uint64_t)cdb[4] << 56 |
18310 	    (uint64_t)cdb[5] << 48 |
18311 	    (uint64_t)cdb[6] << 40 |
18312 	    (uint64_t)cdb[7] << 32 |
18313 	    (uint64_t)cdb[8] << 24 |
18314 	    (uint64_t)cdb[9] << 16 |
18315 	    (uint64_t)cdb[10] << 8 |
18316 	    (uint64_t)cdb[11];
18317 	return (lba);
18318 }
18319 
18320 static const cmd_attribute cmd_attributes[] = {
18321 	{ SCMD_READ,
18322 	    1, 0, 1, 0, 0, DIR_FORW, TRAN_READ, POS_EXPECTED,
18323 	    0, 0, 0, st_get_cdb_g0_rw_count },
18324 	{ SCMD_WRITE,
18325 	    1, 0, 1, 1, 0, DIR_FORW, TRAN_WRTE, POS_EXPECTED,
18326 	    0, 0, 0, st_get_cdb_g0_rw_count },
18327 	{ SCMD_TEST_UNIT_READY,
18328 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED,
18329 	    0, 0, 0 },
18330 	{ SCMD_REWIND,
18331 	    1, 1, 1, 0, 0, DIR_REVC, TRAN_NONE, POS_EXPECTED,
18332 	    0, 0, 0, st_get_no_count },
18333 	{ SCMD_REQUEST_SENSE,
18334 	    0, 0, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18335 	    0, 0, 0 },
18336 	{ SCMD_READ_BLKLIM,
18337 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18338 	    0, 0, 0 },
18339 	{ SCMD_READ_G4,
18340 	    1, 0, 1, 0, 1, DIR_FORW, TRAN_READ, POS_EXPECTED,
18341 	    0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt },
18342 	{ SCMD_WRITE_G4,
18343 	    1, 0, 1, 1, 1, DIR_FORW, TRAN_WRTE, POS_EXPECTED,
18344 	    0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt },
18345 	{ SCMD_READ_REVERSE,
18346 	    1, 0, 1, 1, 0, DIR_REVC, TRAN_READ, POS_EXPECTED,
18347 	    0, 0, 0, st_get_cdb_g0_rw_count },
18348 	{ SCMD_READ_REVERSE_G4,
18349 	    1, 0, 1, 1, 1, DIR_REVC, TRAN_READ, POS_EXPECTED,
18350 	    0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt },
18351 	{ SCMD_WRITE_FILE_MARK,
18352 	    1, 0, 1, 1, 0, DIR_FORW, TRAN_NONE, POS_EXPECTED,
18353 	    0, 0, 0, st_get_cdb_g0_count },
18354 	{ SCMD_WRITE_FILE_MARK_G4,
18355 	    1, 0, 1, 1, 1, DIR_FORW, TRAN_NONE, POS_EXPECTED,
18356 	    0, 0, 0, st_get_cdb_g5_count, st_get_cdb_g4g5_cnt },
18357 	{ SCMD_SPACE,
18358 	    1, 0, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_STARTING,
18359 	    0, 0, 0, st_get_cdb_g0_sign_count },
18360 	{ SCMD_SPACE_G4,
18361 	    1, 0, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_STARTING,
18362 	    0, 0, 0, st_get_cdb_g4g5_cnt },
18363 	{ SCMD_INQUIRY,
18364 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18365 	    0, 0, 0 },
18366 	{ SCMD_VERIFY_G0,
18367 	    1, 0, 1, 0, 0, DIR_FORW, TRAN_NONE, POS_EXPECTED,
18368 	    0, 0, 0, st_get_cdb_g0_rw_count },
18369 	{ SCMD_VERIFY_G4,
18370 	    1, 0, 1, 0, 1, DIR_FORW, TRAN_NONE, POS_EXPECTED,
18371 	    0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt },
18372 	{ SCMD_RECOVER_BUF,
18373 	    1, 0, 1, 1, 0, DIR_REVC, TRAN_READ, POS_EXPECTED,
18374 	    0, 0, 0 },
18375 	{ SCMD_MODE_SELECT,
18376 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED,
18377 	    0, 0, 0 },
18378 	{ SCMD_RESERVE,
18379 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED,
18380 	    0, 0, 0 },
18381 	{ SCMD_RELEASE,
18382 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED,
18383 	    0, 0, 0 },
18384 	{ SCMD_ERASE,
18385 	    1, 0, 1, 1, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED,
18386 	    0, 0, 0, st_get_erase_options },
18387 	{ SCMD_MODE_SENSE,
18388 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18389 	    0, 0, 0 },
18390 	{ SCMD_LOAD,
18391 	    1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED,
18392 	    0, 0, 0, st_get_load_options },
18393 	{ SCMD_GDIAG,
18394 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18395 	    1, 0, 0 },
18396 	{ SCMD_SDIAG,
18397 	    1, 0, 1, 1, 0, DIR_EITH, TRAN_WRTE, POS_EXPECTED,
18398 	    1, 0, 0 },
18399 	{ SCMD_DOORLOCK,
18400 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED,
18401 	    0, 4, 3 },
18402 	{ SCMD_LOCATE,
18403 	    1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED,
18404 	    0, 0, 0, NULL, st_get_cdb_g1_lba },
18405 	{ SCMD_READ_POSITION,
18406 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18407 	    0, 0, 0 },
18408 	{ SCMD_WRITE_BUFFER,
18409 	    1, 0, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED,
18410 	    1, 0, 0 },
18411 	{ SCMD_READ_BUFFER,
18412 	    1, 0, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18413 	    1, 0, 0 },
18414 	{ SCMD_REPORT_DENSITIES,
18415 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18416 	    0, 0, 0 },
18417 	{ SCMD_LOG_SELECT_G1,
18418 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED,
18419 	    0, 0, 0 },
18420 	{ SCMD_LOG_SENSE_G1,
18421 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18422 	    0, 0, 0 },
18423 	{ SCMD_PRIN,
18424 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18425 	    0, 0, 0 },
18426 	{ SCMD_PROUT,
18427 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED,
18428 	    0, 0, 0 },
18429 	{ SCMD_READ_ATTRIBUTE,
18430 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18431 	    0, 0, 0 },
18432 	{ SCMD_WRITE_ATTRIBUTE,
18433 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED,
18434 	    0, 0, 0 },
18435 	{ SCMD_LOCATE_G4,
18436 	    1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED,
18437 	    0, 0, 0, NULL, st_get_cdb_g4g5_cnt },
18438 	{ SCMD_REPORT_LUNS,
18439 	    0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18440 	    0, 0, 0 },
18441 	{ SCMD_SVC_ACTION_IN_G5,
18442 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18443 	    0, 0, 0 },
18444 	{ SCMD_MAINTENANCE_IN,
18445 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED,
18446 	    0, 0, 0 },
18447 	{ SCMD_MAINTENANCE_OUT,
18448 	    1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED,
18449 	    0, 0, 0 },
18450 	{ 0xff, /* Default attribute for unsupported commands */
18451 	    1, 0, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_STARTING,
18452 	    1, 0, 0, NULL, NULL }
18453 };
18454 
18455 static const cmd_attribute *
18456 st_lookup_cmd_attribute(unsigned char cmd)
18457 {
18458 	int i;
18459 	cmd_attribute const *attribute;
18460 
18461 	for (i = 0; i < ST_NUM_MEMBERS(cmd_attributes); i++) {
18462 		attribute = &cmd_attributes[i];
18463 		if (attribute->cmd == cmd) {
18464 			return (attribute);
18465 		}
18466 	}
18467 	ASSERT(attribute);
18468 	return (attribute);
18469 }
18470 
18471 static int
18472 st_reset(struct scsi_tape *un, int reset_type)
18473 {
18474 	int rval;
18475 
18476 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
18477 
18478 	ST_FUNC(ST_DEVINFO, st_reset);
18479 	un->un_rsvd_status |= ST_INITIATED_RESET;
18480 	mutex_exit(ST_MUTEX);
18481 	do {
18482 		rval = scsi_reset(&un->un_sd->sd_address, reset_type);
18483 		if (rval == 0) {
18484 			switch (reset_type) {
18485 			case RESET_LUN:
18486 				ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
18487 				    "LUN reset failed trying target reset");
18488 				reset_type = RESET_TARGET;
18489 				break;
18490 			case RESET_TARGET:
18491 				ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
18492 				    "target reset failed trying bus reset");
18493 				reset_type = RESET_BUS;
18494 				break;
18495 			case RESET_BUS:
18496 				ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
18497 				    "bus reset failed trying all reset");
18498 				reset_type = RESET_ALL;
18499 			default:
18500 				mutex_enter(ST_MUTEX);
18501 				return (rval);
18502 			}
18503 		}
18504 	} while (rval == 0);
18505 	mutex_enter(ST_MUTEX);
18506 	return (rval);
18507 }
18508 
18509 #define	SAS_TLR_MOD_LEN sizeof (struct seq_mode)
18510 static int
18511 st_set_target_TLR_mode(struct scsi_tape *un, ubufunc_t ubf)
18512 {
18513 	int ret;
18514 	int amount = SAS_TLR_MOD_LEN;
18515 	struct seq_mode *mode_data;
18516 
18517 	ST_FUNC(ST_DEVINFO, st_set_target_TLR_mode);
18518 
18519 	mode_data = kmem_zalloc(SAS_TLR_MOD_LEN, KM_SLEEP);
18520 	ret = st_gen_mode_sense(un, ubf, 0x18, mode_data, amount);
18521 	if (ret != DDI_SUCCESS) {
18522 		if (ret != EACCES)
18523 			un->un_tlr_flag = TLR_NOT_SUPPORTED;
18524 		goto out;
18525 	}
18526 	if (mode_data->data_len != amount + 1) {
18527 		amount = mode_data->data_len + 1;
18528 	}
18529 	/* Must be SAS protocol */
18530 	if (mode_data->page.saslun.protocol_id != 6) {
18531 		un->un_tlr_flag = TLR_NOT_SUPPORTED;
18532 		ret = ENOTSUP;
18533 		goto out;
18534 	}
18535 	if (un->un_tlr_flag == TLR_SAS_ONE_DEVICE) {
18536 		if (mode_data->page.saslun.tran_layer_ret == 1)
18537 			goto out;
18538 		mode_data->page.saslun.tran_layer_ret = 1;
18539 	} else {
18540 		if (mode_data->page.saslun.tran_layer_ret == 0)
18541 			goto out;
18542 		mode_data->page.saslun.tran_layer_ret = 0;
18543 	}
18544 	ret = st_gen_mode_select(un, ubf, mode_data, amount);
18545 	if (ret != DDI_SUCCESS) {
18546 		if (ret != EACCES)
18547 			un->un_tlr_flag = TLR_NOT_SUPPORTED;
18548 	} else {
18549 		if (mode_data->page.saslun.tran_layer_ret == 0)
18550 			un->un_tlr_flag = TLR_NOT_KNOWN;
18551 		else
18552 			un->un_tlr_flag = TLR_SAS_ONE_DEVICE;
18553 	}
18554 #ifdef STDEBUG
18555 	st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, "TLR data sent",
18556 	    (char *)mode_data, amount);
18557 #endif
18558 out:
18559 	kmem_free(mode_data, SAS_TLR_MOD_LEN);
18560 	return (ret);
18561 }
18562 
18563 
18564 static void
18565 st_reset_notification(caddr_t arg)
18566 {
18567 	struct scsi_tape *un = (struct scsi_tape *)arg;
18568 
18569 	ST_FUNC(ST_DEVINFO, st_reset_notification);
18570 	mutex_enter(ST_MUTEX);
18571 
18572 	un->un_unit_attention_flags |= 2;
18573 	if ((un->un_rsvd_status & (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) ==
18574 	    ST_RESERVE) {
18575 		un->un_rsvd_status |= ST_LOST_RESERVE;
18576 		ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
18577 		    "Lost Reservation notification");
18578 	} else {
18579 		ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
18580 		    "reset notification");
18581 	}
18582 
18583 	if ((un->un_restore_pos == 0) &&
18584 	    (un->un_state == ST_STATE_CLOSED) ||
18585 	    (un->un_state == ST_STATE_OPEN_PENDING_IO) ||
18586 	    (un->un_state == ST_STATE_CLOSING)) {
18587 		un->un_restore_pos = 1;
18588 	}
18589 	ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
18590 	    "reset and state was %d\n", un->un_state);
18591 	mutex_exit(ST_MUTEX);
18592 }
18593