xref: /illumos-gate/usr/src/uts/common/io/scsi/targets/st.c (revision 38d6b75a067abaff85b53171045f9fdca1c4f636)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * SCSI	 SCSA-compliant and not-so-DDI-compliant Tape Driver
31  */
32 
33 #if defined(lint) && !defined(DEBUG)
34 #define	DEBUG	1
35 #endif
36 
37 #include <sys/modctl.h>
38 #include <sys/scsi/scsi.h>
39 #include <sys/mtio.h>
40 #include <sys/scsi/targets/stdef.h>
41 #include <sys/file.h>
42 #include <sys/stat.h>
43 #include <sys/kstat.h>
44 #include <sys/ddidmareq.h>
45 #include <sys/ddi.h>
46 #include <sys/sunddi.h>
47 
48 #define	IOSP	KSTAT_IO_PTR(un->un_stats)
49 /*
50  * stats maintained only for reads/writes as commands
51  * like rewind etc skew the wait/busy times
52  */
53 #define	IS_RW(bp) 	((bp)->b_bcount > 0)
54 #define	ST_DO_KSTATS(bp, kstat_function) \
55 	if ((bp != un->un_sbufp) && un->un_stats && IS_RW(bp)) { \
56 		kstat_function(IOSP); \
57 	}
58 
59 #define	ST_DO_ERRSTATS(un, x)  \
60 	if (un->un_errstats) { \
61 		struct st_errstats *stp; \
62 		stp = (struct st_errstats *)un->un_errstats->ks_data; \
63 		stp->x.value.ul++; \
64 	}
65 
66 #define	FILL_SCSI1_LUN(devp, pkt) 					\
67 	if ((devp)->sd_inq->inq_ansi == 0x1) {				\
68 		int _lun;						\
69 		_lun = ddi_prop_get_int(DDI_DEV_T_ANY, (devp)->sd_dev,	\
70 		    DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0);		\
71 		if (_lun > 0) {						\
72 			((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun =	\
73 			    _lun;					\
74 		}							\
75 	}
76 
77 #define	ST_NUM_MEMBERS(array)	(sizeof (array) / sizeof (array[0]))
78 
79 /*
80  * Global External Data Definitions
81  */
82 extern struct scsi_key_strings scsi_cmds[];
83 
84 /*
85  * Local Static Data
86  */
87 static void *st_state;
88 static char *st_label = "st";
89 
90 #if defined(__i386) || defined(__amd64)
91 /*
92  * We need to use below DMA attr to alloc physically contiguous
93  * memory to do I/O in big block size
94  */
95 static ddi_dma_attr_t st_contig_mem_dma_attr = {
96 	DMA_ATTR_V0,    /* version number */
97 	0x0,		/* lowest usable address */
98 	0xFFFFFFFFull,  /* high DMA address range */
99 	0xFFFFFFFFull,  /* DMA counter register */
100 	1,		/* DMA address alignment */
101 	1,		/* DMA burstsizes */
102 	1,		/* min effective DMA size */
103 	0xFFFFFFFFull,  /* max DMA xfer size */
104 	0xFFFFFFFFull,  /* segment boundary */
105 	1,		/* s/g list length */
106 	1,		/* granularity of device */
107 	0		/* DMA transfer flags */
108 };
109 
110 static ddi_device_acc_attr_t st_acc_attr = {
111 	DDI_DEVICE_ATTR_V0,
112 	DDI_NEVERSWAP_ACC,
113 	DDI_STRICTORDER_ACC
114 };
115 
116 /* set limitation for the number of contig_mem */
117 static int st_max_contig_mem_num = ST_MAX_CONTIG_MEM_NUM;
118 #endif
119 
120 /*
121  * Tunable parameters
122  *
123  * DISCLAIMER
124  * ----------
125  * These parameters are intended for use only in system testing; if you use
126  * them in production systems, you do so at your own risk. Altering any
127  * variable not listed below may cause unpredictable system behavior.
128  *
129  * st_check_media_time
130  *
131  *   Three second state check
132  *
133  * st_allow_large_xfer
134  *
135  *   Gated with ST_NO_RECSIZE_LIMIT
136  *
137  *   0 - Transfers larger than 64KB will not be allowed
138  *       regardless of the setting of ST_NO_RECSIZE_LIMIT
139  *   1 - Transfers larger than 64KB will be allowed
140  *       if ST_NO_RECSIZE_LIMIT is TRUE for the drive
141  *
142  * st_report_soft_errors_on_close
143  *
144  *  Gated with ST_SOFT_ERROR_REPORTING
145  *
146  *  0 - Errors will not be reported on close regardless
147  *      of the setting of ST_SOFT_ERROR_REPORTING
148  *
149  *  1 - Errors will be reported on close if
150  *      ST_SOFT_ERROR_REPORTING is TRUE for the drive
151  */
152 static int st_selection_retry_count = ST_SEL_RETRY_COUNT;
153 static int st_retry_count	= ST_RETRY_COUNT;
154 
155 static int st_io_time		= ST_IO_TIME;
156 static int st_long_timeout_x	= ST_LONG_TIMEOUT_X;
157 
158 static int st_space_time	= ST_SPACE_TIME;
159 static int st_long_space_time_x	= ST_LONG_SPACE_TIME_X;
160 
161 static int st_error_level	= SCSI_ERR_RETRYABLE;
162 static int st_check_media_time	= 3000000;	/* 3 Second State Check */
163 
164 static int st_max_throttle	= ST_MAX_THROTTLE;
165 
166 static clock_t st_wait_cmds_complete = ST_WAIT_CMDS_COMPLETE;
167 
168 static int st_allow_large_xfer = 1;
169 static int st_report_soft_errors_on_close = 1;
170 
171 /*
172  * End of tunable parameters list
173  */
174 
175 
176 
177 /*
178  * Asynchronous I/O and persistent errors, refer to PSARC/1995/228
179  *
180  * Asynchronous I/O's main offering is that it is a non-blocking way to do
181  * reads and writes.  The driver will queue up all the requests it gets and
182  * have them ready to transport to the HBA.  Unfortunately, we cannot always
183  * just ship the I/O requests to the HBA, as there errors and exceptions
184  * that may happen when we don't want the HBA to continue.  Therein comes
185  * the flush-on-errors capability.  If the HBA supports it, then st will
186  * send in st_max_throttle I/O requests at the same time.
187  *
188  * Persistent errors : This was also reasonably simple.  In the interrupt
189  * routines, if there was an error or exception (FM, LEOT, media error,
190  * transport error), the persistent error bits are set and shuts everything
191  * down, but setting the throttle to zero.  If we hit and exception in the
192  * HBA, and flush-on-errors were set, we wait for all outstanding I/O's to
193  * come back (with CMD_ABORTED), then flush all bp's in the wait queue with
194  * the appropriate error, and this will preserve order. Of course, depending
195  * on the exception we have to show a zero read or write before we show
196  * errors back to the application.
197  */
198 
199 extern const int st_ndrivetypes;	/* defined in st_conf.c */
200 extern const struct st_drivetype st_drivetypes[];
201 
202 #ifdef STDEBUG
203 static int st_soft_error_report_debug = 0;
204 static int st_debug = 0;
205 #endif
206 
207 #define	ST_MT02_NAME	"Emulex  MT02 QIC-11/24  "
208 
209 static const struct driver_minor_data {
210 	char	*name;
211 	int	minor;
212 } st_minor_data[] = {
213 	/*
214 	 * The top 4 entries are for the default densities,
215 	 * don't alter their position.
216 	 */
217 	{"",	0},
218 	{"n",	MT_NOREWIND},
219 	{"b",	MT_BSD},
220 	{"bn",	MT_NOREWIND | MT_BSD},
221 	{"l",	MT_DENSITY1},
222 	{"m",	MT_DENSITY2},
223 	{"h",	MT_DENSITY3},
224 	{"c",	MT_DENSITY4},
225 	{"u",	MT_DENSITY4},
226 	{"ln",	MT_DENSITY1 | MT_NOREWIND},
227 	{"mn",	MT_DENSITY2 | MT_NOREWIND},
228 	{"hn",	MT_DENSITY3 | MT_NOREWIND},
229 	{"cn",	MT_DENSITY4 | MT_NOREWIND},
230 	{"un",	MT_DENSITY4 | MT_NOREWIND},
231 	{"lb",	MT_DENSITY1 | MT_BSD},
232 	{"mb",	MT_DENSITY2 | MT_BSD},
233 	{"hb",	MT_DENSITY3 | MT_BSD},
234 	{"cb",	MT_DENSITY4 | MT_BSD},
235 	{"ub",	MT_DENSITY4 | MT_BSD},
236 	{"lbn",	MT_DENSITY1 | MT_NOREWIND | MT_BSD},
237 	{"mbn",	MT_DENSITY2 | MT_NOREWIND | MT_BSD},
238 	{"hbn",	MT_DENSITY3 | MT_NOREWIND | MT_BSD},
239 	{"cbn",	MT_DENSITY4 | MT_NOREWIND | MT_BSD},
240 	{"ubn",	MT_DENSITY4 | MT_NOREWIND | MT_BSD}
241 };
242 
243 /* strings used in many debug and warning messages */
244 static const char wr_str[]  = "write";
245 static const char rd_str[]  = "read";
246 static const char wrg_str[] = "writing";
247 static const char rdg_str[] = "reading";
248 
249 /* default density offsets in the table above */
250 #define	DEF_BLANK	0
251 #define	DEF_NOREWIND	1
252 #define	DEF_BSD		2
253 #define	DEF_BSD_NR	3
254 
255 /* Sense Key, ASC/ASCQ for which tape ejection is needed */
256 
257 static struct tape_failure_code {
258 	uchar_t key;
259 	uchar_t add_code;
260 	uchar_t qual_code;
261 } st_tape_failure_code[] = {
262 	{ KEY_HARDWARE_ERROR, 0x15, 0x01},
263 	{ KEY_HARDWARE_ERROR, 0x44, 0x00},
264 	{ KEY_HARDWARE_ERROR, 0x53, 0x00},
265 	{ KEY_HARDWARE_ERROR, 0x53, 0x01},
266 	{ KEY_NOT_READY, 0x53, 0x00},
267 	{ 0xff}
268 };
269 
270 /*  clean bit position and mask */
271 
272 static struct cln_bit_position {
273 	ushort_t cln_bit_byte;
274 	uchar_t cln_bit_mask;
275 } st_cln_bit_position[] = {
276 	{ 21, 0x08},
277 	{ 70, 0xc0},
278 	{ 18, 0x81}  /* 80 bit indicates in bit mode, 1 bit clean light is on */
279 };
280 
281 /*
282  * Configuration Data:
283  *
284  * Device driver ops vector
285  */
286 static int st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p);
287 static int st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p);
288 static int st_read(dev_t  dev,  struct   uio   *uio_p,   cred_t *cred_p);
289 static int st_write(dev_t  dev,  struct  uio   *uio_p,   cred_t *cred_p);
290 static int st_open(dev_t  *devp,  int  flag,  int  otyp,  cred_t *cred_p);
291 static int st_close(dev_t  dev,  int  flag,  int  otyp,  cred_t *cred_p);
292 static int st_strategy(struct buf *bp);
293 static int st_ioctl(dev_t dev, int cmd, intptr_t arg, int  flag,
294 	cred_t *cred_p, int *rval_p);
295 extern int nulldev(), nodev();
296 
297 static struct cb_ops st_cb_ops = {
298 	st_open,			/* open */
299 	st_close,		/* close */
300 	st_strategy,		/* strategy */
301 	nodev,			/* print */
302 	nodev,			/* dump */
303 	st_read,		/* read */
304 	st_write,		/* write */
305 	st_ioctl,		/* ioctl */
306 	nodev,			/* devmap */
307 	nodev,			/* mmap */
308 	nodev,			/* segmap */
309 	nochpoll,		/* poll */
310 	ddi_prop_op,		/* cb_prop_op */
311 	0,			/* streamtab  */
312 	D_64BIT | D_MP | D_NEW | D_HOTPLUG,	/* Driver compatibility flag */
313 	CB_REV,			/* cb_rev */
314 	st_aread, 		/* async I/O read entry point */
315 	st_awrite		/* async I/O write entry point */
316 
317 };
318 
319 static int stinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
320 		void **result);
321 static int st_probe(dev_info_t *dev);
322 static int st_attach(dev_info_t *dev, ddi_attach_cmd_t cmd);
323 static int st_detach(dev_info_t *dev, ddi_detach_cmd_t cmd);
324 
325 static struct dev_ops st_ops = {
326 	DEVO_REV,		/* devo_rev, */
327 	0,			/* refcnt  */
328 	stinfo,			/* info */
329 	nulldev,		/* identify */
330 	st_probe,		/* probe */
331 	st_attach,		/* attach */
332 	st_detach,		/* detach */
333 	nodev,			/* reset */
334 	&st_cb_ops,		/* driver operations */
335 	(struct bus_ops *)0,	/* bus operations */
336 	nulldev			/* power */
337 };
338 
339 /*
340  * Local Function Declarations
341  */
342 static void st_clean_print(dev_info_t *dev, char *label, uint_t level,
343 	char *title, char *data, int len);
344 static int st_doattach(struct scsi_device *devp, int (*canwait)());
345 static void st_known_tape_type(struct scsi_tape *un);
346 static int st_get_conf_from_st_dot_conf(struct scsi_tape *, char *,
347     struct st_drivetype *);
348 static int st_get_conf_from_st_conf_dot_c(struct scsi_tape *, char *,
349     struct st_drivetype *);
350 static int st_get_default_conf(struct scsi_tape *, char *,
351     struct st_drivetype *);
352 static int st_rw(dev_t dev, struct uio *uio, int flag);
353 static int st_arw(dev_t dev, struct aio_req *aio, int flag);
354 static int st_find_eom(dev_t dev);
355 static int st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag);
356 static int st_ioctl_cmd(dev_t dev, struct uscsi_cmd *,
357 	enum uio_seg, enum uio_seg, enum uio_seg);
358 static int st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag);
359 static void st_start(struct scsi_tape *un);
360 static int st_handle_start_busy(struct scsi_tape *un, struct buf *bp,
361     clock_t timeout_interval);
362 static int st_handle_intr_busy(struct scsi_tape *un, struct buf *bp,
363     clock_t timeout_interval);
364 static int st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp);
365 static void st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp);
366 static void st_init(struct scsi_tape *un);
367 static void st_make_cmd(struct scsi_tape *un, struct buf *bp,
368     int (*func)(caddr_t));
369 static void st_make_uscsi_cmd(struct scsi_tape *, struct uscsi_cmd *,
370     struct buf *bp, int (*func)(caddr_t));
371 static void st_intr(struct scsi_pkt *pkt);
372 static void st_set_state(struct scsi_tape *un);
373 static void st_test_append(struct buf *bp);
374 static int st_runout(caddr_t);
375 static int st_cmd(dev_t dev, int com, int count, int wait);
376 static int st_set_compression(struct scsi_tape *un);
377 static int st_write_fm(dev_t dev, int wfm);
378 static int st_determine_generic(dev_t dev);
379 static int st_determine_density(dev_t dev, int rw);
380 static int st_get_density(dev_t dev);
381 static int st_set_density(dev_t dev);
382 static int st_loadtape(dev_t dev);
383 static int st_modesense(struct scsi_tape *un);
384 static int st_modeselect(struct scsi_tape *un);
385 static int st_handle_incomplete(struct scsi_tape *un, struct buf *bp);
386 static int st_wrongtapetype(struct scsi_tape *un);
387 static int st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt);
388 static int st_handle_sense(struct scsi_tape *un, struct buf *bp);
389 static int st_handle_autosense(struct scsi_tape *un, struct buf *bp);
390 static int st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt,
391 	struct scsi_status *);
392 static int st_report_soft_errors(dev_t dev, int flag);
393 static void st_delayed_cv_broadcast(void *arg);
394 static int st_check_media(dev_t dev, enum mtio_state state);
395 static int st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
396 static void st_intr_restart(void *arg);
397 static void st_start_restart(void *arg);
398 static int st_gen_mode_sense(struct scsi_tape *un, int page,
399     struct seq_mode *page_data, int page_size);
400 static int st_change_block_size(dev_t dev, uint32_t nblksz);
401 static int st_gen_mode_select(struct scsi_tape *un, struct seq_mode *page_data,
402     int page_size);
403 static int st_tape_init(dev_t dev);
404 static void st_flush(struct scsi_tape *un);
405 static void st_set_pe_errno(struct scsi_tape *un);
406 static void st_hba_unflush(struct scsi_tape *un);
407 static void st_turn_pe_on(struct scsi_tape *un);
408 static void st_turn_pe_off(struct scsi_tape *un);
409 static void st_set_pe_flag(struct scsi_tape *un);
410 static void st_clear_pe(struct scsi_tape *un);
411 static void st_wait_for_io(struct scsi_tape *un);
412 static int st_set_devconfig_page(struct scsi_tape *un, int compression_on);
413 static int st_set_datacomp_page(struct scsi_tape *un, int compression_on);
414 static int st_tape_reservation_init(dev_t dev);
415 static int st_reserve_release(dev_t dev, int command);
416 static int st_take_ownership(dev_t dev);
417 static int st_check_asc_ascq(struct scsi_tape *un);
418 static int st_check_clean_bit(dev_t dev);
419 static int st_check_alert_clean_bit(dev_t dev);
420 static int st_check_sequential_clean_bit(dev_t dev);
421 static int st_check_sense_clean_bit(dev_t dev);
422 static int st_clear_unit_attentions(dev_t dev_instance, int max_trys);
423 static void st_calculate_timeouts(struct scsi_tape *un);
424 
425 #if defined(__i386) || defined(__amd64)
426 /*
427  * routines for I/O in big block size
428  */
429 static void st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp);
430 static struct contig_mem *st_get_contig_mem(struct scsi_tape *un, size_t len,
431     int alloc_flags);
432 static int st_bigblk_xfer_done(struct buf *bp);
433 static struct buf *st_get_bigblk_bp(struct buf *bp);
434 #endif
435 
436 /*
437  * error statistics create/update functions
438  */
439 static int st_create_errstats(struct scsi_tape *, int);
440 static void st_uscsi_minphys(struct buf *bp);
441 static int st_validate_tapemarks(struct scsi_tape *un, int fileno, daddr_t bn);
442 
443 #ifdef STDEBUG
444 static void st_debug_cmds(struct scsi_tape *un, int com, int count, int wait);
445 static char *st_dev_name(dev_t dev);
446 #endif /* STDEBUG */
447 
448 #if !defined(lint)
449 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_pkt buf uio scsi_cdb))
450 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_extended_sense scsi_status))
451 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device))
452 _NOTE(DATA_READABLE_WITHOUT_LOCK(st_drivetype scsi_address))
453 #endif
454 
455 /*
456  * autoconfiguration routines.
457  */
458 char _depends_on[] = "misc/scsi";
459 
460 static struct modldrv modldrv = {
461 	&mod_driverops,		/* Type of module. This one is a driver */
462 	"SCSI tape Driver %I%", /* Name of the module. */
463 	&st_ops			/* driver ops */
464 };
465 
466 static struct modlinkage modlinkage = {
467 	MODREV_1, &modldrv, NULL
468 };
469 
470 /*
471  * Notes on Post Reset Behavior in the tape driver:
472  *
473  * When the tape drive is opened, the driver  attempts  to make sure that
474  * the tape head is positioned exactly where it was left when it was last
475  * closed  provided  the  medium  is not  changed.  If the tape  drive is
476  * opened in O_NDELAY mode, the repositioning  (if necessary for any loss
477  * of position due to reset) will happen when the first tape operation or
478  * I/O occurs.  The repositioning (if required) may not be possible under
479  * certain situations such as when the device firmware not able to report
480  * the medium  change in the REQUEST  SENSE data  because of a reset or a
481  * misbehaving  bus  not  allowing  the  reposition  to  happen.  In such
482  * extraordinary  situations, where the driver fails to position the head
483  * at its  original  position,  it will fail the open the first  time, to
484  * save the applications from overwriting the data.  All further attempts
485  * to open the tape device will result in the driver  attempting  to load
486  * the  tape at BOT  (beginning  of  tape).  Also a  warning  message  to
487  * indicate  that further  attempts to open the tape device may result in
488  * the tape being  loaded at BOT will be printed on the  console.  If the
489  * tape  device is opened  in  O_NDELAY  mode,  failure  to  restore  the
490  * original tape head  position,  will result in the failure of the first
491  * tape  operation  or I/O,  Further,  the  driver  will  invalidate  its
492  * internal tape position  which will  necessitate  the  applications  to
493  * validate the position by using either a tape  positioning  ioctl (such
494  * as MTREW) or closing and reopening the tape device.
495  *
496  */
497 
498 int
499 _init(void)
500 {
501 	int e;
502 
503 	if (((e = ddi_soft_state_init(&st_state,
504 	    sizeof (struct scsi_tape), ST_MAXUNIT)) != 0)) {
505 		return (e);
506 	}
507 
508 	if ((e = mod_install(&modlinkage)) != 0) {
509 		ddi_soft_state_fini(&st_state);
510 	}
511 
512 	return (e);
513 }
514 
515 int
516 _fini(void)
517 {
518 	int e;
519 
520 	if ((e = mod_remove(&modlinkage)) != 0) {
521 		return (e);
522 	}
523 
524 	ddi_soft_state_fini(&st_state);
525 
526 	return (e);
527 }
528 
529 int
530 _info(struct modinfo *modinfop)
531 {
532 	return (mod_info(&modlinkage, modinfop));
533 }
534 
535 
536 static int
537 st_probe(dev_info_t *devi)
538 {
539 	int instance;
540 	struct scsi_device *devp;
541 	int rval;
542 
543 #if !defined(__sparc)
544 	char    *tape_prop;
545 	int	tape_prop_len;
546 #endif
547 
548 	/* If self identifying device */
549 	if (ddi_dev_is_sid(devi) == DDI_SUCCESS) {
550 		return (DDI_PROBE_DONTCARE);
551 	}
552 
553 #if !defined(__sparc)
554 	/*
555 	 * Since some x86 HBAs have devnodes that look like SCSI as
556 	 * far as we can tell but aren't really SCSI (DADK, like mlx)
557 	 * we check for the presence of the "tape" property.
558 	 */
559 	if (ddi_prop_op(DDI_DEV_T_NONE, devi, PROP_LEN_AND_VAL_ALLOC,
560 	    DDI_PROP_CANSLEEP, "tape",
561 	    (caddr_t)&tape_prop, &tape_prop_len) != DDI_PROP_SUCCESS) {
562 		return (DDI_PROBE_FAILURE);
563 	}
564 	if (strncmp(tape_prop, "sctp", tape_prop_len) != 0) {
565 		kmem_free(tape_prop, tape_prop_len);
566 		return (DDI_PROBE_FAILURE);
567 	}
568 	kmem_free(tape_prop, tape_prop_len);
569 #endif
570 
571 	devp = ddi_get_driver_private(devi);
572 	instance = ddi_get_instance(devi);
573 
574 	if (ddi_get_soft_state(st_state, instance) != NULL) {
575 		return (DDI_PROBE_PARTIAL);
576 	}
577 
578 
579 	/*
580 	 * Turn around and call probe routine to see whether
581 	 * we actually have a tape at this SCSI nexus.
582 	 */
583 	if (scsi_probe(devp, NULL_FUNC) == SCSIPROBE_EXISTS) {
584 
585 		/*
586 		 * In checking the whole inq_dtype byte we are looking at both
587 		 * the Peripheral Qualifier and the Peripheral Device Type.
588 		 * For this driver we are only interested in sequential devices
589 		 * that are connected or capable if connecting to this logical
590 		 * unit.
591 		 */
592 		if (devp->sd_inq->inq_dtype ==
593 		    (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) {
594 			ST_DEBUG6(devi, st_label, SCSI_DEBUG,
595 			    "probe exists\n");
596 			rval = DDI_PROBE_SUCCESS;
597 		} else {
598 			rval = DDI_PROBE_FAILURE;
599 		}
600 	} else {
601 		ST_DEBUG6(devi, st_label, SCSI_DEBUG,
602 		    "probe failure: nothing there\n");
603 		rval = DDI_PROBE_FAILURE;
604 	}
605 	scsi_unprobe(devp);
606 	return (rval);
607 }
608 
609 static int
610 st_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
611 {
612 	int 	instance;
613 	int	wide;
614 	int 	dev_instance;
615 	int	ret_status;
616 	struct	scsi_device *devp;
617 	int	node_ix;
618 	struct	scsi_tape *un;
619 
620 	devp = ddi_get_driver_private(devi);
621 	instance = ddi_get_instance(devi);
622 
623 	switch (cmd) {
624 		case DDI_ATTACH:
625 			if (st_doattach(devp, SLEEP_FUNC) == DDI_FAILURE) {
626 				return (DDI_FAILURE);
627 			}
628 			break;
629 		case DDI_RESUME:
630 			/*
631 			 * Suspend/Resume
632 			 *
633 			 * When the driver suspended, there might be
634 			 * outstanding cmds and therefore we need to
635 			 * reset the suspended flag and resume the scsi
636 			 * watch thread and restart commands and timeouts
637 			 */
638 
639 			if (!(un = ddi_get_soft_state(st_state, instance))) {
640 				return (DDI_FAILURE);
641 			}
642 			dev_instance = ((un->un_dev == 0) ? MTMINOR(instance) :
643 			    un->un_dev);
644 
645 			mutex_enter(ST_MUTEX);
646 
647 			un->un_throttle = un->un_max_throttle;
648 			un->un_tids_at_suspend = 0;
649 			un->un_pwr_mgmt = ST_PWR_NORMAL;
650 
651 			if (un->un_swr_token) {
652 				scsi_watch_resume(un->un_swr_token);
653 			}
654 
655 			/*
656 			 * Restart timeouts
657 			 */
658 			if ((un->un_tids_at_suspend & ST_DELAY_TID) != 0) {
659 				mutex_exit(ST_MUTEX);
660 				un->un_delay_tid =
661 				    timeout(st_delayed_cv_broadcast, un,
662 					drv_usectohz((clock_t)
663 					MEDIA_ACCESS_DELAY));
664 				mutex_enter(ST_MUTEX);
665 			}
666 
667 			if (un->un_tids_at_suspend & ST_HIB_TID) {
668 				mutex_exit(ST_MUTEX);
669 				un->un_hib_tid = timeout(st_intr_restart, un,
670 				    ST_STATUS_BUSY_TIMEOUT);
671 				mutex_enter(ST_MUTEX);
672 			}
673 
674 			ret_status = st_clear_unit_attentions(dev_instance, 5);
675 
676 			/*
677 			 * now check if we need to restore the tape position
678 			 */
679 			if ((un->un_suspend_fileno > 0) ||
680 			    (un->un_suspend_blkno > 0)) {
681 				if (ret_status != 0) {
682 					/*
683 					 * tape didn't get good TUR
684 					 * just print out error messages
685 					 */
686 					scsi_log(ST_DEVINFO, st_label, CE_WARN,
687 					    "st_attach-RESUME: tape failure "
688 					    " tape position will be lost");
689 				} else {
690 					/* this prints errors */
691 					(void) st_validate_tapemarks(un,
692 					    un->un_suspend_fileno,
693 					    un->un_suspend_blkno);
694 				}
695 				/*
696 				 * there are no retries, if there is an error
697 				 * we don't know if the tape has changed
698 				 */
699 				un->un_suspend_fileno = 0;
700 				un->un_suspend_blkno = 0;
701 			}
702 
703 			/* now we are ready to start up any queued I/Os */
704 			if (un->un_ncmds || un->un_quef) {
705 				st_start(un);
706 			}
707 
708 			cv_broadcast(&un->un_suspend_cv);
709 			mutex_exit(ST_MUTEX);
710 			return (DDI_SUCCESS);
711 
712 		default:
713 			return (DDI_FAILURE);
714 	}
715 
716 	un = ddi_get_soft_state(st_state, instance);
717 
718 	ST_DEBUG(devi, st_label, SCSI_DEBUG,
719 	    "st_attach: instance=%x\n", instance);
720 
721 	/*
722 	 * find the drive type for this target
723 	 */
724 	st_known_tape_type(un);
725 
726 	for (node_ix = 0; node_ix < ST_NUM_MEMBERS(st_minor_data); node_ix++) {
727 		int minor;
728 		char *name;
729 
730 		name  = st_minor_data[node_ix].name;
731 		minor = st_minor_data[node_ix].minor;
732 
733 		/*
734 		 * For default devices set the density to the
735 		 * preferred default density for this device.
736 		 */
737 		if (node_ix <= DEF_BSD_NR) {
738 			minor |= un->un_dp->default_density;
739 		}
740 		minor |= MTMINOR(instance);
741 
742 		if (ddi_create_minor_node(devi, name, S_IFCHR, minor,
743 		    DDI_NT_TAPE, NULL) == DDI_SUCCESS) {
744 			continue;
745 		}
746 
747 		ddi_remove_minor_node(devi, NULL);
748 		if (un) {
749 			cv_destroy(&un->un_clscv);
750 			cv_destroy(&un->un_sbuf_cv);
751 			cv_destroy(&un->un_queue_cv);
752 			cv_destroy(&un->un_state_cv);
753 			cv_destroy(&un->un_suspend_cv);
754 			cv_destroy(&un->un_tape_busy_cv);
755 
756 			if (un->un_sbufp) {
757 				freerbuf(un->un_sbufp);
758 			}
759 			if (un->un_uscsi_rqs_buf) {
760 				kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
761 			}
762 			if (un->un_mspl) {
763 				ddi_iopb_free((caddr_t)un->un_mspl);
764 			}
765 			scsi_destroy_pkt(un->un_rqs);
766 			scsi_free_consistent_buf(un->un_rqs_bp);
767 			ddi_soft_state_free(st_state, instance);
768 			devp->sd_private = NULL;
769 			devp->sd_sense = NULL;
770 
771 		}
772 		ddi_prop_remove_all(devi);
773 		return (DDI_FAILURE);
774 	}
775 
776 	/*
777 	 * Add a zero-length attribute to tell the world we support
778 	 * kernel ioctls (for layered drivers)
779 	 */
780 	(void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
781 	    DDI_KERNEL_IOCTL, NULL, 0);
782 
783 	ddi_report_dev((dev_info_t *)devi);
784 
785 	/*
786 	 * If it's a SCSI-2 tape drive which supports wide,
787 	 * tell the host adapter to use wide.
788 	 */
789 	wide = ((devp->sd_inq->inq_rdf == RDF_SCSI2) &&
790 	    (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) ?
791 		1 : 0;
792 
793 	if (scsi_ifsetcap(ROUTE, "wide-xfer", wide, 1) == 1) {
794 		ST_DEBUG(devi, st_label, SCSI_DEBUG,
795 		    "Wide Transfer %s\n", wide ? "enabled" : "disabled");
796 	}
797 
798 	/*
799 	 * enable autorequest sense; keep the rq packet around in case
800 	 * the autorequest sense fails because of a busy condition
801 	 * do a getcap first in case the capability is not variable
802 	 */
803 	if (scsi_ifgetcap(ROUTE, "auto-rqsense", 1) == 1) {
804 		un->un_arq_enabled = 1;
805 	} else {
806 		un->un_arq_enabled =
807 		    ((scsi_ifsetcap(ROUTE, "auto-rqsense", 1, 1) == 1) ? 1 : 0);
808 	}
809 
810 
811 	ST_DEBUG(devi, st_label, SCSI_DEBUG, "auto request sense %s\n",
812 		(un->un_arq_enabled ? "enabled" : "disabled"));
813 
814 	un->un_untagged_qing =
815 	    (scsi_ifgetcap(ROUTE, "untagged-qing", 0) == 1);
816 
817 	/*
818 	 * XXX - This is just for 2.6.  to tell users that write buffering
819 	 *	has gone away.
820 	 */
821 	if (un->un_arq_enabled && un->un_untagged_qing) {
822 		if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
823 		    "tape-driver-buffering", 0) != 0) {
824 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
825 			    "Write Data Buffering has been depricated. Your "
826 			    "applications should continue to work normally.\n"
827 			    " But, they should  ported to use Asynchronous "
828 			    " I/O\n"
829 			    " For more information, read about "
830 			    " tape-driver-buffering "
831 			    "property in the st(7d) man page\n");
832 		}
833 	}
834 
835 	un->un_max_throttle = un->un_throttle = un->un_last_throttle = 1;
836 	un->un_flush_on_errors = 0;
837 	un->un_mkr_pkt = (struct scsi_pkt *)NULL;
838 
839 	ST_DEBUG(devi, st_label, SCSI_DEBUG,
840 	    "throttle=%x, max_throttle = %x\n",
841 	    un->un_throttle, un->un_max_throttle);
842 
843 	/* initialize persistent errors to nil */
844 	un->un_persistence = 0;
845 	un->un_persist_errors = 0;
846 
847 	/*
848 	 * Get dma-max from HBA driver. If it is not defined, use 64k
849 	 */
850 	un->un_maxdma	= scsi_ifgetcap(&devp->sd_address, "dma-max", 1);
851 	if (un->un_maxdma == -1) {
852 		un->un_maxdma = (64 * 1024);
853 	}
854 
855 	un->un_maxbsize = MAXBSIZE_UNKNOWN;
856 
857 	un->un_mediastate = MTIO_NONE;
858 	un->un_HeadClean  = TAPE_ALERT_SUPPORT_UNKNOWN;
859 
860 	/*
861 	 * initialize kstats
862 	 */
863 	un->un_stats = kstat_create("st", instance, NULL, "tape",
864 			KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
865 	if (un->un_stats) {
866 		un->un_stats->ks_lock = ST_MUTEX;
867 		kstat_install(un->un_stats);
868 	}
869 	(void) st_create_errstats(un, instance);
870 
871 	return (DDI_SUCCESS);
872 }
873 
874 /*
875  * st_detach:
876  *
877  * we allow a detach if and only if:
878  *	- no tape is currently inserted
879  *	- tape position is at BOT or unknown
880  *		(if it is not at BOT then a no rewind
881  *		device was opened and we have to preserve state)
882  *	- it must be in a closed state : no timeouts or scsi_watch requests
883  *		will exist if it is closed, so we don't need to check for
884  *		them here.
885  */
886 /*ARGSUSED*/
887 static int
888 st_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
889 {
890 	int 	instance;
891 	int 	dev_instance;
892 	struct scsi_device *devp;
893 	struct scsi_tape *un;
894 	clock_t wait_cmds_complete;
895 
896 	instance = ddi_get_instance(devi);
897 
898 	if (!(un = ddi_get_soft_state(st_state, instance))) {
899 		return (DDI_FAILURE);
900 	}
901 
902 	switch (cmd) {
903 
904 	case DDI_DETACH:
905 		/*
906 		 * Undo what we did in st_attach & st_doattach,
907 		 * freeing resources and removing things we installed.
908 		 * The system framework guarantees we are not active
909 		 * with this devinfo node in any other entry points at
910 		 * this time.
911 		 */
912 
913 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
914 		    "st_detach: instance=%x, un=%p\n", instance,
915 		    (void *)un);
916 
917 		if (((un->un_dp->options & ST_UNLOADABLE) == 0) ||
918 		    (un->un_ncmds != 0) || (un->un_quef != NULL) ||
919 		    (un->un_state != ST_STATE_CLOSED)) {
920 			/*
921 			 * we cannot unload some targets because the
922 			 * inquiry returns junk unless immediately
923 			 * after a reset
924 			 */
925 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
926 			    "cannot unload instance %x\n", instance);
927 			return (DDI_FAILURE);
928 		}
929 
930 		/*
931 		 * if the tape has been removed then we may unload;
932 		 * do a test unit ready and if it returns NOT READY
933 		 * then we assume that it is safe to unload.
934 		 * as a side effect, fileno may be set to -1 if the
935 		 * the test unit ready fails;
936 		 * also un_state may be set to non-closed, so reset it
937 		 */
938 		if ((un->un_dev) &&		/* Been opened since attach */
939 		    ((un->un_fileno > 0) ||	/* Known position not rewound */
940 		    (un->un_blkno != 0))) {	/* Or within first file */
941 			mutex_enter(ST_MUTEX);
942 			/*
943 			 * Send Test Unit Ready in the hopes that if
944 			 * the drive is not in the state we think it is.
945 			 * And the state will be changed so it can be detached.
946 			 * If the command fails to reach the device and
947 			 * the drive was not rewound or unloaded we want
948 			 * to fail the detach till a user command fails
949 			 * where after the detach will succead.
950 			 */
951 			(void) st_cmd(un->un_dev, SCMD_TEST_UNIT_READY,
952 			    0, SYNC_CMD);
953 			/*
954 			 * After TUR un_state may be set to non-closed,
955 			 * so reset it back.
956 			 */
957 			un->un_state = ST_STATE_CLOSED;
958 			mutex_exit(ST_MUTEX);
959 		}
960 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
961 		    "un_status=%x, fileno=%x, blkno=%lx\n",
962 		    un->un_status, un->un_fileno, un->un_blkno);
963 
964 		/*
965 		 * check again:
966 		 * if we are not at BOT then it is not safe to unload
967 		 */
968 		if ((un->un_dev) &&		/* Been opened since attach */
969 		    ((un->un_fileno > 0) ||	/* Known position not rewound */
970 		    (un->un_blkno != 0))) {	/* Or within first file */
971 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
972 			    "cannot detach: fileno=%x, blkno=%lx\n",
973 			    un->un_fileno, un->un_blkno);
974 			return (DDI_FAILURE);
975 		}
976 
977 		/*
978 		 * Just To make sure that we have released the
979 		 * tape unit .
980 		 */
981 		if (un->un_dev && (un->un_rsvd_status & ST_RESERVE) &&
982 		    !DEVI_IS_DEVICE_REMOVED(devi)) {
983 			mutex_enter(ST_MUTEX);
984 			(void) st_cmd(un->un_dev, SCMD_RELEASE, 0, SYNC_CMD);
985 			mutex_exit(ST_MUTEX);
986 		}
987 
988 		/*
989 		 * now remove other data structures allocated in st_doattach()
990 		 */
991 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
992 		    "destroying/freeing\n");
993 		cv_destroy(&un->un_clscv);
994 		cv_destroy(&un->un_sbuf_cv);
995 		cv_destroy(&un->un_queue_cv);
996 		cv_destroy(&un->un_suspend_cv);
997 		cv_destroy(&un->un_tape_busy_cv);
998 
999 		if (un->un_hib_tid) {
1000 			(void) untimeout(un->un_hib_tid);
1001 			un->un_hib_tid = 0;
1002 		}
1003 
1004 		if (un->un_delay_tid) {
1005 			(void) untimeout(un->un_delay_tid);
1006 			un->un_delay_tid = 0;
1007 		}
1008 		cv_destroy(&un->un_state_cv);
1009 
1010 #if defined(__i386) || defined(__amd64)
1011 		if (un->un_contig_mem_hdl != NULL) {
1012 			ddi_dma_free_handle(&un->un_contig_mem_hdl);
1013 		}
1014 #endif
1015 		if (un->un_sbufp) {
1016 			freerbuf(un->un_sbufp);
1017 		}
1018 		if (un->un_uscsi_rqs_buf) {
1019 			kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
1020 		}
1021 		if (un->un_mspl) {
1022 			ddi_iopb_free((caddr_t)un->un_mspl);
1023 		}
1024 		if (un->un_rqs) {
1025 			scsi_destroy_pkt(un->un_rqs);
1026 			scsi_free_consistent_buf(un->un_rqs_bp);
1027 		}
1028 		if (un->un_mkr_pkt) {
1029 			scsi_destroy_pkt(un->un_mkr_pkt);
1030 		}
1031 		if (un->un_arq_enabled) {
1032 			(void) scsi_ifsetcap(ROUTE, "auto-rqsense", 0, 1);
1033 		}
1034 		if (un->un_dp_size) {
1035 			kmem_free(un->un_dp, un->un_dp_size);
1036 		}
1037 		if (un->un_stats) {
1038 			kstat_delete(un->un_stats);
1039 			un->un_stats = (kstat_t *)0;
1040 		}
1041 		if (un->un_errstats) {
1042 			kstat_delete(un->un_errstats);
1043 			un->un_errstats = (kstat_t *)0;
1044 		}
1045 		devp = ST_SCSI_DEVP;
1046 		ddi_soft_state_free(st_state, instance);
1047 		devp->sd_private = NULL;
1048 		devp->sd_sense = NULL;
1049 		scsi_unprobe(devp);
1050 		ddi_prop_remove_all(devi);
1051 		ddi_remove_minor_node(devi, NULL);
1052 		ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach done\n");
1053 		return (DDI_SUCCESS);
1054 
1055 	case DDI_SUSPEND:
1056 
1057 		/*
1058 		 * Suspend/Resume
1059 		 *
1060 		 * To process DDI_SUSPEND, we must do the following:
1061 		 *
1062 		 *  - check ddi_removing_power to see if power will be turned
1063 		 *    off. if so, return DDI_FAILURE
1064 		 *  - check if we are already suspended,
1065 		 *    if so, return DDI_FAILURE
1066 		 *  - check if device state is CLOSED,
1067 		 *    if not, return DDI_FAILURE.
1068 		 *  - wait until outstanding operations complete
1069 		 *  - save tape state
1070 		 *  - block new operations
1071 		 *  - cancel pending timeouts
1072 		 *
1073 		 */
1074 
1075 		if (ddi_removing_power(devi))
1076 			return (DDI_FAILURE);
1077 
1078 		mutex_enter(ST_MUTEX);
1079 
1080 		/*
1081 		 * Shouldn't already be suspended, if so return failure
1082 		 */
1083 		if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
1084 			mutex_exit(ST_MUTEX);
1085 			return (DDI_FAILURE);
1086 		}
1087 		if (un->un_state != ST_STATE_CLOSED) {
1088 			mutex_exit(ST_MUTEX);
1089 			return (DDI_FAILURE);
1090 		}
1091 
1092 		/*
1093 		 * Wait for all outstanding I/O's to complete
1094 		 *
1095 		 * we wait on both ncmds and the wait queue for times
1096 		 * when we are flushing after persistent errors are
1097 		 * flagged, which is when ncmds can be 0, and the
1098 		 * queue can still have I/O's.  This way we preserve
1099 		 * order of biodone's.
1100 		 */
1101 		wait_cmds_complete = ddi_get_lbolt();
1102 		wait_cmds_complete +=
1103 		    st_wait_cmds_complete * drv_usectohz(1000000);
1104 		while (un->un_ncmds || un->un_quef ||
1105 		    (un->un_state == ST_STATE_RESOURCE_WAIT)) {
1106 
1107 			if (cv_timedwait(&un->un_tape_busy_cv, ST_MUTEX,
1108 			    wait_cmds_complete) == -1) {
1109 				/*
1110 				 * Time expired then cancel the command
1111 				 */
1112 				mutex_exit(ST_MUTEX);
1113 				if (scsi_reset(ROUTE, RESET_TARGET) == 0) {
1114 					mutex_enter(ST_MUTEX);
1115 					if (un->un_last_throttle) {
1116 						un->un_throttle =
1117 						    un->un_last_throttle;
1118 					}
1119 					mutex_exit(ST_MUTEX);
1120 					return (DDI_FAILURE);
1121 				} else {
1122 					mutex_enter(ST_MUTEX);
1123 					break;
1124 				}
1125 			}
1126 		}
1127 
1128 		/*
1129 		 * DDI_SUSPEND says that the system "may" power down, we
1130 		 * remember the file and block number before rewinding.
1131 		 * we also need to save state before issuing
1132 		 * any WRITE_FILE_MARK command.
1133 		 */
1134 		if (un->un_fileno < 0) {
1135 			un->un_suspend_fileno = 0;
1136 			un->un_suspend_blkno  = 0;
1137 		} else {
1138 			un->un_suspend_fileno = un->un_fileno;
1139 			un->un_suspend_blkno = un->un_blkno;
1140 		}
1141 		dev_instance = ((un->un_dev == 0) ? MTMINOR(instance) :
1142 		    un->un_dev);
1143 
1144 		/*
1145 		 * Issue a zero write file fmk command to tell the drive to
1146 		 * flush any buffered tape marks
1147 		 */
1148 		(void) st_cmd(dev_instance, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD);
1149 
1150 		/*
1151 		 * Because not all tape drives correctly implement buffer
1152 		 * flushing with the zero write file fmk command, issue a
1153 		 * synchronous rewind command to force data flushing.
1154 		 * st_validate_tapemarks() will do a rewind during DDI_RESUME
1155 		 * anyway.
1156 		 */
1157 		(void) st_cmd(dev_instance, SCMD_REWIND, 0, SYNC_CMD);
1158 
1159 		/* stop any new operations */
1160 		un->un_pwr_mgmt = ST_PWR_SUSPENDED;
1161 		un->un_throttle = 0;
1162 
1163 		/*
1164 		 * cancel any outstanding timeouts
1165 		 */
1166 		if (un->un_delay_tid) {
1167 			timeout_id_t temp_id = un->un_delay_tid;
1168 			un->un_delay_tid = 0;
1169 			un->un_tids_at_suspend |= ST_DELAY_TID;
1170 			mutex_exit(ST_MUTEX);
1171 			(void) untimeout(temp_id);
1172 			mutex_enter(ST_MUTEX);
1173 		}
1174 
1175 		if (un->un_hib_tid) {
1176 			timeout_id_t temp_id = un->un_hib_tid;
1177 			un->un_hib_tid = 0;
1178 			un->un_tids_at_suspend |= ST_HIB_TID;
1179 			mutex_exit(ST_MUTEX);
1180 			(void) untimeout(temp_id);
1181 			mutex_enter(ST_MUTEX);
1182 		}
1183 
1184 		/*
1185 		 * Suspend the scsi_watch_thread
1186 		 */
1187 		if (un->un_swr_token) {
1188 			opaque_t temp_token = un->un_swr_token;
1189 			mutex_exit(ST_MUTEX);
1190 			scsi_watch_suspend(temp_token);
1191 		} else {
1192 			mutex_exit(ST_MUTEX);
1193 		}
1194 
1195 		return (DDI_SUCCESS);
1196 
1197 	default:
1198 		ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach failed\n");
1199 		return (DDI_FAILURE);
1200 	}
1201 }
1202 
1203 
1204 /* ARGSUSED */
1205 static int
1206 stinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
1207 {
1208 	dev_t dev;
1209 	struct scsi_tape *un;
1210 	int instance, error;
1211 	switch (infocmd) {
1212 	case DDI_INFO_DEVT2DEVINFO:
1213 		dev = (dev_t)arg;
1214 		instance = MTUNIT(dev);
1215 		if ((un = ddi_get_soft_state(st_state, instance)) == NULL)
1216 			return (DDI_FAILURE);
1217 		*result = (void *) ST_DEVINFO;
1218 		error = DDI_SUCCESS;
1219 		break;
1220 	case DDI_INFO_DEVT2INSTANCE:
1221 		dev = (dev_t)arg;
1222 		instance = MTUNIT(dev);
1223 		*result = (void *)(uintptr_t)instance;
1224 		error = DDI_SUCCESS;
1225 		break;
1226 	default:
1227 		error = DDI_FAILURE;
1228 	}
1229 	return (error);
1230 }
1231 
1232 static int
1233 st_doattach(struct scsi_device *devp, int (*canwait)())
1234 {
1235 	struct scsi_pkt *rqpkt = NULL;
1236 	struct scsi_tape *un = NULL;
1237 	int km_flags = (canwait != NULL_FUNC) ? KM_SLEEP : KM_NOSLEEP;
1238 	int instance;
1239 	struct buf *bp;
1240 
1241 	/*
1242 	 * Call the routine scsi_probe to do some of the dirty work.
1243 	 * If the INQUIRY command succeeds, the field sd_inq in the
1244 	 * device structure will be filled in.
1245 	 */
1246 	ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1247 		"st_doattach(): probing\n");
1248 
1249 	if (scsi_probe(devp, canwait) == SCSIPROBE_EXISTS) {
1250 
1251 		/*
1252 		 * In checking the whole inq_dtype byte we are looking at both
1253 		 * the Peripheral Qualifier and the Peripheral Device Type.
1254 		 * For this driver we are only interested in sequential devices
1255 		 * that are connected or capable if connecting to this logical
1256 		 * unit.
1257 		 */
1258 		if (devp->sd_inq->inq_dtype ==
1259 		    (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) {
1260 			ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1261 			    "probe exists\n");
1262 		} else {
1263 			/* Something there but not a tape device */
1264 			scsi_unprobe(devp);
1265 			return (DDI_FAILURE);
1266 		}
1267 	} else {
1268 		/* Nothing there */
1269 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1270 		    "probe failure: nothing there\n");
1271 		scsi_unprobe(devp);
1272 		return (DDI_FAILURE);
1273 	}
1274 
1275 	bp = scsi_alloc_consistent_buf(&devp->sd_address, (struct buf *)NULL,
1276 	    SENSE_LENGTH, B_READ, canwait, NULL);
1277 	if (!bp) {
1278 		goto error;
1279 	}
1280 	rqpkt = scsi_init_pkt(&devp->sd_address,
1281 	    (struct scsi_pkt *)NULL, bp, CDB_GROUP0, 1, 0,
1282 	    PKT_CONSISTENT, canwait, NULL);
1283 	if (!rqpkt) {
1284 		goto error;
1285 	}
1286 	devp->sd_sense = (struct scsi_extended_sense *)bp->b_un.b_addr;
1287 	ASSERT(geterror(bp) == NULL);
1288 
1289 	(void) scsi_setup_cdb((union scsi_cdb *)rqpkt->pkt_cdbp,
1290 	    SCMD_REQUEST_SENSE, 0, SENSE_LENGTH, 0);
1291 	FILL_SCSI1_LUN(devp, rqpkt);
1292 
1293 	/*
1294 	 * The actual unit is present.
1295 	 * Now is the time to fill in the rest of our info..
1296 	 */
1297 	instance = ddi_get_instance(devp->sd_dev);
1298 
1299 	if (ddi_soft_state_zalloc(st_state, instance) != DDI_SUCCESS) {
1300 		goto error;
1301 	}
1302 	un = ddi_get_soft_state(st_state, instance);
1303 
1304 	un->un_sbufp = getrbuf(km_flags);
1305 
1306 	un->un_uscsi_rqs_buf = kmem_alloc(SENSE_LENGTH, KM_SLEEP);
1307 
1308 	(void) ddi_iopb_alloc(devp->sd_dev, (ddi_dma_lim_t *)0,
1309 		sizeof (struct seq_mode), (caddr_t *)&un->un_mspl);
1310 
1311 	if (!un->un_sbufp || !un->un_mspl) {
1312 		if (un->un_mspl) {
1313 			ddi_iopb_free((caddr_t)un->un_mspl);
1314 		}
1315 		ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG,
1316 		    "probe partial failure: no space\n");
1317 		goto error;
1318 	}
1319 
1320 	bzero(un->un_mspl, sizeof (struct seq_mode));
1321 
1322 	cv_init(&un->un_sbuf_cv, NULL, CV_DRIVER, NULL);
1323 	cv_init(&un->un_queue_cv, NULL, CV_DRIVER, NULL);
1324 	cv_init(&un->un_clscv, NULL, CV_DRIVER, NULL);
1325 	cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL);
1326 #if defined(__i386) || defined(__amd64)
1327 	cv_init(&un->un_contig_mem_cv, NULL, CV_DRIVER, NULL);
1328 #endif
1329 
1330 	/* Initialize power managemnet condition variable */
1331 	cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL);
1332 	cv_init(&un->un_tape_busy_cv, NULL, CV_DRIVER, NULL);
1333 
1334 	rqpkt->pkt_flags |= (FLAG_SENSING | FLAG_HEAD | FLAG_NODISCON);
1335 
1336 	un->un_fileno	= -1;
1337 	rqpkt->pkt_time = st_io_time;
1338 	rqpkt->pkt_comp = st_intr;
1339 	un->un_rqs	= rqpkt;
1340 	un->un_sd	= devp;
1341 	un->un_rqs_bp	= bp;
1342 	un->un_swr_token = (opaque_t)NULL;
1343 	un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE;
1344 
1345 	un->un_suspend_fileno 	= 0;
1346 	un->un_suspend_blkno 	= 0;
1347 
1348 #if defined(__i386) || defined(__amd64)
1349 	if (ddi_dma_alloc_handle(ST_DEVINFO, &st_contig_mem_dma_attr,
1350 		DDI_DMA_SLEEP, NULL, &un->un_contig_mem_hdl) != DDI_SUCCESS) {
1351 		ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG,
1352 		    "allocation of contiguous memory dma handle failed!");
1353 		un->un_contig_mem_hdl = NULL;
1354 		goto error;
1355 	}
1356 #endif
1357 
1358 	/*
1359 	 * Since this driver manages devices with "remote" hardware,
1360 	 * i.e. the devices themselves have no "reg" properties,
1361 	 * the SUSPEND/RESUME commands in detach/attach will not be
1362 	 * called by the power management framework unless we request
1363 	 * it by creating a "pm-hardware-state" property and setting it
1364 	 * to value "needs-suspend-resume".
1365 	 */
1366 	if (ddi_prop_update_string(DDI_DEV_T_NONE, devp->sd_dev,
1367 	    "pm-hardware-state", "needs-suspend-resume") !=
1368 	    DDI_PROP_SUCCESS) {
1369 
1370 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1371 		    "ddi_prop_update(\"pm-hardware-state\") failed\n");
1372 		goto error;
1373 	}
1374 
1375 	if (ddi_prop_create(DDI_DEV_T_NONE, devp->sd_dev, DDI_PROP_CANSLEEP,
1376 	    "no-involuntary-power-cycles", NULL, 0) != DDI_PROP_SUCCESS) {
1377 
1378 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1379 		    "ddi_prop_create(\"no-involuntary-power-cycles\") "
1380 		    "failed\n");
1381 		goto error;
1382 	}
1383 
1384 	ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, "probe success\n");
1385 	return (DDI_SUCCESS);
1386 
1387 error:
1388 	devp->sd_sense = NULL;
1389 
1390 	ddi_remove_minor_node(devp->sd_dev, NULL);
1391 	if (un) {
1392 		if (un->un_mspl) {
1393 			ddi_iopb_free((caddr_t)un->un_mspl);
1394 		}
1395 		if (un->un_sbufp) {
1396 			freerbuf(un->un_sbufp);
1397 		}
1398 		if (un->un_uscsi_rqs_buf) {
1399 			kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
1400 		}
1401 #if defined(__i386) || defined(__amd64)
1402 		if (un->un_contig_mem_hdl != NULL) {
1403 			ddi_dma_free_handle(&un->un_contig_mem_hdl);
1404 		}
1405 #endif
1406 		ddi_soft_state_free(st_state, instance);
1407 		devp->sd_private = NULL;
1408 	}
1409 
1410 	if (rqpkt) {
1411 		scsi_destroy_pkt(rqpkt);
1412 	}
1413 
1414 	if (bp) {
1415 		scsi_free_consistent_buf(bp);
1416 	}
1417 
1418 	if (devp->sd_inq) {
1419 		scsi_unprobe(devp);
1420 	}
1421 	return (DDI_FAILURE);
1422 }
1423 
1424 typedef int
1425 (*cfg_functp)(struct scsi_tape *, char *vidpid, struct st_drivetype *);
1426 
1427 static cfg_functp config_functs[] = {
1428 	st_get_conf_from_st_dot_conf,
1429 	st_get_conf_from_st_conf_dot_c,
1430 	st_get_default_conf
1431 };
1432 
1433 
1434 /*
1435  * determine tape type, using tape-config-list or built-in table or
1436  * use a generic tape config entry
1437  */
1438 static void
1439 st_known_tape_type(struct scsi_tape *un)
1440 {
1441 	struct st_drivetype *dp;
1442 	cfg_functp *config_funct;
1443 
1444 	/*
1445 	 * XXX:  Emulex MT-02 (and emulators) predates SCSI-1 and has
1446 	 *	 no vid & pid inquiry data.  So, we provide one.
1447 	 */
1448 	if (ST_INQUIRY->inq_len == 0 ||
1449 		(bcmp("\0\0\0\0\0\0\0\0", ST_INQUIRY->inq_vid, 8) == 0)) {
1450 		(void) strcpy((char *)ST_INQUIRY->inq_vid, ST_MT02_NAME);
1451 	}
1452 
1453 	un->un_dp_size = sizeof (struct st_drivetype);
1454 	dp = kmem_zalloc((size_t)un->un_dp_size, KM_SLEEP);
1455 	un->un_dp = dp;
1456 
1457 	/*
1458 	 * Loop through the configuration methods till one works.
1459 	 */
1460 	for (config_funct = &config_functs[0]; ; config_funct++) {
1461 		if ((*config_funct)(un, ST_INQUIRY->inq_vid, dp)) {
1462 			break;
1463 		}
1464 	}
1465 
1466 	/*
1467 	 * If we didn't just make up this configuration and
1468 	 * all the density codes are the same..
1469 	 * Set Auto Density over ride.
1470 	 */
1471 	if (*config_funct != st_get_default_conf) {
1472 		/*
1473 		 * If this device is one that is configured and all
1474 		 * densities are the same, This saves doing gets and set
1475 		 * that yield nothing.
1476 		 */
1477 		if ((dp->densities[0]) == (dp->densities[1]) &&
1478 		    (dp->densities[0]) == (dp->densities[2]) &&
1479 		    (dp->densities[0]) == (dp->densities[3])) {
1480 
1481 			dp->options |= ST_AUTODEN_OVERRIDE;
1482 		}
1483 	}
1484 
1485 
1486 	/*
1487 	 * Store tape drive characteristics.
1488 	 */
1489 	un->un_status = 0;
1490 	un->un_attached = 1;
1491 	un->un_init_options = dp->options;
1492 
1493 	/* setup operation time-outs based on options */
1494 	st_calculate_timeouts(un);
1495 
1496 	/* make sure if we are supposed to be variable, make it variable */
1497 	if (dp->options & ST_VARIABLE) {
1498 		dp->bsize = 0;
1499 	}
1500 
1501 	scsi_log(ST_DEVINFO, st_label, CE_NOTE, "?<%s>\n", dp->name);
1502 }
1503 
1504 
1505 typedef struct {
1506 	int mask;
1507 	int bottom;
1508 	int top;
1509 	char *name;
1510 } conf_limit;
1511 
1512 static const conf_limit conf_limits[] = {
1513 
1514 	-1,		1,		2,		"conf version",
1515 	-1,		MT_ISTS,	ST_LAST_TYPE,	"drive type",
1516 	-1,		0,		0xffffff,	"block size",
1517 	ST_VALID_OPTS,	0,		ST_VALID_OPTS,	"options",
1518 	-1,		0,		4,		"number of densities",
1519 	-1,		0,		UINT8_MAX,	"density code",
1520 	-1,		0,		3,		"default density",
1521 	-1,		0,		UINT16_MAX,	"non motion timeout",
1522 	-1,		0,		UINT16_MAX,	"I/O timeout",
1523 	-1,		0,		UINT16_MAX,	"space timeout",
1524 	-1,		0,		UINT16_MAX,	"load timeout",
1525 	-1,		0,		UINT16_MAX,	"unload timeout",
1526 	-1,		0,		UINT16_MAX,	"erase timeout",
1527 	0,		0,		0,		NULL
1528 };
1529 
1530 static int
1531 st_validate_conf_data(struct scsi_tape *un, int *list, int list_len,
1532     const char *conf_name)
1533 {
1534 	int dens;
1535 	int ndens;
1536 	int value;
1537 	int type;
1538 	int count;
1539 	const conf_limit *limit = &conf_limits[0];
1540 
1541 	ST_DEBUG3(ST_DEVINFO, st_label, CE_NOTE,
1542 	    "Checking %d entrys total with %d densities\n", list_len, list[4]);
1543 
1544 	count = list_len;
1545 	type = *list;
1546 	for (;  count && limit->name; count--, list++, limit++) {
1547 
1548 		value = *list;
1549 		if (value & ~limit->mask) {
1550 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1551 			    "%s %s value invalid bits set: 0x%X\n",
1552 			    conf_name, limit->name, value & ~limit->mask);
1553 			*list &= limit->mask;
1554 		} else if (value < limit->bottom) {
1555 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1556 			    "%s %s value too low: value = %d limit %d\n",
1557 			    conf_name, limit->name, value, limit->bottom);
1558 		} else if (value > limit->top) {
1559 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1560 			    "%s %s value too high: value = %d limit %d\n",
1561 			    conf_name, limit->name, value, limit->top);
1562 		} else {
1563 			ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT,
1564 			    "%s %s value = 0x%X\n",
1565 			    conf_name, limit->name, value);
1566 		}
1567 
1568 		/* If not the number of densities continue */
1569 		if (limit != &conf_limits[4]) {
1570 			continue;
1571 		}
1572 
1573 		/* If number of densities is not in range can't use config */
1574 		if (value < limit->bottom || value > limit->top) {
1575 			return (-1);
1576 		}
1577 
1578 		ndens = min(value, NDENSITIES);
1579 		if ((type == 1) && (list_len - ndens) != 6) {
1580 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1581 			    "%s conf version 1 with %d densities has %d items"
1582 			    " should have %d",
1583 			    conf_name, ndens, list_len, 6 + ndens);
1584 		} else if ((type == 2) && (list_len - ndens) != 13) {
1585 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1586 			    "%s conf version 2 with %d densities has %d items"
1587 			    " should have %d",
1588 			    conf_name, ndens, list_len, 13 + ndens);
1589 		}
1590 
1591 		limit++;
1592 		for (dens = 0; dens < ndens && count; dens++) {
1593 			count--;
1594 			list++;
1595 			value = *list;
1596 			if (value < limit->bottom) {
1597 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1598 				    "%s density[%d] value too low: value ="
1599 				    " 0x%X limit 0x%X\n",
1600 				    conf_name, dens, value, limit->bottom);
1601 			} else if (value > limit->top) {
1602 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1603 				    "%s density[%d] value too high: value ="
1604 				    " 0x%X limit 0x%X\n",
1605 				    conf_name, dens, value, limit->top);
1606 			} else {
1607 				ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT,
1608 				    "%s density[%d] value = 0x%X\n",
1609 				    conf_name, dens, value);
1610 			}
1611 		}
1612 	}
1613 
1614 	return (0);
1615 }
1616 
1617 static int
1618 st_get_conf_from_st_dot_conf(struct scsi_tape *un, char *vidpid,
1619     struct st_drivetype *dp)
1620 {
1621 	caddr_t config_list = NULL;
1622 	caddr_t data_list = NULL;
1623 	int	*data_ptr;
1624 	caddr_t vidptr, prettyptr, datanameptr;
1625 	size_t	vidlen, prettylen, datanamelen, tripletlen = 0;
1626 	int config_list_len, data_list_len, len, i;
1627 	int version;
1628 	int found = 0;
1629 
1630 
1631 	/*
1632 	 * Determine type of tape controller. Type is determined by
1633 	 * checking the vendor ids of the earlier inquiry command and
1634 	 * comparing those with vids in tape-config-list defined in st.conf
1635 	 */
1636 	if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, DDI_PROP_DONTPASS,
1637 	    "tape-config-list", (caddr_t)&config_list, &config_list_len)
1638 	    != DDI_PROP_SUCCESS) {
1639 		return (found);
1640 	}
1641 
1642 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
1643 	    "st_get_conf_from_st_dot_conf(): st.conf has tape-config-list\n");
1644 
1645 	/*
1646 	 * Compare vids in each triplet - if it matches, get value for
1647 	 * data_name and contruct a st_drivetype struct
1648 	 * tripletlen is not set yet!
1649 	 */
1650 	for (len = config_list_len, vidptr = config_list;
1651 	    len > 0;
1652 	    vidptr += tripletlen, len -= tripletlen) {
1653 
1654 		vidlen = strlen(vidptr);
1655 		prettyptr = vidptr + vidlen + 1;
1656 		prettylen = strlen(prettyptr);
1657 		datanameptr = prettyptr + prettylen + 1;
1658 		datanamelen = strlen(datanameptr);
1659 		tripletlen = vidlen + prettylen + datanamelen + 3;
1660 
1661 		if (vidlen == 0) {
1662 			continue;
1663 		}
1664 
1665 		/*
1666 		 * If inquiry vid dosen't match this triplets vid,
1667 		 * try the next.
1668 		 */
1669 		if (strncasecmp(vidpid, vidptr, vidlen)) {
1670 			continue;
1671 		}
1672 
1673 		/*
1674 		 * if prettylen is zero then use the vid string
1675 		 */
1676 		if (prettylen == 0) {
1677 			prettyptr = vidptr;
1678 			prettylen = vidlen;
1679 		}
1680 
1681 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1682 		    "vid = %s, pretty=%s, dataname = %s\n",
1683 		    vidptr, prettyptr, datanameptr);
1684 
1685 		/*
1686 		 * get the data list
1687 		 */
1688 		if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, 0,
1689 		    datanameptr, (caddr_t)&data_list,
1690 		    &data_list_len) != DDI_PROP_SUCCESS) {
1691 			/*
1692 			 * Error in getting property value
1693 			 * print warning!
1694 			 */
1695 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
1696 			    "data property (%s) has no value\n",
1697 			    datanameptr);
1698 			continue;
1699 		}
1700 
1701 		/*
1702 		 * now initialize the st_drivetype struct
1703 		 */
1704 		(void) strncpy(dp->name, prettyptr, ST_NAMESIZE - 1);
1705 		dp->length = (int)min(vidlen, (VIDPIDLEN - 1));
1706 		(void) strncpy(dp->vid, vidptr, dp->length);
1707 		data_ptr = (int *)data_list;
1708 		/*
1709 		 * check if data is enough for version, type,
1710 		 * bsize, options, # of densities, density1,
1711 		 * density2, ..., default_density
1712 		 */
1713 		if ((data_list_len < 5 * sizeof (int)) ||
1714 		    (data_list_len < 6 * sizeof (int) +
1715 		    *(data_ptr + 4) * sizeof (int))) {
1716 			/*
1717 			 * print warning and skip to next triplet.
1718 			 */
1719 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
1720 			    "data property (%s) incomplete\n",
1721 			    datanameptr);
1722 			kmem_free(data_list, data_list_len);
1723 			continue;
1724 		}
1725 
1726 		if (st_validate_conf_data(un, data_ptr,
1727 		    data_list_len / sizeof (int), datanameptr)) {
1728 			kmem_free(data_list, data_list_len);
1729 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
1730 			    "data property (%s) rejected\n",
1731 			    datanameptr);
1732 			continue;
1733 		}
1734 
1735 		/*
1736 		 * check version
1737 		 */
1738 		version = *data_ptr++;
1739 		if (version != 1 && version != 2) {
1740 			/* print warning but accept it */
1741 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
1742 			    "Version # for data property (%s) "
1743 			    "not set to 1 or 2\n", datanameptr);
1744 		}
1745 
1746 		dp->type    = *data_ptr++;
1747 		dp->bsize   = *data_ptr++;
1748 		dp->options = *data_ptr++;
1749 		dp->options |= ST_DYNAMIC;
1750 		len = *data_ptr++;
1751 		for (i = 0; i < NDENSITIES; i++) {
1752 			if (i < len) {
1753 				dp->densities[i] = *data_ptr++;
1754 			}
1755 		}
1756 		dp->default_density = *data_ptr << 3;
1757 		if (version == 2 &&
1758 		    data_list_len >= (13 + len) * sizeof (int)) {
1759 			data_ptr++;
1760 			dp->non_motion_timeout	= *data_ptr++;
1761 			dp->io_timeout		= *data_ptr++;
1762 			dp->rewind_timeout	= *data_ptr++;
1763 			dp->space_timeout	= *data_ptr++;
1764 			dp->load_timeout	= *data_ptr++;
1765 			dp->unload_timeout	= *data_ptr++;
1766 			dp->erase_timeout	= *data_ptr++;
1767 		}
1768 		kmem_free(data_list, data_list_len);
1769 		found = 1;
1770 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1771 		    "found in st.conf: vid = %s, pretty=%s\n",
1772 		    dp->vid, dp->name);
1773 		break;
1774 	}
1775 
1776 	/*
1777 	 * free up the memory allocated by ddi_getlongprop
1778 	 */
1779 	if (config_list) {
1780 		kmem_free(config_list, config_list_len);
1781 	}
1782 	return (found);
1783 }
1784 
1785 static int
1786 st_get_conf_from_st_conf_dot_c(struct scsi_tape *un, char *vidpid,
1787     struct st_drivetype *dp)
1788 {
1789 	int i;
1790 
1791 	/*
1792 	 * Determine type of tape controller.  Type is determined by
1793 	 * checking the result of the earlier inquiry command and
1794 	 * comparing vendor ids with strings in a table declared in st_conf.c.
1795 	 */
1796 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
1797 	    "st_get_conf_from_st_conf_dot_c(): looking at st_drivetypes\n");
1798 
1799 	for (i = 0; i < st_ndrivetypes; i++) {
1800 		if (st_drivetypes[i].length == 0) {
1801 			continue;
1802 		}
1803 		if (strncasecmp(vidpid, st_drivetypes[i].vid,
1804 		    st_drivetypes[i].length)) {
1805 			continue;
1806 		}
1807 		bcopy(&st_drivetypes[i], dp, sizeof (st_drivetypes[i]));
1808 		return (1);
1809 	}
1810 	return (0);
1811 }
1812 
1813 static int
1814 st_get_default_conf(struct scsi_tape *un, char *vidpid, struct st_drivetype *dp)
1815 {
1816 	int i;
1817 
1818 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
1819 	    "st_get_default_conf(): making drivetype from INQ cmd\n");
1820 
1821 
1822 	/*
1823 	 * Make up a name
1824 	 */
1825 	bcopy("Vendor '", dp->name, 8);
1826 	bcopy(vidpid, &dp->name[8], VIDLEN);
1827 	bcopy("' Product '", &dp->name[16], 11);
1828 	bcopy(&vidpid[8], &dp->name[27], PIDLEN);
1829 	dp->name[ST_NAMESIZE - 2] = '\'';
1830 	dp->name[ST_NAMESIZE - 1] = '\0';
1831 	dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1));
1832 	(void) strncpy(dp->vid, ST_INQUIRY->inq_vid, dp->length);
1833 	/*
1834 	 * 'clean' vendor and product strings of non-printing chars
1835 	 */
1836 	for (i = 0; i < ST_NAMESIZE - 2; i++) {
1837 		if (dp->name[i] < ' ' || dp->name[i] > '~') {
1838 			dp->name[i] = '.';
1839 		}
1840 	}
1841 	dp->type = ST_TYPE_INVALID;
1842 	dp->options |= (ST_DYNAMIC | ST_UNLOADABLE | ST_MODE_SEL_COMP);
1843 
1844 	return (1); /* Can Not Fail */
1845 }
1846 
1847 /*
1848  * Regular Unix Entry points
1849  */
1850 
1851 
1852 
1853 /* ARGSUSED */
1854 static int
1855 st_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
1856 {
1857 	dev_t dev = *dev_p;
1858 	int rval = 0;
1859 
1860 	GET_SOFT_STATE(dev);
1861 
1862 	/*
1863 	 * validate that we are addressing a sensible unit
1864 	 */
1865 	mutex_enter(ST_MUTEX);
1866 
1867 #ifdef	STDEBUG
1868 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
1869 	    "st_open(node = %s dev = 0x%lx, flag = %d, otyp = %d)\n",
1870 	    st_dev_name(dev), *dev_p, flag, otyp);
1871 #endif
1872 
1873 	/*
1874 	 * All device accesss go thru st_strategy() where we check
1875 	 * suspend status
1876 	 */
1877 
1878 	if (!un->un_attached) {
1879 		st_known_tape_type(un);
1880 		if (!un->un_attached) {
1881 			rval = ENXIO;
1882 			goto exit;
1883 		}
1884 
1885 	}
1886 
1887 	/*
1888 	 * Check for the case of the tape in the middle of closing.
1889 	 * This isn't simply a check of the current state, because
1890 	 * we could be in state of sensing with the previous state
1891 	 * that of closing.
1892 	 *
1893 	 * And don't allow multiple opens.
1894 	 */
1895 	if (!(flag & (FNDELAY | FNONBLOCK)) && IS_CLOSING(un)) {
1896 		un->un_laststate = un->un_state;
1897 		un->un_state = ST_STATE_CLOSE_PENDING_OPEN;
1898 		while (IS_CLOSING(un) ||
1899 		    un->un_state == ST_STATE_CLOSE_PENDING_OPEN) {
1900 			if (cv_wait_sig(&un->un_clscv, ST_MUTEX) == 0) {
1901 				rval = EINTR;
1902 				un->un_state = un->un_laststate;
1903 				goto exit;
1904 			}
1905 		}
1906 	} else if (un->un_state != ST_STATE_CLOSED) {
1907 		rval = EBUSY;
1908 		goto busy;
1909 	}
1910 
1911 	/*
1912 	 * record current dev
1913 	 */
1914 	un->un_dev = dev;
1915 	un->un_oflags = flag;	/* save for use in st_tape_init() */
1916 	un->un_errno = 0;	/* no errors yet */
1917 	un->un_restore_pos = 0;
1918 	un->un_rqs_state = 0;
1919 
1920 	/*
1921 	 * If we are opening O_NDELAY, or O_NONBLOCK, we don't check for
1922 	 * anything, leave internal states alone, if fileno >= 0
1923 	 */
1924 	if (flag & (FNDELAY | FNONBLOCK)) {
1925 		if (un->un_fileno < 0 || (un->un_fileno == 0 &&
1926 			un->un_blkno == 0)) {
1927 			un->un_state = ST_STATE_OFFLINE;
1928 		} else {
1929 			/*
1930 			 * set un_read_only/write-protect status.
1931 			 *
1932 			 * If the tape is not bot we can assume
1933 			 * that mspl->wp_status is set properly.
1934 			 * else
1935 			 * we need to do a mode sense/Tur once
1936 			 * again to get the actual tape status.(since
1937 			 * user might have replaced the tape)
1938 			 * Hence make the st state OFFLINE so that
1939 			 * we re-intialize the tape once again.
1940 			 */
1941 			if (un->un_fileno > 0 ||
1942 			    (un->un_fileno == 0 && un->un_blkno != 0)) {
1943 				un->un_read_only =
1944 				    (un->un_oflags & FWRITE) ? 0 : 1;
1945 				un->un_state = ST_STATE_OPEN_PENDING_IO;
1946 			} else {
1947 				un->un_state = ST_STATE_OFFLINE;
1948 			}
1949 		}
1950 		rval = 0;
1951 	} else {
1952 		/*
1953 		 * If reserve/release is supported on this drive.
1954 		 * then call st_tape_reservation_init().
1955 		 */
1956 		un->un_state = ST_STATE_OPENING;
1957 
1958 		if (ST_RESERVE_SUPPORTED(un)) {
1959 			rval = st_tape_reservation_init(dev);
1960 			if (rval) {
1961 				goto exit;
1962 			}
1963 		}
1964 		rval = st_tape_init(dev);
1965 		if (rval) {
1966 			/*
1967 			 * Release the tape unit, if no preserve reserve
1968 			 */
1969 			if ((ST_RESERVE_SUPPORTED(un)) &&
1970 			    !(un->un_rsvd_status & ST_PRESERVE_RESERVE)) {
1971 				(void) st_reserve_release(dev, ST_RELEASE);
1972 			}
1973 		} else {
1974 			un->un_state = ST_STATE_OPEN_PENDING_IO;
1975 		}
1976 	}
1977 
1978 exit:
1979 	/*
1980 	 * we don't want any uninvited guests scrogging our data when we're
1981 	 * busy with something, so for successful opens or failed opens
1982 	 * (except for EBUSY), reset these counters and state appropriately.
1983 	 */
1984 	if (rval != EBUSY) {
1985 		if (rval) {
1986 			un->un_state = ST_STATE_CLOSED;
1987 		}
1988 		un->un_err_resid = 0;
1989 		un->un_retry_ct = 0;
1990 		un->un_tran_retry_ct = 0;
1991 	}
1992 busy:
1993 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
1994 	    "st_open: return val = %x, state = %d\n", rval, un->un_state);
1995 	mutex_exit(ST_MUTEX);
1996 	return (rval);
1997 
1998 }
1999 
2000 #define	ST_LOST_RESERVE_BETWEEN_OPENS  \
2001 		(ST_RESERVE | ST_LOST_RESERVE | ST_PRESERVE_RESERVE)
2002 
2003 int
2004 st_tape_reservation_init(dev_t dev)
2005 {
2006 	int rval = 0;
2007 
2008 	GET_SOFT_STATE(dev);
2009 
2010 	ASSERT(mutex_owned(ST_MUTEX));
2011 
2012 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2013 	    "st_tape_reservation_init(dev = 0x%lx)\n", dev);
2014 
2015 	/*
2016 	 * Issue a Throw-Away reserve command to clear the
2017 	 * check condition.
2018 	 * If the current behaviour of reserve/release is to
2019 	 * hold reservation across opens , and if a Bus reset
2020 	 * has been issued between opens then this command
2021 	 * would set the ST_LOST_RESERVE flags in rsvd_status.
2022 	 * In this case return an EACCES so that user knows that
2023 	 * reservation has been lost in between opens.
2024 	 * If this error is not returned and we continue with
2025 	 * successful open , then user may think position of the
2026 	 * tape is still the same but inreality we would rewind the
2027 	 * tape and continue from BOT.
2028 	 */
2029 	rval = st_reserve_release(dev, ST_RESERVE);
2030 
2031 	if (rval) {
2032 		if ((un->un_rsvd_status & ST_LOST_RESERVE_BETWEEN_OPENS) ==
2033 			ST_LOST_RESERVE_BETWEEN_OPENS) {
2034 				un->un_rsvd_status &=
2035 					~(ST_LOST_RESERVE | ST_RESERVE);
2036 				un->un_errno = EACCES;
2037 				return (EACCES);
2038 		}
2039 		rval = st_reserve_release(dev, ST_RESERVE);
2040 	}
2041 	if (rval == 0)
2042 		un->un_rsvd_status |= ST_INIT_RESERVE;
2043 
2044 	return (rval);
2045 }
2046 
2047 static int
2048 st_tape_init(dev_t dev)
2049 {
2050 	int err;
2051 	int rval = 0;
2052 
2053 	GET_SOFT_STATE(dev);
2054 
2055 	ASSERT(mutex_owned(ST_MUTEX));
2056 
2057 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2058 	    "st_tape_init(dev = 0x%lx, oflags = %d)\n", dev, un->un_oflags);
2059 
2060 	/*
2061 	 * Clean up after any errors left by 'last' close.
2062 	 * This also handles the case of the initial open.
2063 	 */
2064 	if (un->un_state != ST_STATE_INITIALIZING) {
2065 		un->un_laststate = un->un_state;
2066 		un->un_state = ST_STATE_OPENING;
2067 	}
2068 
2069 	un->un_kbytes_xferred = 0;
2070 
2071 	/*
2072 	 * do a throw away TUR to clear check condition
2073 	 */
2074 	err = st_cmd(dev, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
2075 
2076 	/*
2077 	 * If test unit ready fails because the drive is reserved
2078 	 * by another host fail the open for no access.
2079 	 */
2080 	if (err) {
2081 		if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) {
2082 			un->un_state = ST_STATE_CLOSED;
2083 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2084 				"st_tape_init: RESERVATION CONFLICT\n");
2085 			rval = EACCES;
2086 			goto exit;
2087 		}
2088 	}
2089 
2090 	/*
2091 	 * See whether this is a generic device that we haven't figured
2092 	 * anything out about yet.
2093 	 */
2094 	if (un->un_dp->type == ST_TYPE_INVALID) {
2095 		if (st_determine_generic(dev)) {
2096 			un->un_state = ST_STATE_CLOSED;
2097 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2098 			    "st_open: EIO invalid type\n");
2099 			rval = EIO;
2100 			goto exit;
2101 		}
2102 		/*
2103 		 * If this is a Unknown Type drive,
2104 		 * Use the READ BLOCK LIMITS to determine if
2105 		 * allow large xfer is approprate if not globally
2106 		 * disabled with st_allow_large_xfer.
2107 		 */
2108 		un->un_allow_large_xfer = (uchar_t)st_allow_large_xfer;
2109 	} else {
2110 
2111 		/*
2112 		 * If we allow_large_xfer (ie >64k) and have not yet found out
2113 		 * the max block size supported by the drive,
2114 		 * find it by issueing a READ_BLKLIM command.
2115 		 * if READ_BLKLIM cmd fails, assume drive doesn't
2116 		 * allow_large_xfer and min/max block sizes as 1 byte and 63k.
2117 		 */
2118 		un->un_allow_large_xfer = st_allow_large_xfer &&
2119 		    (un->un_dp->options & ST_NO_RECSIZE_LIMIT);
2120 	}
2121 	/*
2122 	 * if maxbsize is unknown, set the maximum block size.
2123 	 */
2124 	if (un->un_maxbsize == MAXBSIZE_UNKNOWN) {
2125 
2126 		/*
2127 		 * Get the Block limits of the tape drive.
2128 		 * if un->un_allow_large_xfer = 0 , then make sure
2129 		 * that maxbsize is <= ST_MAXRECSIZE_FIXED.
2130 		 */
2131 		un->un_rbl = kmem_zalloc(RBLSIZE, KM_SLEEP);
2132 
2133 		err = st_cmd(dev, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD);
2134 		if (err) {
2135 			/* Retry */
2136 			err = st_cmd(dev, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD);
2137 		}
2138 		if (!err) {
2139 
2140 			/*
2141 			 * if cmd successful, use limit returned
2142 			 */
2143 			un->un_maxbsize = (un->un_rbl->max_hi << 16) +
2144 					(un->un_rbl->max_mid << 8) +
2145 					un->un_rbl->max_lo;
2146 			un->un_minbsize = (un->un_rbl->min_hi << 8) +
2147 					un->un_rbl->min_lo;
2148 			un->un_data_mod = 1 << un->un_rbl->granularity;
2149 			if ((un->un_maxbsize == 0) ||
2150 			    (un->un_allow_large_xfer == 0 &&
2151 			    un->un_maxbsize > ST_MAXRECSIZE_FIXED)) {
2152 				un->un_maxbsize = ST_MAXRECSIZE_FIXED;
2153 
2154 			} else if (un->un_dp->type == ST_TYPE_DEFAULT) {
2155 				/*
2156 				 * Drive is not one that is configured, But the
2157 				 * READ BLOCK LIMITS tells us it can do large
2158 				 * xfers.
2159 				 */
2160 				if (un->un_maxbsize > ST_MAXRECSIZE_FIXED) {
2161 					un->un_dp->options |=
2162 					    ST_NO_RECSIZE_LIMIT;
2163 				}
2164 				/*
2165 				 * If max and mimimum block limits are the
2166 				 * same this is a fixed block size device.
2167 				 */
2168 				if (un->un_maxbsize == un->un_minbsize) {
2169 					un->un_dp->options &= ~ST_VARIABLE;
2170 				}
2171 			}
2172 
2173 			if (un->un_minbsize == 0) {
2174 				un->un_minbsize = 1;
2175 			}
2176 
2177 		} else { /* error on read block limits */
2178 
2179 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2180 				"!st_tape_init: Error on READ BLOCK LIMITS,"
2181 				" errno = %d un_rsvd_status = 0x%X\n",
2182 				err, un->un_rsvd_status);
2183 
2184 			/*
2185 			 * since read block limits cmd failed,
2186 			 * do not allow large xfers.
2187 			 * use old values in st_minphys
2188 			 */
2189 			if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) {
2190 				rval = EACCES;
2191 			} else {
2192 				un->un_allow_large_xfer = 0;
2193 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2194 					"!Disabling large transfers\n");
2195 
2196 				/*
2197 				 * we guess maxbsize and minbsize
2198 				 */
2199 				if (un->un_bsize) {
2200 					un->un_maxbsize = un->un_minbsize =
2201 						un->un_bsize;
2202 				} else {
2203 					un->un_maxbsize = ST_MAXRECSIZE_FIXED;
2204 					un->un_minbsize = 1;
2205 				}
2206 				/*
2207 				 * Data Mod must be set,
2208 				 * Even if read block limits fails.
2209 				 * Prevents Divide By Zero in st_rw().
2210 				 */
2211 				un->un_data_mod = 1;
2212 			}
2213 		}
2214 		if (un->un_rbl) {
2215 			kmem_free(un->un_rbl, RBLSIZE);
2216 			un->un_rbl = NULL;
2217 		}
2218 
2219 		if (rval) {
2220 			goto exit;
2221 		}
2222 	}
2223 
2224 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
2225 	    "maxdma = %d, maxbsize = %d, minbsize = %d, %s large xfer\n",
2226 	    un->un_maxdma, un->un_maxbsize, un->un_minbsize,
2227 	    (un->un_allow_large_xfer ? "ALLOW": "DON'T ALLOW"));
2228 
2229 	err = st_cmd(dev, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
2230 
2231 	if (err != 0) {
2232 		if (err == EINTR) {
2233 			un->un_laststate = un->un_state;
2234 			un->un_state = ST_STATE_CLOSED;
2235 			rval = EINTR;
2236 			goto exit;
2237 		}
2238 		/*
2239 		 * Make sure the tape is ready
2240 		 */
2241 		un->un_fileno = -1;
2242 		if (un->un_status != KEY_UNIT_ATTENTION) {
2243 			/*
2244 			 * allow open no media.  Subsequent MTIOCSTATE
2245 			 * with media present will complete the open
2246 			 * logic.
2247 			 */
2248 			un->un_laststate = un->un_state;
2249 			if (un->un_oflags & (FNONBLOCK|FNDELAY)) {
2250 				un->un_mediastate = MTIO_EJECTED;
2251 				un->un_state = ST_STATE_OFFLINE;
2252 				rval = 0;
2253 				goto exit;
2254 			} else {
2255 				un->un_state = ST_STATE_CLOSED;
2256 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2257 		    "st_open EIO no media, not opened O_NONBLOCK|O_EXCL\n");
2258 				rval = EIO;
2259 				goto exit;
2260 			}
2261 		}
2262 	}
2263 
2264 	/*
2265 	 * On each open, initialize block size from drivetype struct,
2266 	 * as it could have been changed by MTSRSZ ioctl.
2267 	 * Now, ST_VARIABLE simply means drive is capable of variable
2268 	 * mode. All drives are assumed to support fixed records.
2269 	 * Hence, un_bsize tells what mode the drive is in.
2270 	 *	un_bsize	= 0	- variable record length
2271 	 *			= x	- fixed record length is x
2272 	 */
2273 	un->un_bsize = un->un_dp->bsize;
2274 
2275 	if (un->un_restore_pos) {
2276 		if (st_validate_tapemarks(un, un->un_save_fileno,
2277 		    un->un_save_blkno) != 0) {
2278 			un->un_restore_pos = 0;
2279 			un->un_laststate = un->un_state;
2280 			un->un_state = ST_STATE_CLOSED;
2281 			rval = EIO;
2282 			goto exit;
2283 		}
2284 		un->un_restore_pos = 0;
2285 	}
2286 
2287 	if ((un->un_fileno < 0) && st_loadtape(dev)) {
2288 		un->un_laststate = un->un_state;
2289 		un->un_state = ST_STATE_CLOSED;
2290 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2291 		    "st_open : EIO can't open tape\n");
2292 		rval = EIO;
2293 		goto exit;
2294 	}
2295 
2296 	/*
2297 	 * do a mode sense to pick up state of current write-protect,
2298 	 */
2299 	(void) st_modesense(un);
2300 
2301 	/*
2302 	 * If we are opening the tape for writing, check
2303 	 * to make sure that the tape can be written.
2304 	 */
2305 	if (un->un_oflags & FWRITE) {
2306 		err = 0;
2307 		if (un->un_mspl->wp)  {
2308 			un->un_status = KEY_WRITE_PROTECT;
2309 			un->un_laststate = un->un_state;
2310 			un->un_state = ST_STATE_CLOSED;
2311 			rval = EACCES;
2312 			goto exit;
2313 		} else {
2314 			un->un_read_only = 0;
2315 		}
2316 	} else {
2317 		un->un_read_only = 1;
2318 	}
2319 
2320 	/*
2321 	 * If we're opening the tape write-only, we need to
2322 	 * write 2 filemarks on the HP 1/2 inch drive, to
2323 	 * create a null file.
2324 	 */
2325 	if ((un->un_oflags == FWRITE) && (un->un_dp->options & ST_REEL)) {
2326 		un->un_fmneeded = 2;
2327 	} else if (un->un_oflags == FWRITE) {
2328 		un->un_fmneeded = 1;
2329 	} else {
2330 		un->un_fmneeded = 0;
2331 	}
2332 
2333 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
2334 	    "fmneeded = %x\n", un->un_fmneeded);
2335 
2336 	/*
2337 	 * Make sure the density can be selected correctly.
2338 	 */
2339 	if (st_determine_density(dev, B_WRITE)) {
2340 		un->un_status = KEY_ILLEGAL_REQUEST;
2341 		un->un_laststate = un->un_state;
2342 		un->un_state = ST_STATE_CLOSED;
2343 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2344 		    "st_open: EIO can't determine density\n");
2345 		rval = EIO;
2346 		goto exit;
2347 	}
2348 
2349 	/*
2350 	 * Destroy the knowledge that we have 'determined'
2351 	 * density so that a later read at BOT comes along
2352 	 * does the right density determination.
2353 	 */
2354 
2355 	un->un_density_known = 0;
2356 
2357 
2358 	/*
2359 	 * Okay, the tape is loaded and either at BOT or somewhere past.
2360 	 * Mark the state such that any I/O or tape space operations
2361 	 * will get/set the right density, etc..
2362 	 */
2363 	un->un_laststate = un->un_state;
2364 	un->un_lastop = ST_OP_NIL;
2365 	un->un_mediastate = MTIO_INSERTED;
2366 	cv_broadcast(&un->un_state_cv);
2367 
2368 	/*
2369 	 *  Set test append flag if writing.
2370 	 *  First write must check that tape is positioned correctly.
2371 	 */
2372 	un->un_test_append = (un->un_oflags & FWRITE);
2373 
2374 exit:
2375 	un->un_err_resid = 0;
2376 	un->un_last_resid = 0;
2377 	un->un_last_count = 0;
2378 
2379 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2380 	    "st_tape_init: return val = %x\n", rval);
2381 	return (rval);
2382 
2383 }
2384 
2385 
2386 
2387 /* ARGSUSED */
2388 static int
2389 st_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
2390 {
2391 	int err = 0;
2392 	int norew, count, last_state;
2393 #if defined(__i386) || defined(__amd64)
2394 	struct contig_mem *cp, *cp_temp;
2395 #endif
2396 
2397 	GET_SOFT_STATE(dev);
2398 
2399 	/*
2400 	 * wait till all cmds in the pipeline have been completed
2401 	 */
2402 	mutex_enter(ST_MUTEX);
2403 
2404 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2405 	    "st_close(dev = 0x%lx, flag = %d, otyp = %d)\n", dev, flag, otyp);
2406 
2407 	st_wait_for_io(un);
2408 
2409 	/* turn off persistent errors on close, as we want close to succeed */
2410 	TURN_PE_OFF(un);
2411 
2412 	/*
2413 	 * set state to indicate that we are in process of closing
2414 	 */
2415 	last_state = un->un_laststate = un->un_state;
2416 	un->un_state = ST_STATE_CLOSING;
2417 
2418 	/*
2419 	 * BSD behavior:
2420 	 * a close always causes a silent span to the next file if we've hit
2421 	 * an EOF (but not yet read across it).
2422 	 */
2423 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2424 	    "st_close1: fileno=%x, blkno=%lx, un_eof=%x\n", un->un_fileno,
2425 	    un->un_blkno, un->un_eof);
2426 
2427 
2428 	if (BSD_BEHAVIOR && (un->un_eof == ST_EOF)) {
2429 		if (un->un_fileno >= 0) {
2430 			un->un_fileno++;
2431 			un->un_blkno = 0;
2432 		}
2433 		un->un_eof = ST_NO_EOF;
2434 	}
2435 
2436 	/*
2437 	 * rewinding?
2438 	 */
2439 	norew = (getminor(dev) & MT_NOREWIND);
2440 
2441 	/*
2442 	 * SVR4 behavior for skipping to next file:
2443 	 *
2444 	 * If we have not seen a filemark, space to the next file
2445 	 *
2446 	 * If we have already seen the filemark we are physically in the next
2447 	 * file and we only increment the filenumber
2448 	 */
2449 
2450 	if (norew && SVR4_BEHAVIOR && (flag & FREAD) && (un->un_blkno != 0) &&
2451 	    (un->un_lastop != ST_OP_WRITE)) {
2452 		switch (un->un_eof) {
2453 		case ST_NO_EOF:
2454 			/*
2455 			 * if we were reading and did not read the complete file
2456 			 * skip to the next file, leaving the tape correctly
2457 			 * positioned to read the first record of the next file
2458 			 * Check first for REEL if we are at EOT by trying to
2459 			 * read a block
2460 			 */
2461 			if ((un->un_dp->options & ST_REEL) &&
2462 				(!(un->un_dp->options & ST_READ_IGNORE_EOFS)) &&
2463 			    (un->un_blkno == 0)) {
2464 				if (st_cmd(dev, SCMD_SPACE, Blk(1), SYNC_CMD)) {
2465 					ST_DEBUG2(ST_DEVINFO, st_label,
2466 					    SCSI_DEBUG,
2467 					    "st_close : EIO can't space\n");
2468 					err = EIO;
2469 					break;
2470 				}
2471 				if (un->un_eof >= ST_EOF_PENDING) {
2472 					un->un_eof = ST_EOT_PENDING;
2473 					un->un_fileno += 1;
2474 					un->un_blkno   = 0;
2475 					break;
2476 				}
2477 			}
2478 			if (st_cmd(dev, SCMD_SPACE, Fmk(1), SYNC_CMD)) {
2479 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2480 				    "st_close: EIO can't space #2\n");
2481 				err = EIO;
2482 			} else {
2483 				ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2484 				    "st_close2: fileno=%x,blkno=%lx,"
2485 				    "un_eof=%x\n",
2486 				    un->un_fileno, un->un_blkno, un->un_eof);
2487 				un->un_eof = ST_NO_EOF;
2488 			}
2489 			break;
2490 
2491 		case ST_EOF_PENDING:
2492 		case ST_EOF:
2493 			un->un_fileno += 1;
2494 			un->un_blkno   = 0;
2495 			un->un_eof = ST_NO_EOF;
2496 			break;
2497 
2498 		case ST_EOT:
2499 		case ST_EOT_PENDING:
2500 			/* nothing to do */
2501 			break;
2502 		}
2503 	}
2504 
2505 
2506 	/*
2507 	 * For performance reasons (HP 88780), the driver should
2508 	 * postpone writing the second tape mark until just before a file
2509 	 * positioning ioctl is issued (e.g., rewind).	This means that
2510 	 * the user must not manually rewind the tape because the tape will
2511 	 * be missing the second tape mark which marks EOM.
2512 	 * However, this small performance improvement is not worth the risk.
2513 	 */
2514 
2515 	/*
2516 	 * We need to back up over the filemark we inadvertently popped
2517 	 * over doing a read in between the two filemarks that constitute
2518 	 * logical eot for 1/2" tapes. Note that ST_EOT_PENDING is only
2519 	 * set while reading.
2520 	 *
2521 	 * If we happen to be at physical eot (ST_EOM) (writing case),
2522 	 * the writing of filemark(s) will clear the ST_EOM state, which
2523 	 * we don't want, so we save this state and restore it later.
2524 	 */
2525 
2526 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2527 	    "flag=%x, fmneeded=%x, lastop=%x, eof=%x\n",
2528 		flag, un->un_fmneeded, un->un_lastop, un->un_eof);
2529 
2530 	if (un->un_eof == ST_EOT_PENDING) {
2531 		if (norew) {
2532 			if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)) {
2533 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2534 				    "st_close: EIO can't space #3\n");
2535 				err = EIO;
2536 			} else {
2537 				un->un_blkno = 0;
2538 				un->un_eof = ST_EOT;
2539 			}
2540 		} else {
2541 			un->un_eof = ST_NO_EOF;
2542 		}
2543 
2544 	/*
2545 	 * Do we need to write a file mark?
2546 	 *
2547 	 * only write filemarks if there are fmks to be written and
2548 	 *   - open for write (possibly read/write)
2549 	 *   - the last operation was a write
2550 	 * or:
2551 	 *   -	opened for wronly
2552 	 *   -	no data was written
2553 	 */
2554 	} else if ((un->un_fileno >= 0) && (un->un_fmneeded > 0) &&
2555 	    (((flag & FWRITE) && (un->un_lastop == ST_OP_WRITE)) ||
2556 	    ((flag & FWRITE) && (un->un_lastop == ST_OP_WEOF)) ||
2557 	    ((flag == FWRITE) && (un->un_lastop == ST_OP_NIL)))) {
2558 
2559 		/* save ST_EOM state */
2560 		int was_at_eom = (un->un_eof == ST_EOM) ? 1 : 0;
2561 
2562 		/*
2563 		 * Note that we will write a filemark if we had opened
2564 		 * the tape write only and no data was written, thus
2565 		 * creating a null file.
2566 		 *
2567 		 * If the user already wrote one, we only have to write 1 more.
2568 		 * If they wrote two, we don't have to write any.
2569 		 */
2570 
2571 		count = un->un_fmneeded;
2572 		if (count > 0) {
2573 			if (st_cmd(dev, SCMD_WRITE_FILE_MARK,
2574 			    count, SYNC_CMD)) {
2575 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2576 				    "st_close : EIO can't wfm\n");
2577 				err = EIO;
2578 			}
2579 			if ((un->un_dp->options & ST_REEL) && norew) {
2580 				if (st_cmd(dev, SCMD_SPACE, Fmk((-1)),
2581 				    SYNC_CMD)) {
2582 					ST_DEBUG2(ST_DEVINFO, st_label,
2583 					    SCSI_DEBUG,
2584 					    "st_close : EIO space fmk(-1)\n");
2585 					err = EIO;
2586 				}
2587 				un->un_eof = ST_NO_EOF;
2588 				/* fix up block number */
2589 				un->un_blkno = 0;
2590 			}
2591 		}
2592 
2593 		/*
2594 		 * If we aren't going to be rewinding, and we were at
2595 		 * physical eot, restore the state that indicates we
2596 		 * are at physical eot. Once you have reached physical
2597 		 * eot, and you close the tape, the only thing you can
2598 		 * do on the next open is to rewind. Access to trailer
2599 		 * records is only allowed without closing the device.
2600 		 */
2601 		if (norew == 0 && was_at_eom)
2602 			un->un_eof = ST_EOM;
2603 	}
2604 
2605 	/*
2606 	 * report soft errors if enabled and available, if we never accessed
2607 	 * the drive, don't get errors. This will prevent some DAT error
2608 	 * messages upon LOG SENSE.
2609 	 */
2610 	if (st_report_soft_errors_on_close &&
2611 	    (un->un_dp->options & ST_SOFT_ERROR_REPORTING) &&
2612 	    (last_state != ST_STATE_OFFLINE)) {
2613 		/*
2614 		 * Make sure we have reserve the tape unit.
2615 		 * This is the case when we do a O_NDELAY open and
2616 		 * then do a close without any I/O.
2617 		 */
2618 		if (!(un->un_rsvd_status & ST_INIT_RESERVE) &&
2619 			ST_RESERVE_SUPPORTED(un)) {
2620 			if ((err = st_tape_reservation_init(dev))) {
2621 				goto error;
2622 			}
2623 		}
2624 		(void) st_report_soft_errors(dev, flag);
2625 	}
2626 
2627 
2628 	/*
2629 	 * Do we need to rewind? Can we rewind?
2630 	 */
2631 	if (norew == 0 && un->un_fileno >= 0 && err == 0) {
2632 		/*
2633 		 * We'd like to rewind with the
2634 		 * 'immediate' bit set, but this
2635 		 * causes problems on some drives
2636 		 * where subsequent opens get a
2637 		 * 'NOT READY' error condition
2638 		 * back while the tape is rewinding,
2639 		 * which is impossible to distinguish
2640 		 * from the condition of 'no tape loaded'.
2641 		 *
2642 		 * Also, for some targets, if you disconnect
2643 		 * with the 'immediate' bit set, you don't
2644 		 * actually return right away, i.e., the
2645 		 * target ignores your request for immediate
2646 		 * return.
2647 		 *
2648 		 * Instead, we'll fire off an async rewind
2649 		 * command. We'll mark the device as closed,
2650 		 * and any subsequent open will stall on
2651 		 * the first TEST_UNIT_READY until the rewind
2652 		 * completes.
2653 		 *
2654 		 */
2655 		if (!(un->un_rsvd_status & ST_INIT_RESERVE) &&
2656 			ST_RESERVE_SUPPORTED(un)) {
2657 			if ((err = st_tape_reservation_init(dev))) {
2658 				goto error;
2659 			}
2660 		}
2661 		if (ST_RESERVE_SUPPORTED(un)) {
2662 			(void) st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD);
2663 		} else {
2664 			(void) st_cmd(dev, SCMD_REWIND, 0, ASYNC_CMD);
2665 		}
2666 	}
2667 
2668 	/*
2669 	 * eject tape if necessary
2670 	 */
2671 	if (un->un_eject_tape_on_failure) {
2672 		un->un_eject_tape_on_failure = 0;
2673 		if (st_cmd(dev, SCMD_LOAD, 0, SYNC_CMD)) {
2674 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2675 			    "st_close : can't unload tape\n");
2676 		} else {
2677 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2678 			    "st_close : tape unloaded \n");
2679 			un->un_eof = ST_NO_EOF;
2680 			un->un_mediastate = MTIO_EJECTED;
2681 		}
2682 	}
2683 	/*
2684 	 * Release the tape unit, if default reserve/release
2685 	 * behaviour.
2686 	 */
2687 	if (ST_RESERVE_SUPPORTED(un) &&
2688 		!(un->un_rsvd_status & ST_PRESERVE_RESERVE) &&
2689 		    (un->un_rsvd_status & ST_INIT_RESERVE)) {
2690 		(void) st_reserve_release(dev, ST_RELEASE);
2691 	}
2692 
2693 error:
2694 	/*
2695 	 * clear up state
2696 	 */
2697 	un->un_laststate = un->un_state;
2698 	un->un_state = ST_STATE_CLOSED;
2699 	un->un_lastop = ST_OP_NIL;
2700 	un->un_throttle = 1;	/* assume one request at time, for now */
2701 	un->un_retry_ct = 0;
2702 	un->un_tran_retry_ct = 0;
2703 	un->un_errno = 0;
2704 	un->un_swr_token = (opaque_t)NULL;
2705 	un->un_rsvd_status &= ~(ST_INIT_RESERVE);
2706 
2707 	/* Restore the options to the init time settings */
2708 	if (un->un_init_options & ST_READ_IGNORE_ILI) {
2709 		un->un_dp->options |= ST_READ_IGNORE_ILI;
2710 	} else {
2711 		un->un_dp->options &= ~ST_READ_IGNORE_ILI;
2712 	}
2713 
2714 	if (un->un_init_options & ST_READ_IGNORE_EOFS) {
2715 		un->un_dp->options |= ST_READ_IGNORE_EOFS;
2716 	} else {
2717 		un->un_dp->options &= ~ST_READ_IGNORE_EOFS;
2718 	}
2719 
2720 	if (un->un_init_options & ST_SHORT_FILEMARKS) {
2721 		un->un_dp->options |= ST_SHORT_FILEMARKS;
2722 	} else {
2723 		un->un_dp->options &= ~ST_SHORT_FILEMARKS;
2724 	}
2725 
2726 	ASSERT(mutex_owned(ST_MUTEX));
2727 
2728 	/*
2729 	 * Signal anyone awaiting a close operation to complete.
2730 	 */
2731 	cv_signal(&un->un_clscv);
2732 
2733 	/*
2734 	 * any kind of error on closing causes all state to be tossed
2735 	 */
2736 	if (err && un->un_status != KEY_ILLEGAL_REQUEST) {
2737 		un->un_density_known = 0;
2738 		/*
2739 		 * note that st_intr has already set un_fileno to -1
2740 		 */
2741 	}
2742 
2743 #if defined(__i386) || defined(__amd64)
2744 	/*
2745 	 * free any contiguous mem alloc'ed for big block I/O
2746 	 */
2747 	cp = un->un_contig_mem;
2748 	while (cp) {
2749 		if (cp->cm_addr) {
2750 			ddi_dma_mem_free(&cp->cm_acc_hdl);
2751 		}
2752 		if (cp->cm_bp) {
2753 			freerbuf(cp->cm_bp);
2754 		}
2755 		cp_temp = cp;
2756 		cp = cp->cm_next;
2757 		kmem_free(cp_temp, sizeof (struct contig_mem));
2758 	}
2759 	un->un_contig_mem_total_num = 0;
2760 	un->un_contig_mem_available_num = 0;
2761 	un->un_contig_mem = NULL;
2762 #endif
2763 
2764 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2765 	    "st_close3: return val = %x, fileno=%x, blkno=%lx, un_eof=%x\n",
2766 			    err, un->un_fileno, un->un_blkno, un->un_eof);
2767 
2768 	mutex_exit(ST_MUTEX);
2769 	return (err);
2770 }
2771 
2772 /*
2773  * These routines perform raw i/o operations.
2774  */
2775 
2776 /* ARGSUSED2 */
2777 static int
2778 st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p)
2779 {
2780 	return (st_arw(dev, aio, B_READ));
2781 }
2782 
2783 
2784 /* ARGSUSED2 */
2785 static int
2786 st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p)
2787 {
2788 	return (st_arw(dev, aio, B_WRITE));
2789 }
2790 
2791 
2792 
2793 /* ARGSUSED */
2794 static int
2795 st_read(dev_t dev, struct uio *uiop, cred_t *cred_p)
2796 {
2797 	return (st_rw(dev, uiop, B_READ));
2798 }
2799 
2800 /* ARGSUSED */
2801 static int
2802 st_write(dev_t dev, struct uio *uiop, cred_t *cred_p)
2803 {
2804 	return (st_rw(dev, uiop, B_WRITE));
2805 }
2806 
2807 /*
2808  * Due to historical reasons, old limits are: For variable-length devices:
2809  * if greater than 64KB - 1 (ST_MAXRECSIZE_VARIABLE), block into 64 KB - 2
2810  * ST_MAXRECSIZE_VARIABLE_LIMIT) requests; otherwise,
2811  * (let it through unmodified. For fixed-length record devices:
2812  * 63K (ST_MAXRECSIZE_FIXED) is max (default minphys).
2813  *
2814  * The new limits used are un_maxdma (retrieved using scsi_ifgetcap()
2815  * from the HBA) and un_maxbsize (retrieved by sending SCMD_READ_BLKLIM
2816  * command to the drive).
2817  *
2818  */
2819 static void
2820 st_minphys(struct buf *bp)
2821 {
2822 	struct scsi_tape *un;
2823 
2824 #if !defined(lint)
2825 	_NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_tape::un_sd));
2826 #endif
2827 
2828 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
2829 
2830 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2831 	    "st_minphys(bp = 0x%p): b_bcount = 0x%lx\n", (void *)bp,
2832 	    bp->b_bcount);
2833 
2834 	if (un->un_allow_large_xfer) {
2835 
2836 		/*
2837 		 * check un_maxbsize for variable length devices only
2838 		 */
2839 		if (un->un_bsize == 0 && bp->b_bcount > un->un_maxbsize) {
2840 			bp->b_bcount = un->un_maxbsize;
2841 		}
2842 		/*
2843 		 * can't go more that HBA maxdma limit in either fixed-length
2844 		 * or variable-length tape drives.
2845 		 */
2846 		if (bp->b_bcount > un->un_maxdma) {
2847 			bp->b_bcount = un->un_maxdma;
2848 		}
2849 	} else {
2850 
2851 		/*
2852 		 *  use old fixed limits
2853 		 */
2854 		if (un->un_bsize == 0) {
2855 			if (bp->b_bcount > ST_MAXRECSIZE_VARIABLE) {
2856 				bp->b_bcount = ST_MAXRECSIZE_VARIABLE_LIMIT;
2857 			}
2858 		} else {
2859 			if (bp->b_bcount > ST_MAXRECSIZE_FIXED) {
2860 				bp->b_bcount = ST_MAXRECSIZE_FIXED;
2861 			}
2862 		}
2863 	}
2864 
2865 #if !defined(lint)
2866 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsi_tape::un_sbufp));
2867 #endif /* lint */
2868 	/*
2869 	 * For regular raw I/O and Fixed Block length devices, make sure
2870 	 * the adjusted block count is a whole multiple of the device
2871 	 * block size.
2872 	 */
2873 	if (bp != un->un_sbufp && un->un_bsize) {
2874 		bp->b_bcount -= (bp->b_bcount % un->un_bsize);
2875 	}
2876 }
2877 
2878 /*ARGSUSED*/
2879 static void
2880 st_uscsi_minphys(struct buf *bp)
2881 {
2882 	/*
2883 	 * do not break up because the CDB count would then be
2884 	 * incorrect and create spurious data underrun errors.
2885 	 */
2886 }
2887 
2888 static int
2889 st_rw(dev_t dev, struct uio *uio, int flag)
2890 {
2891 	int rval = 0;
2892 	long len;
2893 
2894 	GET_SOFT_STATE(dev);
2895 
2896 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2897 	    "st_rw(dev = 0x%lx, flag = %s)\n", dev,
2898 	    (flag == B_READ ? rd_str: wr_str));
2899 
2900 	/* get local copy of transfer length */
2901 	len = uio->uio_iov->iov_len;
2902 
2903 	mutex_enter(ST_MUTEX);
2904 
2905 	/*
2906 	 * If in fixed block size mode and requested read or write
2907 	 * is not an even multiple of that block size.
2908 	 */
2909 	if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) {
2910 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
2911 		    "%s: not modulo %d block size\n",
2912 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize);
2913 		rval = EINVAL;
2914 	}
2915 
2916 	/* If device has set granularity in the READ_BLKLIM we honor it. */
2917 	if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) {
2918 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
2919 		    "%s: not modulo %d device granularity\n",
2920 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod);
2921 		rval = EINVAL;
2922 	}
2923 
2924 	if (rval != 0) {
2925 		un->un_errno = rval;
2926 		mutex_exit(ST_MUTEX);
2927 		return (rval);
2928 	}
2929 
2930 	un->un_silent_skip = 0;
2931 	mutex_exit(ST_MUTEX);
2932 
2933 	len = uio->uio_resid;
2934 
2935 	rval = physio(st_strategy, (struct buf *)NULL,
2936 		dev, flag, st_minphys, uio);
2937 	/*
2938 	 * if we have hit logical EOT during this xfer and there is not a
2939 	 * full residue, then set un_eof back  to ST_EOM to make sure that
2940 	 * the user will see at least one zero write
2941 	 * after this short write
2942 	 */
2943 	mutex_enter(ST_MUTEX);
2944 	if (un->un_eof > ST_NO_EOF) {
2945 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2946 		"un_eof=%d resid=%lx\n", un->un_eof, uio->uio_resid);
2947 	}
2948 	if (un->un_eof >= ST_EOM && (flag == B_WRITE)) {
2949 		if ((uio->uio_resid != len) && (uio->uio_resid != 0)) {
2950 			un->un_eof = ST_EOM;
2951 		} else if (uio->uio_resid == len) {
2952 			un->un_eof = ST_NO_EOF;
2953 		}
2954 	}
2955 
2956 	if (un->un_silent_skip && uio->uio_resid != len) {
2957 		un->un_eof = ST_EOF;
2958 		un->un_blkno = un->un_save_blkno;
2959 		un->un_fileno--;
2960 	}
2961 
2962 	un->un_errno = rval;
2963 
2964 	mutex_exit(ST_MUTEX);
2965 
2966 	return (rval);
2967 }
2968 
2969 static int
2970 st_arw(dev_t dev, struct aio_req *aio, int flag)
2971 {
2972 	struct uio *uio = aio->aio_uio;
2973 	int rval = 0;
2974 	long len;
2975 
2976 	GET_SOFT_STATE(dev);
2977 
2978 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2979 	    "st_rw(dev = 0x%lx, flag = %s)\n", dev,
2980 	    (flag == B_READ ? rd_str: wr_str));
2981 
2982 	/* get local copy of transfer length */
2983 	len = uio->uio_iov->iov_len;
2984 
2985 	mutex_enter(ST_MUTEX);
2986 
2987 	/*
2988 	 * If in fixed block size mode and requested read or write
2989 	 * is not an even multiple of that block size.
2990 	 */
2991 	if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) {
2992 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
2993 		    "%s: not modulo %d block size\n",
2994 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize);
2995 		rval = EINVAL;
2996 	}
2997 
2998 	/* If device has set granularity in the READ_BLKLIM we honor it. */
2999 	if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) {
3000 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
3001 		    "%s: not modulo %d device granularity\n",
3002 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod);
3003 		rval = EINVAL;
3004 	}
3005 
3006 	if (rval != 0) {
3007 		un->un_errno = rval;
3008 		mutex_exit(ST_MUTEX);
3009 		return (rval);
3010 	}
3011 
3012 	mutex_exit(ST_MUTEX);
3013 
3014 	len = uio->uio_resid;
3015 
3016 	rval = aphysio(st_strategy, anocancel, dev, flag, st_minphys, aio);
3017 
3018 	/*
3019 	 * if we have hit logical EOT during this xfer and there is not a
3020 	 * full residue, then set un_eof back  to ST_EOM to make sure that
3021 	 * the user will see at least one zero write
3022 	 * after this short write
3023 	 *
3024 	 * we keep this here just in case the application is not using
3025 	 * persistent errors
3026 	 */
3027 	mutex_enter(ST_MUTEX);
3028 	if (un->un_eof > ST_NO_EOF) {
3029 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3030 		    "un_eof=%d resid=%lx\n", un->un_eof, uio->uio_resid);
3031 	}
3032 	if (un->un_eof >= ST_EOM && (flag == B_WRITE)) {
3033 		if ((uio->uio_resid != len) && (uio->uio_resid != 0)) {
3034 			un->un_eof = ST_EOM;
3035 		} else if (uio->uio_resid == len && !IS_PE_FLAG_SET(un)) {
3036 			un->un_eof = ST_NO_EOF;
3037 		}
3038 	}
3039 	un->un_errno = rval;
3040 	mutex_exit(ST_MUTEX);
3041 
3042 	return (rval);
3043 }
3044 
3045 
3046 
3047 static int
3048 st_strategy(struct buf *bp)
3049 {
3050 	struct scsi_tape *un;
3051 	dev_t dev = bp->b_edev;
3052 
3053 	/*
3054 	 * validate arguments
3055 	 */
3056 	if ((un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev))) == NULL) {
3057 		bp->b_resid = bp->b_bcount;
3058 		mutex_enter(ST_MUTEX);
3059 		st_bioerror(bp, ENXIO);
3060 		mutex_exit(ST_MUTEX);
3061 		goto error;
3062 	}
3063 
3064 	mutex_enter(ST_MUTEX);
3065 
3066 	while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
3067 		cv_wait(&un->un_suspend_cv, ST_MUTEX);
3068 	}
3069 
3070 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3071 	    "st_strategy(): bcount=0x%lx, fileno=%d, blkno=%lx, eof=%d\n",
3072 	    bp->b_bcount, un->un_fileno, un->un_blkno, un->un_eof);
3073 
3074 	/*
3075 	 * If persistent errors have been flagged, just nix this one. We wait
3076 	 * for any outstanding I/O's below, so we will be in order.
3077 	 */
3078 	if (IS_PE_FLAG_SET(un))
3079 		goto exit;
3080 
3081 	if (bp != un->un_sbufp) {
3082 		char reading = bp->b_flags & B_READ;
3083 		int wasopening = 0;
3084 
3085 		/*
3086 		 * If we haven't done/checked reservation on the tape unit
3087 		 * do it now.
3088 		 */
3089 		if (!(un->un_rsvd_status & ST_INIT_RESERVE)) {
3090 		    if (ST_RESERVE_SUPPORTED(un)) {
3091 				if (st_tape_reservation_init(dev)) {
3092 					st_bioerror(bp, un->un_errno);
3093 					goto exit;
3094 				}
3095 		    } else if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
3096 				/*
3097 				 * Enter here to restore position for possible
3098 				 * resets when the device was closed and opened
3099 				 * in O_NDELAY mode subsequently
3100 				 */
3101 				un->un_state = ST_STATE_INITIALIZING;
3102 				(void) st_cmd(dev, SCMD_TEST_UNIT_READY,
3103 				    0, SYNC_CMD);
3104 				un->un_state = ST_STATE_OPEN_PENDING_IO;
3105 			}
3106 		    un->un_rsvd_status |= ST_INIT_RESERVE;
3107 		}
3108 
3109 		/*
3110 		 * If we are offline, we have to initialize everything first.
3111 		 * This is to handle either when opened with O_NDELAY, or
3112 		 * we just got a new tape in the drive, after an offline.
3113 		 * We don't observe O_NDELAY past the open,
3114 		 * as it will not make sense for tapes.
3115 		 */
3116 		if (un->un_state == ST_STATE_OFFLINE || un->un_restore_pos) {
3117 			/* reset state to avoid recursion */
3118 			un->un_state = ST_STATE_INITIALIZING;
3119 			if (st_tape_init(dev)) {
3120 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3121 					"stioctl : OFFLINE init failure ");
3122 				un->un_state = ST_STATE_OFFLINE;
3123 				un->un_fileno = -1;
3124 				goto b_done_err;
3125 			}
3126 			un->un_state = ST_STATE_OPEN_PENDING_IO;
3127 		}
3128 		/*
3129 		 * Check for legal operations
3130 		 */
3131 		if (un->un_fileno < 0) {
3132 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3133 			    "strategy with un->un_fileno < 0\n");
3134 			goto b_done_err;
3135 		}
3136 
3137 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3138 		    "st_strategy(): regular io\n");
3139 
3140 		/*
3141 		 * Process this first. If we were reading, and we're pending
3142 		 * logical eot, that means we've bumped one file mark too far.
3143 		 */
3144 
3145 		/*
3146 		 * Recursion warning: st_cmd will route back through here.
3147 		 */
3148 		if (un->un_eof == ST_EOT_PENDING) {
3149 			if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)) {
3150 				un->un_fileno = -1;
3151 				un->un_density_known = 0;
3152 				goto b_done_err;
3153 			}
3154 			un->un_blkno = 0; /* fix up block number.. */
3155 			un->un_eof = ST_EOT;
3156 		}
3157 
3158 		/*
3159 		 * If we are in the process of opening, we may have to
3160 		 * determine/set the correct density. We also may have
3161 		 * to do a test_append (if QIC) to see whether we are
3162 		 * in a position to append to the end of the tape.
3163 		 *
3164 		 * If we're already at logical eot, we transition
3165 		 * to ST_NO_EOF. If we're at physical eot, we punt
3166 		 * to the switch statement below to handle.
3167 		 */
3168 		if ((un->un_state == ST_STATE_OPEN_PENDING_IO) ||
3169 		    (un->un_test_append && (un->un_dp->options & ST_QIC))) {
3170 
3171 			if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
3172 				if (st_determine_density(dev, (int)reading)) {
3173 					goto b_done_err;
3174 				}
3175 			}
3176 
3177 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3178 			    "pending_io@fileno %d rw %d qic %d eof %d\n",
3179 			    un->un_fileno, (int)reading,
3180 			    (un->un_dp->options & ST_QIC) ? 1 : 0,
3181 			    un->un_eof);
3182 
3183 			if (!reading && un->un_eof != ST_EOM) {
3184 				if (un->un_eof == ST_EOT) {
3185 					un->un_eof = ST_NO_EOF;
3186 				} else if (un->un_fileno > 0 &&
3187 				    (un->un_dp->options & ST_QIC)) {
3188 					/*
3189 					 * st_test_append() will do it all
3190 					 */
3191 					st_test_append(bp);
3192 					goto done;
3193 				}
3194 			}
3195 			if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
3196 				wasopening = 1;
3197 			}
3198 			un->un_laststate = un->un_state;
3199 			un->un_state = ST_STATE_OPEN;
3200 		}
3201 
3202 
3203 		/*
3204 		 * Process rest of END OF FILE and END OF TAPE conditions
3205 		 */
3206 
3207 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3208 		    "un_eof=%x, wasopening=%x\n",
3209 		    un->un_eof, wasopening);
3210 
3211 		switch (un->un_eof) {
3212 		case ST_EOM:
3213 			/*
3214 			 * This allows writes to proceed past physical
3215 			 * eot. We'll *really* be in trouble if the
3216 			 * user continues blindly writing data too
3217 			 * much past this point (unwind the tape).
3218 			 * Physical eot really means 'early warning
3219 			 * eot' in this context.
3220 			 *
3221 			 * Every other write from now on will succeed
3222 			 * (if sufficient  tape left).
3223 			 * This write will return with resid == count
3224 			 * but the next one should be successful
3225 			 *
3226 			 * Note that we only transition to logical EOT
3227 			 * if the last state wasn't the OPENING state.
3228 			 * We explicitly prohibit running up to physical
3229 			 * eot, closing the device, and then re-opening
3230 			 * to proceed. Trailer records may only be gotten
3231 			 * at by keeping the tape open after hitting eot.
3232 			 *
3233 			 * Also note that ST_EOM cannot be set by reading-
3234 			 * this can only be set during writing. Reading
3235 			 * up to the end of the tape gets a blank check
3236 			 * or a double-filemark indication (ST_EOT_PENDING),
3237 			 * and we prohibit reading after that point.
3238 			 *
3239 			 */
3240 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOM\n");
3241 			if (wasopening == 0) {
3242 				/*
3243 				 * this allows st_rw() to reset it back to
3244 				 * ST_EOM to make sure that the application
3245 				 * will see a zero write
3246 				 */
3247 				un->un_eof = ST_WRITE_AFTER_EOM;
3248 			}
3249 			un->un_status = SUN_KEY_EOT;
3250 			goto b_done;
3251 
3252 		case ST_WRITE_AFTER_EOM:
3253 		case ST_EOT:
3254 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOT\n");
3255 			un->un_status = SUN_KEY_EOT;
3256 			if (SVR4_BEHAVIOR && reading) {
3257 				goto b_done_err;
3258 			}
3259 
3260 			if (reading) {
3261 				goto b_done;
3262 			}
3263 			un->un_eof = ST_NO_EOF;
3264 			break;
3265 
3266 		case ST_EOF_PENDING:
3267 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3268 			    "EOF PENDING\n");
3269 			un->un_status = SUN_KEY_EOF;
3270 			if (SVR4_BEHAVIOR) {
3271 				un->un_eof = ST_EOF;
3272 				goto b_done;
3273 			}
3274 			/* FALLTHROUGH */
3275 		case ST_EOF:
3276 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOF\n");
3277 			un->un_status = SUN_KEY_EOF;
3278 			if (SVR4_BEHAVIOR) {
3279 				goto b_done_err;
3280 			}
3281 
3282 			if (BSD_BEHAVIOR) {
3283 				un->un_eof = ST_NO_EOF;
3284 				un->un_fileno += 1;
3285 				un->un_blkno   = 0;
3286 			}
3287 
3288 			if (reading) {
3289 				ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3290 				    "now file %d (read)\n",
3291 				    un->un_fileno);
3292 				goto b_done;
3293 			}
3294 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3295 			    "now file %d (write)\n", un->un_fileno);
3296 			break;
3297 		default:
3298 			un->un_status = 0;
3299 			break;
3300 		}
3301 	}
3302 
3303 	bp->b_flags &= ~(B_DONE);
3304 	st_bioerror(bp, 0);
3305 	bp->av_forw = NULL;
3306 	bp->b_resid = 0;
3307 	SET_BP_PKT(bp, 0);
3308 
3309 
3310 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3311 	    "st_strategy: cmd=0x%p  count=%ld  resid=%ld flags=0x%x"
3312 	    " pkt=0x%p\n",
3313 	    (void *)bp->b_forw, bp->b_bcount,
3314 	    bp->b_resid, bp->b_flags, (void *)BP_PKT(bp));
3315 
3316 #if defined(__i386) || defined(__amd64)
3317 	/*
3318 	 * We will replace bp with a new bp that can do big blk xfer
3319 	 * if the requested xfer size is bigger than ST_BIGBLK_XFER
3320 	 *
3321 	 * Also, we need to make sure that we're handling real I/O
3322 	 * by checking group 0/1 SCSI I/O commands, if needed
3323 	 */
3324 	if (bp->b_bcount > ST_BIGBLK_XFER &&
3325 	    (bp != un->un_sbufp					||
3326 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_READ		||
3327 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_READ_G1	||
3328 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE	||
3329 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE_G1)) {
3330 		mutex_exit(ST_MUTEX);
3331 		bp = st_get_bigblk_bp(bp);
3332 		mutex_enter(ST_MUTEX);
3333 	}
3334 #endif
3335 
3336 	/* put on wait queue */
3337 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3338 	    "st_strategy: un->un_quef = 0x%p, bp = 0x%p\n",
3339 	    (void *)un->un_quef, (void *)bp);
3340 
3341 	if (un->un_quef) {
3342 		un->un_quel->b_actf = bp;
3343 	} else {
3344 		un->un_quef = bp;
3345 	}
3346 	un->un_quel = bp;
3347 
3348 	ST_DO_KSTATS(bp, kstat_waitq_enter);
3349 
3350 	st_start(un);
3351 
3352 done:
3353 	mutex_exit(ST_MUTEX);
3354 	return (0);
3355 
3356 
3357 error:
3358 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3359 	    "st_strategy: error exit\n");
3360 
3361 	biodone(bp);
3362 	return (0);
3363 
3364 b_done_err:
3365 	st_bioerror(bp, EIO);
3366 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3367 	    "st_strategy : EIO b_done_err\n");
3368 
3369 b_done:
3370 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3371 	    "st_strategy: b_done\n");
3372 
3373 exit:
3374 	/*
3375 	 * make sure no commands are outstanding or waiting before closing,
3376 	 * so we can guarantee order
3377 	 */
3378 	st_wait_for_io(un);
3379 	un->un_err_resid = bp->b_resid = bp->b_bcount;
3380 
3381 	/* override errno here, if persistent errors were flagged */
3382 	if (IS_PE_FLAG_SET(un))
3383 		bioerror(bp, un->un_errno);
3384 
3385 	mutex_exit(ST_MUTEX);
3386 
3387 	biodone(bp);
3388 	ASSERT(mutex_owned(ST_MUTEX) == 0);
3389 	return (0);
3390 }
3391 
3392 
3393 
3394 /*
3395  * this routine spaces forward over filemarks
3396  */
3397 static int
3398 st_space_fmks(dev_t dev, int count)
3399 {
3400 	int rval = 0;
3401 
3402 	GET_SOFT_STATE(dev);
3403 
3404 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3405 	    "st_space_fmks(dev = 0x%lx, count = %d)\n", dev, count);
3406 
3407 	ASSERT(mutex_owned(ST_MUTEX));
3408 
3409 	/*
3410 	 * the risk with doing only one space operation is that we
3411 	 * may accidentily jump in old data
3412 	 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
3413 	 * because the 8200 does not append a marker; in order not to
3414 	 * sacrifice the fast file skip, we do a slow skip if the low
3415 	 * density device has been opened
3416 	 */
3417 
3418 	if ((un->un_dp->options & ST_KNOWS_EOD) &&
3419 	    !((un->un_dp->type == ST_TYPE_EXB8500 && MT_DENSITY(dev) == 0))) {
3420 		if (st_cmd(dev, SCMD_SPACE, Fmk(count), SYNC_CMD)) {
3421 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3422 			    "space_fmks : EIO can't do space cmd #1\n");
3423 			rval = EIO;
3424 		}
3425 	} else {
3426 		while (count > 0) {
3427 			if (st_cmd(dev, SCMD_SPACE, Fmk(1), SYNC_CMD)) {
3428 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3429 				    "space_fmks : EIO can't do space cmd #2\n");
3430 				rval = EIO;
3431 				break;
3432 			}
3433 			count -= 1;
3434 			/*
3435 			 * read a block to see if we have reached
3436 			 * end of medium (double filemark for reel or
3437 			 * medium error for others)
3438 			 */
3439 			if (count > 0) {
3440 				if (st_cmd(dev, SCMD_SPACE, Blk(1),
3441 				    SYNC_CMD)) {
3442 					ST_DEBUG2(ST_DEVINFO, st_label,
3443 					    SCSI_DEBUG,
3444 					    "space_fmks : EIO can't do "
3445 					    "space cmd #3\n");
3446 					rval = EIO;
3447 					break;
3448 				}
3449 				if ((un->un_eof >= ST_EOF_PENDING) &&
3450 				    (un->un_dp->options & ST_REEL)) {
3451 					un->un_status = SUN_KEY_EOT;
3452 					ST_DEBUG2(ST_DEVINFO, st_label,
3453 					    SCSI_DEBUG,
3454 					    "space_fmks : EIO ST_REEL\n");
3455 					rval = EIO;
3456 					break;
3457 				} else if (IN_EOF(un)) {
3458 					un->un_eof = ST_NO_EOF;
3459 					un->un_fileno++;
3460 					un->un_blkno = 0;
3461 					count--;
3462 				} else if (un->un_eof > ST_EOF) {
3463 					ST_DEBUG2(ST_DEVINFO, st_label,
3464 					    SCSI_DEBUG,
3465 					    "space_fmks, EIO > ST_EOF\n");
3466 					rval = EIO;
3467 					break;
3468 				}
3469 
3470 			}
3471 		}
3472 		un->un_err_resid = count;
3473 		un->un_err_fileno = un->un_fileno;
3474 		un->un_err_blkno = un->un_blkno;
3475 	}
3476 	ASSERT(mutex_owned(ST_MUTEX));
3477 	return (rval);
3478 }
3479 
3480 /*
3481  * this routine spaces to EOM
3482  *
3483  * it keeps track of the current filenumber and returns the filenumber after
3484  * the last successful space operation, we keep the number high because as
3485  * tapes are getting larger, the possibility of more and more files exist,
3486  * 0x100000 (1 Meg of files) probably will never have to be changed any time
3487  * soon
3488  */
3489 #define	MAX_SKIP	0x100000 /* somewhat arbitrary */
3490 
3491 static int
3492 st_find_eom(dev_t dev)
3493 {
3494 	int count, savefile;
3495 	struct scsi_tape *un;
3496 	int instance;
3497 
3498 	instance = MTUNIT(dev);
3499 	if ((un = ddi_get_soft_state(st_state, instance)) == NULL)
3500 		return (-1);
3501 
3502 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3503 	    "st_find_eom(dev = 0x%lx): fileno = %d\n", dev, un->un_fileno);
3504 
3505 	ASSERT(mutex_owned(ST_MUTEX));
3506 
3507 	savefile = un->un_fileno;
3508 
3509 	/*
3510 	 * see if the drive is smart enough to do the skips in
3511 	 * one operation; 1/2" use two filemarks
3512 	 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
3513 	 * because the 8200 does not append a marker; in order not to
3514 	 * sacrifice the fast file skip, we do a slow skip if the low
3515 	 * density device has been opened
3516 	 */
3517 	if ((un->un_dp->options & ST_KNOWS_EOD) &&
3518 	    !((un->un_dp->type == ST_TYPE_EXB8500 && MT_DENSITY(dev) == 0))) {
3519 		count = MAX_SKIP;
3520 	} else {
3521 		count = 1;
3522 	}
3523 
3524 	while (st_cmd(dev, SCMD_SPACE, Fmk(count), SYNC_CMD) == 0) {
3525 
3526 		savefile = un->un_fileno;
3527 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3528 			"count=%x, eof=%x, status=%x\n", count,  un->un_eof,
3529 			un->un_status);
3530 
3531 		/*
3532 		 * If we're not EOM smart,  space a record
3533 		 * to see whether we're now in the slot between
3534 		 * the two sequential filemarks that logical
3535 		 * EOM consists of (REEL) or hit nowhere land
3536 		 * (8mm).
3537 		 */
3538 		if (count == 1) {
3539 			/*
3540 			 * no fast skipping, check a record
3541 			 */
3542 			if (st_cmd(dev, SCMD_SPACE, Blk((1)), SYNC_CMD))
3543 				break;
3544 			else if ((un->un_eof >= ST_EOF_PENDING) &&
3545 			    (un->un_dp->options & ST_REEL)) {
3546 				un->un_status = KEY_BLANK_CHECK;
3547 				un->un_fileno++;
3548 				un->un_blkno = 0;
3549 				break;
3550 			} else if (IN_EOF(un)) {
3551 				un->un_eof = ST_NO_EOF;
3552 				un->un_fileno++;
3553 				un->un_blkno = 0;
3554 			} else if (un->un_eof > ST_EOF) {
3555 				break;
3556 			}
3557 		} else {
3558 			if (un->un_eof >  ST_EOF) {
3559 				break;
3560 			}
3561 		}
3562 	}
3563 
3564 	if (un->un_dp->options & ST_KNOWS_EOD) {
3565 		savefile = un->un_fileno;
3566 	}
3567 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3568 	    "st_find_eom: %x\n", savefile);
3569 	ASSERT(mutex_owned(ST_MUTEX));
3570 	return (savefile);
3571 }
3572 
3573 
3574 /*
3575  * this routine is frequently used in ioctls below;
3576  * it determines whether we know the density and if not will
3577  * determine it
3578  * if we have written the tape before, one or more filemarks are written
3579  *
3580  * depending on the stepflag, the head is repositioned to where it was before
3581  * the filemarks were written in order not to confuse step counts
3582  */
3583 #define	STEPBACK    0
3584 #define	NO_STEPBACK 1
3585 
3586 static int
3587 st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag)
3588 {
3589 
3590 	GET_SOFT_STATE(dev);
3591 
3592 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3593 	"st_check_density_or_wfm(dev= 0x%lx, wfm= %d, mode= %d, stpflg= %d)\n",
3594 	dev, wfm, mode, stepflag);
3595 
3596 	ASSERT(mutex_owned(ST_MUTEX));
3597 
3598 	/*
3599 	 * If we don't yet know the density of the tape we have inserted,
3600 	 * we have to either unconditionally set it (if we're 'writing'),
3601 	 * or we have to determine it. As side effects, check for any
3602 	 * write-protect errors, and for the need to put out any file-marks
3603 	 * before positioning a tape.
3604 	 *
3605 	 * If we are going to be spacing forward, and we haven't determined
3606 	 * the tape density yet, we have to do so now...
3607 	 */
3608 	if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
3609 		if (st_determine_density(dev, mode)) {
3610 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3611 			    "check_density_or_wfm : EIO can't determine "
3612 			    "density\n");
3613 			un->un_errno = EIO;
3614 			return (EIO);
3615 		}
3616 		/*
3617 		 * Presumably we are at BOT. If we attempt to write, it will
3618 		 * either work okay, or bomb. We don't do a st_test_append
3619 		 * unless we're past BOT.
3620 		 */
3621 		un->un_laststate = un->un_state;
3622 		un->un_state = ST_STATE_OPEN;
3623 
3624 	} else if (un->un_fileno >= 0 && un->un_fmneeded > 0 &&
3625 	    ((un->un_lastop == ST_OP_WEOF && wfm) ||
3626 	    (un->un_lastop == ST_OP_WRITE && wfm))) {
3627 
3628 		daddr_t blkno = un->un_blkno;
3629 		int fileno = un->un_fileno;
3630 
3631 		/*
3632 		 * We need to write one or two filemarks.
3633 		 * In the case of the HP, we need to
3634 		 * position the head between the two
3635 		 * marks.
3636 		 */
3637 		if ((un->un_fmneeded > 0) || (un->un_lastop == ST_OP_WEOF)) {
3638 			wfm = un->un_fmneeded;
3639 			un->un_fmneeded = 0;
3640 		}
3641 
3642 		if (st_write_fm(dev, wfm)) {
3643 			un->un_fileno = -1;
3644 			un->un_density_known = 0;
3645 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3646 			    "check_density_or_wfm : EIO can't write fm\n");
3647 			un->un_errno = EIO;
3648 			return (EIO);
3649 		}
3650 
3651 		if (stepflag == STEPBACK) {
3652 			if (st_cmd(dev, SCMD_SPACE, Fmk((-wfm)), SYNC_CMD)) {
3653 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3654 				    "check_density_or_wfm : EIO can't space "
3655 				    "(-wfm)\n");
3656 				un->un_errno = EIO;
3657 				return (EIO);
3658 			}
3659 			un->un_blkno = blkno;
3660 			un->un_fileno = fileno;
3661 		}
3662 	}
3663 
3664 	/*
3665 	 * Whatever we do at this point clears the state of the eof flag.
3666 	 */
3667 
3668 	un->un_eof = ST_NO_EOF;
3669 
3670 	/*
3671 	 * If writing, let's check that we're positioned correctly
3672 	 * at the end of tape before issuing the next write.
3673 	 */
3674 	if (!un->un_read_only) {
3675 		un->un_test_append = 1;
3676 	}
3677 
3678 	ASSERT(mutex_owned(ST_MUTEX));
3679 	return (0);
3680 }
3681 
3682 
3683 /*
3684  * Wait for all outstaning I/O's to complete
3685  *
3686  * we wait on both ncmds and the wait queue for times when we are flushing
3687  * after persistent errors are flagged, which is when ncmds can be 0, and the
3688  * queue can still have I/O's.  This way we preserve order of biodone's.
3689  */
3690 static void
3691 st_wait_for_io(struct scsi_tape *un)
3692 {
3693 	ASSERT(mutex_owned(ST_MUTEX));
3694 	while (un->un_ncmds || un->un_quef) {
3695 		cv_wait(&un->un_queue_cv, ST_MUTEX);
3696 	}
3697 }
3698 
3699 /*
3700  * This routine implements the ioctl calls.  It is called
3701  * from the device switch at normal priority.
3702  */
3703 /*ARGSUSED*/
3704 static int
3705 st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p,
3706     int *rval_p)
3707 {
3708 	int tmp, rval = 0;
3709 
3710 	GET_SOFT_STATE(dev);
3711 
3712 	mutex_enter(ST_MUTEX);
3713 
3714 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3715 	    "st_ioctl(): fileno=%x, blkno=%lx, un_eof=%x, state = %d, "
3716 	    "pe_flag = %d\n",
3717 	    un->un_fileno, un->un_blkno, un->un_eof, un->un_state,
3718 	    IS_PE_FLAG_SET(un));
3719 
3720 	/*
3721 	 * We don't want to block on these, so let them through
3722 	 * and we don't care about setting driver states here.
3723 	 */
3724 	if ((cmd == MTIOCGETDRIVETYPE) ||
3725 	    (cmd == MTIOCGUARANTEEDORDER) ||
3726 	    (cmd == MTIOCPERSISTENTSTATUS)) {
3727 		goto check_commands;
3728 	}
3729 
3730 	/*
3731 	 * wait for all outstanding commands to complete, or be dequeued.
3732 	 * And because ioctl's are synchronous commands, any return value
3733 	 * after this,  will be in order
3734 	 */
3735 	st_wait_for_io(un);
3736 
3737 	/*
3738 	 * allow only a through clear errors and persistent status, and
3739 	 * status
3740 	 */
3741 	if (IS_PE_FLAG_SET(un)) {
3742 		if ((cmd == MTIOCLRERR) ||
3743 		    (cmd == MTIOCPERSISTENT) ||
3744 		    (cmd == MTIOCGET) ||
3745 		    (cmd == USCSIGETRQS)) {
3746 			goto check_commands;
3747 		} else {
3748 			rval = un->un_errno;
3749 			goto exit;
3750 		}
3751 	}
3752 
3753 	un->un_throttle = 1;	/* > 1 will never happen here */
3754 	un->un_errno = 0;	/* start clean from here */
3755 
3756 	/*
3757 	 * first and foremost, handle any ST_EOT_PENDING cases.
3758 	 * That is, if a logical eot is pending notice, notice it.
3759 	 */
3760 	if (un->un_eof == ST_EOT_PENDING) {
3761 		int resid = un->un_err_resid;
3762 		uchar_t status = un->un_status;
3763 		uchar_t lastop = un->un_lastop;
3764 
3765 		if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)) {
3766 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3767 			    "stioctl : EIO can't space fmk(-1)\n");
3768 			rval = EIO;
3769 			goto exit;
3770 		}
3771 		un->un_lastop = lastop; /* restore last operation */
3772 		if (status == SUN_KEY_EOF) {
3773 			un->un_status = SUN_KEY_EOT;
3774 		} else {
3775 			un->un_status = status;
3776 		}
3777 		un->un_err_resid  = resid;
3778 		un->un_err_blkno = un->un_blkno = 0; /* fix up block number */
3779 		un->un_eof = ST_EOT;	/* now we're at logical eot */
3780 	}
3781 
3782 	/*
3783 	 * now, handle the rest of the situations
3784 	 */
3785 check_commands:
3786 	switch (cmd) {
3787 	case MTIOCGET:
3788 		{
3789 #ifdef _MULTI_DATAMODEL
3790 			/*
3791 			 * For use when a 32 bit app makes a call into a
3792 			 * 64 bit ioctl
3793 			 */
3794 			struct mtget32		mtg_local32;
3795 			struct mtget32 		*mtget_32 = &mtg_local32;
3796 #endif /* _MULTI_DATAMODEL */
3797 
3798 			/* Get tape status */
3799 			struct mtget mtg_local;
3800 			struct mtget *mtget = &mtg_local;
3801 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3802 				"st_ioctl: MTIOCGET\n");
3803 
3804 			bzero(mtget, sizeof (struct mtget));
3805 			mtget->mt_erreg = un->un_status;
3806 			mtget->mt_resid = un->un_err_resid;
3807 			mtget->mt_dsreg = un->un_retry_ct;
3808 			mtget->mt_fileno = un->un_err_fileno;
3809 			mtget->mt_blkno = un->un_err_blkno;
3810 			mtget->mt_type = un->un_dp->type;
3811 			mtget->mt_flags = MTF_SCSI | MTF_ASF;
3812 			if (un->un_dp->options & ST_REEL) {
3813 				mtget->mt_flags |= MTF_REEL;
3814 				mtget->mt_bf = 20;
3815 			} else {		/* 1/4" cartridges */
3816 				switch (mtget->mt_type) {
3817 				/* Emulex cartridge tape */
3818 				case MT_ISMT02:
3819 					mtget->mt_bf = 40;
3820 					break;
3821 				default:
3822 					mtget->mt_bf = 126;
3823 					break;
3824 				}
3825 			}
3826 
3827 			/*
3828 			 * If large transfers are allowed and drive options
3829 			 * has no record size limit set. Calculate blocking
3830 			 * factor from the lesser of maxbsize and maxdma.
3831 			 */
3832 			if ((un->un_allow_large_xfer) &&
3833 			    (un->un_dp->options & ST_NO_RECSIZE_LIMIT)) {
3834 				mtget->mt_bf = min(un->un_maxbsize,
3835 				    un->un_maxdma) / SECSIZE;
3836 			}
3837 
3838 			rval = st_check_clean_bit(dev);
3839 			if (rval == -1) {
3840 				rval = EIO;
3841 				goto exit;
3842 			} else {
3843 				mtget->mt_flags |= (ushort_t)rval;
3844 				rval = 0;
3845 			}
3846 
3847 			un->un_status = 0;		/* Reset status */
3848 			un->un_err_resid = 0;
3849 			tmp = sizeof (struct mtget);
3850 
3851 #ifdef _MULTI_DATAMODEL
3852 
3853 		switch (ddi_model_convert_from(flag & FMODELS)) {
3854 		case DDI_MODEL_ILP32:
3855 			/*
3856 			 * Convert 64 bit back to 32 bit before doing
3857 			 * copyout. This is what the ILP32 app expects.
3858 			 */
3859 			mtget_32->mt_erreg = 	mtget->mt_erreg;
3860 			mtget_32->mt_resid = 	mtget->mt_resid;
3861 			mtget_32->mt_dsreg = 	mtget->mt_dsreg;
3862 			mtget_32->mt_fileno = 	(daddr32_t)mtget->mt_fileno;
3863 			mtget_32->mt_blkno = 	(daddr32_t)mtget->mt_blkno;
3864 			mtget_32->mt_type =  	mtget->mt_type;
3865 			mtget_32->mt_flags = 	mtget->mt_flags;
3866 			mtget_32->mt_bf = 	mtget->mt_bf;
3867 
3868 			if (ddi_copyout(mtget_32, (void *)arg,
3869 			    sizeof (struct mtget32), flag)) {
3870 				rval = EFAULT;
3871 			}
3872 			break;
3873 
3874 		case DDI_MODEL_NONE:
3875 			if (ddi_copyout(mtget, (void *)arg, tmp, flag)) {
3876 				rval = EFAULT;
3877 			}
3878 			break;
3879 		}
3880 #else /* ! _MULTI_DATAMODE */
3881 		if (ddi_copyout(mtget, (void *)arg, tmp, flag)) {
3882 			rval = EFAULT;
3883 		}
3884 #endif /* _MULTI_DATAMODE */
3885 
3886 			break;
3887 		}
3888 	case MTIOCSTATE:
3889 		{
3890 			/*
3891 			 * return when media presence matches state
3892 			 */
3893 			enum mtio_state state;
3894 
3895 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3896 				"st_ioctl: MTIOCSTATE\n");
3897 
3898 			if (ddi_copyin((void *)arg, &state, sizeof (int), flag))
3899 				rval = EFAULT;
3900 
3901 			mutex_exit(ST_MUTEX);
3902 
3903 			rval = st_check_media(dev, state);
3904 
3905 			mutex_enter(ST_MUTEX);
3906 
3907 			if (rval != 0) {
3908 				break;
3909 			}
3910 
3911 			if (ddi_copyout(&un->un_mediastate, (void *)arg,
3912 			    sizeof (int), flag))
3913 				rval = EFAULT;
3914 			break;
3915 
3916 		}
3917 
3918 	case MTIOCGETDRIVETYPE:
3919 		{
3920 #ifdef _MULTI_DATAMODEL
3921 		/*
3922 		 * For use when a 32 bit app makes a call into a
3923 		 * 64 bit ioctl
3924 		 */
3925 		struct mtdrivetype_request32	mtdtrq32;
3926 #endif /* _MULTI_DATAMODEL */
3927 
3928 			/*
3929 			 * return mtdrivetype
3930 			 */
3931 			struct mtdrivetype_request mtdtrq;
3932 			struct mtdrivetype mtdrtyp;
3933 			struct mtdrivetype *mtdt = &mtdrtyp;
3934 			struct st_drivetype *stdt = un->un_dp;
3935 
3936 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3937 				"st_ioctl: MTIOCGETDRIVETYPE\n");
3938 
3939 #ifdef _MULTI_DATAMODEL
3940 		switch (ddi_model_convert_from(flag & FMODELS)) {
3941 		case DDI_MODEL_ILP32:
3942 		{
3943 			if (ddi_copyin((void *)arg, &mtdtrq32,
3944 			    sizeof (struct mtdrivetype_request32), flag)) {
3945 				rval = EFAULT;
3946 				break;
3947 			}
3948 			mtdtrq.size = mtdtrq32.size;
3949 			mtdtrq.mtdtp =
3950 			    (struct  mtdrivetype *)(uintptr_t)mtdtrq32.mtdtp;
3951 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3952 				"st_ioctl: size 0x%x\n", mtdtrq.size);
3953 			break;
3954 		}
3955 		case DDI_MODEL_NONE:
3956 			if (ddi_copyin((void *)arg, &mtdtrq,
3957 			    sizeof (struct mtdrivetype_request), flag)) {
3958 				rval = EFAULT;
3959 				break;
3960 			}
3961 			break;
3962 		}
3963 
3964 #else /* ! _MULTI_DATAMODEL */
3965 		if (ddi_copyin((void *)arg, &mtdtrq,
3966 		    sizeof (struct mtdrivetype_request), flag)) {
3967 			rval = EFAULT;
3968 			break;
3969 		}
3970 #endif /* _MULTI_DATAMODEL */
3971 
3972 			/*
3973 			 * if requested size is < 0 then return
3974 			 * error.
3975 			 */
3976 			if (mtdtrq.size < 0) {
3977 				rval = EINVAL;
3978 				break;
3979 			}
3980 			bzero(mtdt, sizeof (struct mtdrivetype));
3981 			(void) strncpy(mtdt->name, stdt->name, ST_NAMESIZE);
3982 			(void) strncpy(mtdt->vid, stdt->vid, VIDPIDLEN - 1);
3983 			mtdt->type = stdt->type;
3984 			mtdt->bsize = stdt->bsize;
3985 			mtdt->options = stdt->options;
3986 			mtdt->max_rretries = stdt->max_rretries;
3987 			mtdt->max_wretries = stdt->max_wretries;
3988 			for (tmp = 0; tmp < NDENSITIES; tmp++)
3989 				mtdt->densities[tmp] = stdt->densities[tmp];
3990 			mtdt->default_density = stdt->default_density;
3991 			/*
3992 			 * Speed hasn't been used since the hayday of reel tape.
3993 			 * For all drives not setting the option ST_KNOWS_MEDIA
3994 			 * the speed member renamed to mediatype are zeros.
3995 			 * Those drives that have ST_KNOWS_MEDIA set use the
3996 			 * new mediatype member which is used to figure the
3997 			 * type of media loaded.
3998 			 *
3999 			 * So as to not break applications speed in the
4000 			 * mtdrivetype structure is not renamed.
4001 			 */
4002 			for (tmp = 0; tmp < NDENSITIES; tmp++) {
4003 				mtdt->speeds[tmp] = stdt->mediatype[tmp];
4004 			}
4005 			mtdt->non_motion_timeout = stdt->non_motion_timeout;
4006 			mtdt->io_timeout = stdt->io_timeout;
4007 			mtdt->rewind_timeout = stdt->rewind_timeout;
4008 			mtdt->space_timeout = stdt->space_timeout;
4009 			mtdt->load_timeout = stdt->load_timeout;
4010 			mtdt->unload_timeout = stdt->unload_timeout;
4011 			mtdt->erase_timeout = stdt->erase_timeout;
4012 
4013 			/*
4014 			 * Limit the maximum length of the result to
4015 			 * sizeof (struct mtdrivetype).
4016 			 */
4017 			tmp = sizeof (struct mtdrivetype);
4018 			if (mtdtrq.size < tmp)
4019 				tmp = mtdtrq.size;
4020 			if (ddi_copyout(mtdt, mtdtrq.mtdtp, tmp, flag)) {
4021 				rval = EFAULT;
4022 			}
4023 			break;
4024 		}
4025 	case MTIOCPERSISTENT:
4026 		{
4027 			int persistence = 0;
4028 
4029 			if (ddi_copyin((void *)arg, &persistence,
4030 			    sizeof (int), flag)) {
4031 				rval = EFAULT;
4032 				break;
4033 			}
4034 
4035 			/* non zero sets it, only 0 turns it off */
4036 			un->un_persistence = (uchar_t)persistence ? 1 : 0;
4037 
4038 			if (un->un_persistence)
4039 				TURN_PE_ON(un);
4040 			else
4041 				TURN_PE_OFF(un);
4042 
4043 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4044 			    "st_ioctl: MTIOCPERSISTENT : persistence = %d\n",
4045 			    un->un_persistence);
4046 
4047 			break;
4048 		}
4049 	case MTIOCPERSISTENTSTATUS:
4050 		{
4051 			int persistence = (int)un->un_persistence;
4052 
4053 			if (ddi_copyout(&persistence, (void *)arg,
4054 			    sizeof (int), flag)) {
4055 				rval = EFAULT;
4056 			}
4057 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4058 			    "st_ioctl: MTIOCPERSISTENTSTATUS:persistece = %d\n",
4059 			    un->un_persistence);
4060 
4061 			break;
4062 		}
4063 
4064 
4065 	case MTIOCLRERR:
4066 		{
4067 			/* clear persistent errors */
4068 
4069 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4070 			    "st_ioctl: MTIOCLRERR\n");
4071 
4072 			CLEAR_PE(un);
4073 
4074 			break;
4075 		}
4076 
4077 	case MTIOCGUARANTEEDORDER:
4078 		{
4079 			/*
4080 			 * this is just a holder to make a valid ioctl and
4081 			 * it won't be in any earlier release
4082 			 */
4083 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4084 			    "st_ioctl: MTIOCGUARANTEEDORDER\n");
4085 
4086 			break;
4087 		}
4088 
4089 	case MTIOCRESERVE:
4090 		{
4091 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4092 			    "st_ioctl: MTIOCRESERVE\n");
4093 
4094 			/*
4095 			 * Check if Reserve/Release is supported.
4096 			 */
4097 			if (!(ST_RESERVE_SUPPORTED(un))) {
4098 				rval = ENOTTY;
4099 				break;
4100 			}
4101 
4102 			rval = st_reserve_release(dev, ST_RESERVE);
4103 
4104 			if (rval == 0) {
4105 				un->un_rsvd_status |= ST_PRESERVE_RESERVE;
4106 			}
4107 			break;
4108 		}
4109 
4110 	case MTIOCRELEASE:
4111 		{
4112 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4113 			    "st_ioctl: MTIOCRELEASE\n");
4114 
4115 			/*
4116 			 * Check if Reserve/Release is supported.
4117 			 */
4118 			if (!(ST_RESERVE_SUPPORTED(un))) {
4119 				rval = ENOTTY;
4120 				break;
4121 			}
4122 
4123 			un->un_rsvd_status &= ~ST_PRESERVE_RESERVE;
4124 
4125 			break;
4126 		}
4127 
4128 	case MTIOCFORCERESERVE:
4129 		{
4130 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4131 			    "st_ioctl: MTIOCFORCERESERVE\n");
4132 
4133 			/*
4134 			 * Check if Reserve/Release is supported.
4135 			 */
4136 			if (!(ST_RESERVE_SUPPORTED(un))) {
4137 				rval = ENOTTY;
4138 				break;
4139 			}
4140 			/*
4141 			 * allow only super user to run this.
4142 			 */
4143 			if (drv_priv(cred_p) != 0) {
4144 				rval = EPERM;
4145 				break;
4146 			}
4147 			/*
4148 			 * Throw away reserve,
4149 			 * not using test-unit-ready
4150 			 * since reserve can succeed without tape being
4151 			 * present in the drive.
4152 			 */
4153 			(void) st_reserve_release(dev, ST_RESERVE);
4154 
4155 			rval = st_take_ownership(dev);
4156 
4157 			break;
4158 		}
4159 	case USCSIGETRQS:
4160 		{
4161 #ifdef _MULTI_DATAMODEL
4162 		/*
4163 		 * For use when a 32 bit app makes a call into a
4164 		 * 64 bit ioctl
4165 		 */
4166 		struct uscsi_rqs32	urqs_32;
4167 		struct uscsi_rqs32	*urqs_32_ptr = &urqs_32;
4168 #endif /* _MULTI_DATAMODEL */
4169 			struct uscsi_rqs	urqs;
4170 			struct uscsi_rqs	*urqs_ptr = &urqs;
4171 			ushort_t		len;
4172 #ifdef _MULTI_DATAMODEL
4173 		switch (ddi_model_convert_from(flag & FMODELS)) {
4174 		case DDI_MODEL_ILP32:
4175 		{
4176 			if (ddi_copyin((void *)arg, urqs_32_ptr,
4177 			    sizeof (struct uscsi_rqs32), flag)) {
4178 				rval = EFAULT;
4179 				break;
4180 			}
4181 			urqs_ptr->rqs_buflen = urqs_32_ptr->rqs_buflen;
4182 			urqs_ptr->rqs_bufaddr =
4183 			    (caddr_t)(uintptr_t)urqs_32_ptr->rqs_bufaddr;
4184 			break;
4185 		}
4186 		case DDI_MODEL_NONE:
4187 			if (ddi_copyin((void *)arg, urqs_ptr,
4188 			    sizeof (struct uscsi_rqs), flag)) {
4189 				rval = EFAULT;
4190 				break;
4191 			}
4192 		}
4193 #else /* ! _MULTI_DATAMODEL */
4194 		if (ddi_copyin((void *)arg, urqs_ptr, sizeof (urqs), flag)) {
4195 			rval = EFAULT;
4196 			break;
4197 		}
4198 #endif /* _MULTI_DATAMODEL */
4199 
4200 			urqs_ptr->rqs_flags = (int)un->un_rqs_state &
4201 			    (ST_RQS_OVR | ST_RQS_VALID);
4202 			if (urqs_ptr->rqs_buflen <= SENSE_LENGTH) {
4203 			    len = urqs_ptr->rqs_buflen;
4204 			    urqs_ptr->rqs_resid = 0;
4205 			} else {
4206 			    len = SENSE_LENGTH;
4207 			    urqs_ptr->rqs_resid = urqs_ptr->rqs_buflen
4208 				    - SENSE_LENGTH;
4209 			}
4210 			if (!(un->un_rqs_state & ST_RQS_VALID)) {
4211 			    urqs_ptr->rqs_resid = urqs_ptr->rqs_buflen;
4212 			}
4213 			un->un_rqs_state |= ST_RQS_READ;
4214 			un->un_rqs_state &= ~(ST_RQS_OVR);
4215 
4216 #ifdef _MULTI_DATAMODEL
4217 		switch (ddi_model_convert_from(flag & FMODELS)) {
4218 		case DDI_MODEL_ILP32:
4219 			urqs_32_ptr->rqs_flags = urqs_ptr->rqs_flags;
4220 			urqs_32_ptr->rqs_resid = urqs_ptr->rqs_resid;
4221 			if (ddi_copyout(&urqs_32, (void *)arg,
4222 			    sizeof (urqs_32), flag)) {
4223 				rval = EFAULT;
4224 			}
4225 			break;
4226 		case DDI_MODEL_NONE:
4227 			if (ddi_copyout(&urqs, (void *)arg, sizeof (urqs),
4228 			    flag)) {
4229 				rval = EFAULT;
4230 			}
4231 			break;
4232 		}
4233 
4234 		if (un->un_rqs_state & ST_RQS_VALID) {
4235 			if (ddi_copyout(un->un_uscsi_rqs_buf,
4236 			    urqs_ptr->rqs_bufaddr, len, flag)) {
4237 				rval = EFAULT;
4238 		    }
4239 		}
4240 #else /* ! _MULTI_DATAMODEL */
4241 		if (ddi_copyout(&urqs, (void *)arg, sizeof (urqs), flag)) {
4242 			rval = EFAULT;
4243 		}
4244 		if (un->un_rqs_state & ST_RQS_VALID) {
4245 			if (ddi_copyout(un->un_uscsi_rqs_buf,
4246 			    urqs_ptr->rqs_bufaddr, len, flag)) {
4247 				rval = EFAULT;
4248 		    }
4249 		}
4250 #endif /* _MULTI_DATAMODEL */
4251 			break;
4252 		}
4253 
4254 	case USCSICMD:
4255 		{
4256 		cred_t	*cr;
4257 #ifdef _MULTI_DATAMODEL
4258 		/*
4259 		 * For use when a 32 bit app makes a call into a
4260 		 * 64 bit ioctl
4261 		 */
4262 		struct uscsi_cmd32	ucmd_32;
4263 		struct uscsi_cmd32	*ucmd_32_ptr = &ucmd_32;
4264 #endif /* _MULTI_DATAMODEL */
4265 
4266 			/*
4267 			 * Run a generic USCSI command
4268 			 */
4269 			struct uscsi_cmd ucmd;
4270 			struct uscsi_cmd *ucmd_ptr = &ucmd;
4271 			enum uio_seg uioseg;
4272 
4273 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4274 				"st_ioctl: USCSICMD\n");
4275 
4276 			cr = ddi_get_cred();
4277 			if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) {
4278 				rval = EPERM;
4279 				break;
4280 			}
4281 
4282 #ifdef _MULTI_DATAMODEL
4283 		switch (ddi_model_convert_from(flag & FMODELS)) {
4284 		case DDI_MODEL_ILP32:
4285 		{
4286 			if (ddi_copyin((void *)arg, ucmd_32_ptr,
4287 			    sizeof (struct uscsi_cmd32), flag)) {
4288 				rval = EFAULT;
4289 				break;
4290 			}
4291 			uscsi_cmd32touscsi_cmd(ucmd_32_ptr, ucmd_ptr);
4292 			break;
4293 		}
4294 		case DDI_MODEL_NONE:
4295 			if (ddi_copyin((void *)arg, ucmd_ptr, sizeof (ucmd),
4296 			    flag)) {
4297 				rval = EFAULT;
4298 				break;
4299 			}
4300 		}
4301 
4302 #else /* ! _MULTI_DATAMODEL */
4303 		if (ddi_copyin((void *)arg, ucmd_ptr, sizeof (ucmd), flag)) {
4304 			rval = EFAULT;
4305 			break;
4306 		}
4307 #endif /* _MULTI_DATAMODEL */
4308 
4309 
4310 			/*
4311 			 * If we haven't done/checked reservation on the
4312 			 * tape unit do it now.
4313 			 */
4314 			if (ST_RESERVE_SUPPORTED(un) &&
4315 				!(un->un_rsvd_status & ST_INIT_RESERVE)) {
4316 				if (rval = st_tape_reservation_init(dev))
4317 					goto exit;
4318 			}
4319 
4320 			/*
4321 			 * although st_ioctl_cmd() never makes use of these
4322 			 * now, we are just being safe and consistent
4323 			 */
4324 			ucmd.uscsi_flags &= ~(USCSI_NOINTR | USCSI_NOPARITY |
4325 			    USCSI_OTAG | USCSI_HTAG | USCSI_HEAD);
4326 
4327 
4328 			uioseg = (flag & FKIOCTL) ?
4329 			    UIO_SYSSPACE : UIO_USERSPACE;
4330 
4331 			rval = st_ioctl_cmd(dev, &ucmd, uioseg, uioseg, uioseg);
4332 
4333 
4334 #ifdef _MULTI_DATAMODEL
4335 		switch (ddi_model_convert_from(flag & FMODELS)) {
4336 		case DDI_MODEL_ILP32:
4337 			/*
4338 			 * Convert 64 bit back to 32 bit before doing
4339 			 * copyout. This is what the ILP32 app expects.
4340 			 */
4341 			uscsi_cmdtouscsi_cmd32(ucmd_ptr, ucmd_32_ptr);
4342 
4343 			if (ddi_copyout(&ucmd_32, (void *)arg,
4344 			    sizeof (ucmd_32), flag)) {
4345 				if (rval != 0)
4346 					rval = EFAULT;
4347 				}
4348 			break;
4349 
4350 		case DDI_MODEL_NONE:
4351 			if (ddi_copyout(&ucmd, (void *)arg,
4352 			    sizeof (ucmd), flag)) {
4353 				if (rval != 0)
4354 					rval = EFAULT;
4355 				}
4356 			break;
4357 		}
4358 #else /* ! _MULTI_DATAMODEL */
4359 		if (ddi_copyout(&ucmd, (void *)arg, sizeof (ucmd), flag)) {
4360 			if (rval != 0)
4361 				rval = EFAULT;
4362 		}
4363 #endif /* _MULTI_DATAMODEL */
4364 
4365 			break;
4366 		}
4367 
4368 	case MTIOCTOP:
4369 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4370 			"st_ioctl: MTIOCTOP\n");
4371 		rval = st_mtioctop(un, arg, flag);
4372 		break;
4373 
4374 	case MTIOCREADIGNOREILI:
4375 		{
4376 			int set_ili;
4377 
4378 			if (ddi_copyin((void *)arg, &set_ili,
4379 			    sizeof (set_ili), flag)) {
4380 				rval = EFAULT;
4381 				break;
4382 			}
4383 
4384 			if (un->un_bsize) {
4385 				rval = ENOTTY;
4386 				break;
4387 			}
4388 
4389 			switch (set_ili) {
4390 			case 0:
4391 				un->un_dp->options &= ~ST_READ_IGNORE_ILI;
4392 				break;
4393 
4394 			case 1:
4395 				un->un_dp->options |= ST_READ_IGNORE_ILI;
4396 				break;
4397 
4398 			default:
4399 				rval = EINVAL;
4400 				break;
4401 			}
4402 			break;
4403 		}
4404 
4405 	case MTIOCREADIGNOREEOFS:
4406 		{
4407 			int ignore_eof;
4408 
4409 			if (ddi_copyin((void *)arg, &ignore_eof,
4410 			    sizeof (ignore_eof), flag)) {
4411 				rval = EFAULT;
4412 				break;
4413 			}
4414 
4415 			if (!(un->un_dp->options & ST_REEL)) {
4416 				rval = ENOTTY;
4417 				break;
4418 			}
4419 
4420 			switch (ignore_eof) {
4421 			case 0:
4422 				un->un_dp->options &= ~ST_READ_IGNORE_EOFS;
4423 				break;
4424 
4425 			case 1:
4426 				un->un_dp->options |= ST_READ_IGNORE_EOFS;
4427 				break;
4428 
4429 			default:
4430 				rval = EINVAL;
4431 				break;
4432 			}
4433 			break;
4434 		}
4435 
4436 	case MTIOCSHORTFMK:
4437 		{
4438 			int short_fmk;
4439 
4440 			if (ddi_copyin((void *)arg, &short_fmk,
4441 			    sizeof (short_fmk), flag)) {
4442 				rval = EFAULT;
4443 				break;
4444 			}
4445 
4446 			switch (un->un_dp->type) {
4447 			case ST_TYPE_EXB8500:
4448 			case ST_TYPE_EXABYTE:
4449 				if (!short_fmk) {
4450 					un->un_dp->options &=
4451 						~ST_SHORT_FILEMARKS;
4452 				} else if (short_fmk == 1) {
4453 					un->un_dp->options |=
4454 						ST_SHORT_FILEMARKS;
4455 				} else {
4456 					rval = EINVAL;
4457 				}
4458 				break;
4459 
4460 			default:
4461 				rval = ENOTTY;
4462 				break;
4463 			}
4464 			break;
4465 		}
4466 
4467 	default:
4468 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4469 			"st_ioctl: unknown ioctl\n");
4470 		rval = ENOTTY;
4471 	}
4472 
4473 exit:
4474 	if (!IS_PE_FLAG_SET(un))
4475 		un->un_errno = rval;
4476 
4477 	mutex_exit(ST_MUTEX);
4478 
4479 	return (rval);
4480 }
4481 
4482 
4483 /*
4484  * do some MTIOCTOP tape operations
4485  */
4486 static int
4487 st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag)
4488 {
4489 	struct mtop *mtop, local;
4490 	int savefile, tmp, rval = 0;
4491 	dev_t dev = un->un_dev;
4492 #ifdef _MULTI_DATAMODEL
4493 	/*
4494 	 * For use when a 32 bit app makes a call into a
4495 	 * 64 bit ioctl
4496 	 */
4497 	struct mtop32	mtop_32_for_64;
4498 #endif /* _MULTI_DATAMODEL */
4499 
4500 
4501 	ASSERT(mutex_owned(ST_MUTEX));
4502 
4503 	mtop = &local;
4504 #ifdef _MULTI_DATAMODEL
4505 		switch (ddi_model_convert_from(flag & FMODELS)) {
4506 		case DDI_MODEL_ILP32:
4507 		{
4508 			if (ddi_copyin((void *)arg, &mtop_32_for_64,
4509 			    sizeof (struct mtop32), flag)) {
4510 				return (EFAULT);
4511 			}
4512 			mtop->mt_op = mtop_32_for_64.mt_op;
4513 			mtop->mt_count =  (daddr_t)mtop_32_for_64.mt_count;
4514 			break;
4515 		}
4516 		case DDI_MODEL_NONE:
4517 			if (ddi_copyin((void *)arg, mtop,
4518 			    sizeof (struct mtop), flag)) {
4519 				return (EFAULT);
4520 			}
4521 			break;
4522 		}
4523 
4524 #else /* ! _MULTI_DATAMODEL */
4525 		if (ddi_copyin((void *)arg, mtop, sizeof (struct mtop), flag)) {
4526 			return (EFAULT);
4527 		}
4528 #endif /* _MULTI_DATAMODEL */
4529 
4530 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4531 	    "st_mtioctop(): mt_op=%x\n", mtop->mt_op);
4532 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4533 	    "fileno=%x, blkno=%lx, un_eof=%x\n", un->un_fileno, un->un_blkno,
4534 	    un->un_eof);
4535 
4536 	rval = 0;
4537 	un->un_status = 0;
4538 
4539 	/*
4540 	 * If we haven't done/checked reservation on the tape unit
4541 	 * do it now.
4542 	 */
4543 	if (ST_RESERVE_SUPPORTED(un) &&
4544 		!(un->un_rsvd_status & ST_INIT_RESERVE)) {
4545 		if (rval = st_tape_reservation_init(dev))
4546 			return (rval);
4547 	}
4548 	/*
4549 	 * if we are going to mess with a tape, we have to make sure we have
4550 	 * one and are not offline (i.e. no tape is initialized).  We let
4551 	 * commands pass here that don't actually touch the tape, except for
4552 	 * loading and initialization (rewinding).
4553 	 */
4554 	if (un->un_state == ST_STATE_OFFLINE) {
4555 		switch (mtop->mt_op) {
4556 		case MTLOAD:
4557 		case MTNOP:
4558 			/*
4559 			 * We don't want strategy calling st_tape_init here,
4560 			 * so, change state
4561 			 */
4562 			un->un_state = ST_STATE_INITIALIZING;
4563 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4564 			    "st_mtioctop : OFFLINE state = %d\n",
4565 			    un->un_state);
4566 			break;
4567 		default:
4568 			/*
4569 			 * reinitialize by normal means
4570 			 */
4571 			if (st_tape_init(dev)) {
4572 				un->un_state = ST_STATE_INITIALIZING;
4573 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4574 				    "st_mtioctop : OFFLINE init failure ");
4575 				un->un_state = ST_STATE_OFFLINE;
4576 				un->un_fileno = -1;
4577 				return (EIO);
4578 			}
4579 			un->un_state = ST_STATE_OPEN_PENDING_IO;
4580 			break;
4581 		}
4582 	}
4583 
4584 	/*
4585 	 * If the file position is invalid, allow only those
4586 	 * commands that properly position the tape and fail
4587 	 * the rest with EIO
4588 	 */
4589 	if (un->un_fileno < 0) {
4590 		switch (mtop->mt_op) {
4591 		case MTWEOF:
4592 		case MTRETEN:
4593 		case MTERASE:
4594 		case MTEOM:
4595 		case MTFSF:
4596 		case MTFSR:
4597 		case MTBSF:
4598 		case MTNBSF:
4599 		case MTBSR:
4600 		case MTSRSZ:
4601 		case MTGRSZ:
4602 			return (EIO);
4603 			/* NOTREACHED */
4604 		case MTREW:
4605 		case MTLOAD:
4606 		case MTOFFL:
4607 		case MTNOP:
4608 			break;
4609 
4610 		default:
4611 			return (ENOTTY);
4612 			/* NOTREACHED */
4613 		}
4614 	}
4615 
4616 	switch (mtop->mt_op) {
4617 	case MTERASE:
4618 		/*
4619 		 * MTERASE rewinds the tape, erase it completely, and returns
4620 		 * to the beginning of the tape
4621 		 */
4622 		if (un->un_dp->options & ST_REEL)
4623 			un->un_fmneeded = 2;
4624 
4625 		if (un->un_mspl->wp || un->un_read_only) {
4626 			un->un_status = KEY_WRITE_PROTECT;
4627 			un->un_err_resid = mtop->mt_count;
4628 			un->un_err_fileno = un->un_fileno;
4629 			un->un_err_blkno = un->un_blkno;
4630 			return (EACCES);
4631 		}
4632 		if (st_check_density_or_wfm(dev, 1, B_WRITE, NO_STEPBACK) ||
4633 		    st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD) ||
4634 		    st_cmd(dev, SCMD_ERASE, 0, SYNC_CMD)) {
4635 			un->un_fileno = -1;
4636 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4637 			    "st_mtioctop : EIO space or erase or check den)\n");
4638 			rval = EIO;
4639 		} else {
4640 			/* QIC and helical scan rewind after erase */
4641 			if (un->un_dp->options & ST_REEL) {
4642 				(void) st_cmd(dev, SCMD_REWIND, 0, ASYNC_CMD);
4643 			}
4644 		}
4645 		break;
4646 
4647 	case MTWEOF:
4648 		/*
4649 		 * write an end-of-file record
4650 		 */
4651 		if (un->un_mspl->wp || un->un_read_only) {
4652 			un->un_status = KEY_WRITE_PROTECT;
4653 			un->un_err_resid = mtop->mt_count;
4654 			un->un_err_fileno = un->un_fileno;
4655 			un->un_err_blkno = un->un_blkno;
4656 			return (EACCES);
4657 		}
4658 
4659 		/*
4660 		 * zero count means just flush buffers
4661 		 * negative count is not permitted
4662 		 */
4663 		if (mtop->mt_count < 0)
4664 			return (EINVAL);
4665 
4666 		if (!un->un_read_only) {
4667 			un->un_test_append = 1;
4668 		}
4669 
4670 		if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
4671 			if (st_determine_density(dev, B_WRITE)) {
4672 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4673 				    "st_mtioctop : EIO : MTWEOF can't determine"
4674 				    "density");
4675 				return (EIO);
4676 			}
4677 		}
4678 
4679 		if (st_write_fm(dev, (int)mtop->mt_count)) {
4680 			/*
4681 			 * Failure due to something other than illegal
4682 			 * request results in loss of state (st_intr).
4683 			 */
4684 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4685 			    "st_mtioctop : EIO : MTWEOF can't write file mark");
4686 			rval = EIO;
4687 		}
4688 		break;
4689 
4690 	case MTRETEN:
4691 		/*
4692 		 * retension the tape
4693 		 */
4694 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK) ||
4695 		    st_cmd(dev, SCMD_LOAD, 3, SYNC_CMD)) {
4696 			un->un_fileno = -1;
4697 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4698 			    "st_mtioctop : EIO : MTRETEN ");
4699 			rval = EIO;
4700 		}
4701 		break;
4702 
4703 	case MTREW:
4704 		/*
4705 		 * rewind  the tape
4706 		 */
4707 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) {
4708 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4709 			    "st_mtioctop : EIO:MTREW check density/wfm failed");
4710 			return (EIO);
4711 		}
4712 		if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
4713 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4714 			    "st_mtioctop : EIO : MTREW ");
4715 			rval = EIO;
4716 		}
4717 		break;
4718 
4719 	case MTOFFL:
4720 		/*
4721 		 * rewinds, and, if appropriate, takes the device offline by
4722 		 * unloading the tape
4723 		 */
4724 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) {
4725 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4726 			    "st_mtioctop :EIO:MTOFFL check density/wfm failed");
4727 			return (EIO);
4728 		}
4729 		(void) st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD);
4730 		if (st_cmd(dev, SCMD_LOAD, 0, SYNC_CMD)) {
4731 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4732 			    "st_mtioctop : EIO : MTOFFL");
4733 			return (EIO);
4734 		}
4735 		un->un_eof = ST_NO_EOF;
4736 		un->un_laststate = un->un_state;
4737 		un->un_state = ST_STATE_OFFLINE;
4738 		un->un_mediastate = MTIO_EJECTED;
4739 		break;
4740 
4741 	case MTLOAD:
4742 		/*
4743 		 * This is to load a tape into the drive
4744 		 * Note that if the tape is not loaded, the device will have
4745 		 * to be opened via O_NDELAY or O_NONBLOCK.
4746 		 */
4747 		/*
4748 		 * Let's try and clean things up, if we are not
4749 		 * initializing, and then send in the load command, no
4750 		 * matter what.
4751 		 *
4752 		 * we try the load twice because some drives fail the first
4753 		 * load after a media change by the user.
4754 		 */
4755 
4756 		if (un->un_state > ST_STATE_INITIALIZING)
4757 			(void) st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK);
4758 
4759 		if (st_cmd(dev, SCMD_LOAD, 1, SYNC_CMD) &&
4760 		    st_cmd(dev, SCMD_LOAD, 1, SYNC_CMD)) {
4761 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4762 			    "st_mtioctop : EIO : MTLOAD\n");
4763 			rval = EIO;
4764 
4765 			/*
4766 			 * If load tape fails, who knows what happened...
4767 			 */
4768 			un->un_fileno = -1;
4769 			rval = EIO;
4770 			break;
4771 		}
4772 
4773 		/*
4774 		 * reset all counters appropriately using rewind, as if LOAD
4775 		 * succeeds, we are at BOT
4776 		 */
4777 		un->un_state = ST_STATE_INITIALIZING;
4778 
4779 		if (st_tape_init(dev)) {
4780 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4781 			    "st_mtioctop : EIO : MTLOAD calls st_tape_init\n");
4782 			rval = EIO;
4783 			un->un_state = ST_STATE_OFFLINE;
4784 		}
4785 
4786 		break;
4787 
4788 	case MTNOP:
4789 		un->un_status = 0;		/* Reset status */
4790 		un->un_err_resid = 0;
4791 		break;
4792 
4793 	case MTEOM:
4794 		/*
4795 		 * positions the tape at a location just after the last file
4796 		 * written on the tape. For cartridge and 8 mm, this after
4797 		 * the last file mark; for reel, this is inbetween the two
4798 		 * last 2 file marks
4799 		 */
4800 		if ((un->un_eof >= ST_EOT) ||
4801 		    (un->un_lastop == ST_OP_WRITE) ||
4802 		    (un->un_lastop == ST_OP_WEOF)) {
4803 			/*
4804 			 * If the command wants to move to logical end
4805 			 * of media, and we're already there, we're done.
4806 			 * If we were at logical eot, we reset the state
4807 			 * to be *not* at logical eot.
4808 			 *
4809 			 * If we're at physical or logical eot, we prohibit
4810 			 * forward space operations (unconditionally).
4811 			 *
4812 			 * Also if the last operation was a write of any
4813 			 * kind the tape is at EOD.
4814 			 */
4815 			return (0);
4816 		}
4817 		/*
4818 		 * physical tape position may not be what we've been
4819 		 * telling the user; adjust the request accordingly
4820 		 */
4821 		if (IN_EOF(un)) {
4822 			un->un_fileno++;
4823 			un->un_blkno = 0;
4824 		}
4825 
4826 		if (st_check_density_or_wfm(dev, 1, B_READ, NO_STEPBACK)) {
4827 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4828 			    "st_mtioctop : EIO:MTEOM check density/wfm failed");
4829 			return (EIO);
4830 		}
4831 
4832 		/*
4833 		 * st_find_eom() returns the last fileno we knew about;
4834 		 */
4835 		savefile = st_find_eom(dev);
4836 
4837 		if ((un->un_status != KEY_BLANK_CHECK) &&
4838 		    (un->un_status != SUN_KEY_EOT)) {
4839 			un->un_fileno = -1;
4840 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4841 			    "st_mtioctop : EIO : MTEOM status check failed");
4842 			rval = EIO;
4843 		} else {
4844 			/*
4845 			 * For 1/2" reel tapes assume logical EOT marked
4846 			 * by two file marks or we don't care that we may
4847 			 * be extending the last file on the tape.
4848 			 */
4849 			if (un->un_dp->options & ST_REEL) {
4850 				if (st_cmd(dev, SCMD_SPACE, Fmk((-1)),
4851 				    SYNC_CMD)) {
4852 					un->un_fileno = -1;
4853 					ST_DEBUG2(ST_DEVINFO, st_label,
4854 					    SCSI_DEBUG,
4855 					    "st_mtioctop : EIO : MTEOM space "
4856 					    "cmd failed");
4857 					rval = EIO;
4858 					break;
4859 				}
4860 				/*
4861 				 * Fix up the block number.
4862 				 */
4863 				un->un_blkno = 0;
4864 				un->un_err_blkno = 0;
4865 			}
4866 			un->un_err_resid = 0;
4867 			un->un_fileno = savefile;
4868 			un->un_eof = ST_EOT;
4869 		}
4870 		un->un_status = 0;
4871 		break;
4872 
4873 	case MTFSF:
4874 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4875 		    "fsf: count=%lx, eof=%x\n", mtop->mt_count,
4876 			un->un_eof);
4877 		/*
4878 		 * forward space over filemark
4879 		 *
4880 		 * For ASF we allow a count of 0 on fsf which means
4881 		 * we just want to go to beginning of current file.
4882 		 * Equivalent to "nbsf(0)" or "bsf(1) + fsf".
4883 		 * Allow stepping over double fmk with reel
4884 		 */
4885 		if ((un->un_eof >= ST_EOT) && (mtop->mt_count > 0) &&
4886 		    ((un->un_dp->options & ST_REEL) == 0)) {
4887 			/* we're at EOM */
4888 			un->un_err_resid = mtop->mt_count;
4889 			un->un_status = KEY_BLANK_CHECK;
4890 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4891 			    "st_mtioctop : EIO : MTFSF at EOM");
4892 			return (EIO);
4893 		}
4894 
4895 		/*
4896 		 * physical tape position may not be what we've been
4897 		 * telling the user; adjust the request accordingly
4898 		 */
4899 		if (IN_EOF(un)) {
4900 			un->un_fileno++;
4901 			un->un_blkno = 0;
4902 			/*
4903 			 * For positive direction case, we're now covered.
4904 			 * For zero or negative direction, we're covered
4905 			 * (almost)
4906 			 */
4907 			mtop->mt_count--;
4908 		}
4909 
4910 		if (st_check_density_or_wfm(dev, 1, B_READ, STEPBACK)) {
4911 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4912 			    "st_mtioctop : EIO : MTFSF density/wfm failed");
4913 			return (EIO);
4914 		}
4915 
4916 
4917 		/*
4918 		 * Forward space file marks.
4919 		 * We leave ourselves at block zero
4920 		 * of the target file number.
4921 		 */
4922 		if (mtop->mt_count < 0) {
4923 			mtop->mt_count = -mtop->mt_count;
4924 			mtop->mt_op = MTNBSF;
4925 			goto bspace;
4926 		}
4927 fspace:
4928 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4929 		    "fspace: count=%lx, eof=%x\n", mtop->mt_count,
4930 			un->un_eof);
4931 		if ((tmp = mtop->mt_count) == 0) {
4932 			if (un->un_blkno == 0) {
4933 				un->un_err_resid = 0;
4934 				un->un_err_fileno = un->un_fileno;
4935 				un->un_err_blkno = un->un_blkno;
4936 				break;
4937 			} else if (un->un_fileno == 0) {
4938 				rval = st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD);
4939 			} else if (un->un_dp->options & ST_BSF) {
4940 				rval = (st_cmd(dev, SCMD_SPACE, Fmk((-1)),
4941 				    SYNC_CMD) ||
4942 				    st_cmd(dev, SCMD_SPACE, Fmk(1), SYNC_CMD));
4943 			} else {
4944 				tmp = un->un_fileno;
4945 				rval = (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD) ||
4946 				    st_cmd(dev, SCMD_SPACE, (int)Fmk(tmp),
4947 				    SYNC_CMD));
4948 			}
4949 			if (rval != 0) {
4950 				un->un_fileno = -1;
4951 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4952 				    "st_mtioctop : EIO : fspace fileno = -1");
4953 
4954 				rval = EIO;
4955 			}
4956 		} else {
4957 			rval = st_space_fmks(dev, tmp);
4958 		}
4959 
4960 		if (mtop->mt_op == MTBSF && rval != EIO) {
4961 			/*
4962 			 * we came here with a count < 0; we now need
4963 			 * to skip back to end up before the filemark
4964 			 */
4965 			mtop->mt_count = 1;
4966 			goto bspace;
4967 		}
4968 		break;
4969 
4970 
4971 	case MTFSR:
4972 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4973 		    "fsr: count=%lx, eof=%x\n", mtop->mt_count,
4974 			un->un_eof);
4975 		/*
4976 		 * forward space to inter-record gap
4977 		 *
4978 		 */
4979 		if ((un->un_eof >= ST_EOT) && (mtop->mt_count > 0)) {
4980 			/* we're at EOM */
4981 			un->un_err_resid = mtop->mt_count;
4982 			un->un_status = KEY_BLANK_CHECK;
4983 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4984 			    "st_mtioctop : EIO : MTFSR un_eof > ST_EOT");
4985 			return (EIO);
4986 		}
4987 
4988 		if (mtop->mt_count == 0) {
4989 			un->un_err_fileno = un->un_fileno;
4990 			un->un_err_blkno = un->un_blkno;
4991 			un->un_err_resid = 0;
4992 			if (IN_EOF(un) && SVR4_BEHAVIOR) {
4993 				un->un_status = SUN_KEY_EOF;
4994 			}
4995 			return (0);
4996 		}
4997 
4998 		/*
4999 		 * physical tape position may not be what we've been
5000 		 * telling the user; adjust the position accordingly
5001 		 */
5002 		if (IN_EOF(un)) {
5003 			daddr_t blkno = un->un_blkno;
5004 			int fileno = un->un_fileno;
5005 			uchar_t lastop = un->un_lastop;
5006 			if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)
5007 			    == -1) {
5008 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5009 				    "st_mtioctop : EIO :MTFSR count && IN_EOF");
5010 				return (EIO);
5011 			}
5012 
5013 			un->un_blkno = blkno;
5014 			un->un_fileno = fileno;
5015 			un->un_lastop = lastop;
5016 		}
5017 
5018 		if (st_check_density_or_wfm(dev, 1, B_READ, STEPBACK)) {
5019 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5020 			    "st_mtioctop : EIO : MTFSR st_check_den");
5021 			return (EIO);
5022 		}
5023 
5024 space_records:
5025 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5026 		    "space_records: count=%lx, eof=%x\n", mtop->mt_count,
5027 			un->un_eof);
5028 		tmp = un->un_blkno + mtop->mt_count;
5029 		if (tmp == un->un_blkno) {
5030 			un->un_err_resid = 0;
5031 			un->un_err_fileno = un->un_fileno;
5032 			un->un_err_blkno = un->un_blkno;
5033 			break;
5034 		} else if (un->un_blkno < tmp ||
5035 		    (un->un_dp->options & ST_BSR)) {
5036 			/*
5037 			 * If we're spacing forward, or the device can
5038 			 * backspace records, we can just use the SPACE
5039 			 * command.
5040 			 */
5041 			tmp = tmp - un->un_blkno;
5042 			if (st_cmd(dev, SCMD_SPACE, Blk(tmp), SYNC_CMD)) {
5043 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5044 				    "st_mtioctop :EIO:space_records can't spc");
5045 				rval = EIO;
5046 			} else if (un->un_eof >= ST_EOF_PENDING) {
5047 				/*
5048 				 * check if we hit BOT/EOT
5049 				 */
5050 				if (tmp < 0 && un->un_eof == ST_EOM) {
5051 					un->un_status = SUN_KEY_BOT;
5052 					un->un_eof = ST_NO_EOF;
5053 				} else if (tmp < 0 && un->un_eof ==
5054 				    ST_EOF_PENDING) {
5055 					int residue = un->un_err_resid;
5056 					/*
5057 					 * we skipped over a filemark
5058 					 * and need to go forward again
5059 					 */
5060 					if (st_cmd(dev, SCMD_SPACE, Fmk(1),
5061 					    SYNC_CMD)) {
5062 						ST_DEBUG2(ST_DEVINFO,
5063 						    st_label, SCSI_DEBUG,
5064 						    "st_mtioctop : EIO : "
5065 						    "space_records can't "
5066 						    "space #2");
5067 						rval = EIO;
5068 					}
5069 					un->un_err_resid = residue;
5070 				}
5071 				if (rval == 0) {
5072 					ST_DEBUG2(ST_DEVINFO, st_label,
5073 					    SCSI_DEBUG,
5074 					    "st_mtioctop : EIO : space_rec rval"
5075 					    " == 0");
5076 					rval = EIO;
5077 				}
5078 			}
5079 		} else {
5080 			/*
5081 			 * else we rewind, space forward across filemarks to
5082 			 * the desired file, and then space records to the
5083 			 * desired block.
5084 			 */
5085 
5086 			int t = un->un_fileno;	/* save current file */
5087 
5088 			if (tmp < 0) {
5089 				/*
5090 				 * Wups - we're backing up over a filemark
5091 				 */
5092 				if (un->un_blkno != 0 &&
5093 				    (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD) ||
5094 				    st_cmd(dev, SCMD_SPACE, Fmk(t), SYNC_CMD)))
5095 					un->un_fileno = -1;
5096 				un->un_err_resid = -tmp;
5097 				if (un->un_fileno == 0 && un->un_blkno == 0) {
5098 					un->un_status = SUN_KEY_BOT;
5099 					un->un_eof = ST_NO_EOF;
5100 				} else if (un->un_fileno > 0) {
5101 					un->un_status = SUN_KEY_EOF;
5102 					un->un_eof = ST_NO_EOF;
5103 				}
5104 				un->un_err_fileno = un->un_fileno;
5105 				un->un_err_blkno = un->un_blkno;
5106 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5107 				    "st_mtioctop :EIO:space_records : tmp < 0");
5108 				rval = EIO;
5109 			} else if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD) ||
5110 				    st_cmd(dev, SCMD_SPACE, Fmk(t), SYNC_CMD) ||
5111 				    st_cmd(dev, SCMD_SPACE, Blk(tmp),
5112 					SYNC_CMD)) {
5113 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5114 				    "st_mtioctop : EIO :space_records : rewind "
5115 				    "and space failed");
5116 				un->un_fileno = -1;
5117 				rval = EIO;
5118 			}
5119 		}
5120 		break;
5121 
5122 
5123 	case MTBSF:
5124 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5125 		    "bsf: count=%lx, eof=%x\n", mtop->mt_count,
5126 			un->un_eof);
5127 		/*
5128 		 * backward space of file filemark (1/2" and 8mm)
5129 		 * tape position will end on the beginning of tape side
5130 		 * of the desired file mark
5131 		 */
5132 		if ((un->un_dp->options & ST_BSF) == 0) {
5133 			return (ENOTTY);
5134 		}
5135 
5136 		/*
5137 		 * If a negative count (which implies a forward space op)
5138 		 * is specified, and we're at logical or physical eot,
5139 		 * bounce the request.
5140 		 */
5141 
5142 		if (un->un_eof >= ST_EOT && mtop->mt_count < 0) {
5143 			un->un_err_resid = mtop->mt_count;
5144 			un->un_status = SUN_KEY_EOT;
5145 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5146 			    "st_ioctl : EIO : MTBSF : un_eof > ST_EOF");
5147 			return (EIO);
5148 		}
5149 		/*
5150 		 * physical tape position may not be what we've been
5151 		 * telling the user; adjust the request accordingly
5152 		 */
5153 		if (IN_EOF(un)) {
5154 			un->un_fileno++;
5155 			un->un_blkno = 0;
5156 			mtop->mt_count++;
5157 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5158 			"bsf in eof: count=%ld, op=%x\n",
5159 			mtop->mt_count, mtop->mt_op);
5160 
5161 		}
5162 
5163 		if (st_check_density_or_wfm(dev, 1, 0, STEPBACK)) {
5164 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5165 			    "st_ioctl : EIO : MTBSF : check den wfm");
5166 			return (EIO);
5167 		}
5168 
5169 		if (mtop->mt_count <= 0) {
5170 			/*
5171 			 * for a negative count, we need to step forward
5172 			 * first and then step back again
5173 			 */
5174 			mtop->mt_count = -mtop->mt_count+1;
5175 			goto fspace;
5176 		}
5177 
5178 bspace:
5179 	{
5180 		int skip_cnt, end_at_eof;
5181 
5182 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5183 		    "bspace: count=%lx, eof=%x\n", mtop->mt_count,
5184 			un->un_eof);
5185 		/*
5186 		 * Backspace files (MTNBSF):
5187 		 *
5188 		 *	For tapes that can backspace, backspace
5189 		 *	count+1 filemarks and then run forward over
5190 		 *	a filemark
5191 		 *
5192 		 *	For tapes that can't backspace,
5193 		 *		calculate desired filenumber
5194 		 *		(un->un_fileno - count), rewind,
5195 		 *		and then space forward this amount
5196 		 *
5197 		 * Backspace filemarks (MTBSF)
5198 		 *
5199 		 *	For tapes that can backspace, backspace count
5200 		 *	filemarks
5201 		 *
5202 		 *	For tapes that can't backspace, calculate
5203 		 *	desired filenumber (un->un_fileno - count),
5204 		 *	add 1, rewind, space forward this amount,
5205 		 *	and mark state as ST_EOF_PENDING appropriately.
5206 		 */
5207 
5208 		if (mtop->mt_op == MTBSF) {
5209 			end_at_eof = 1;
5210 		} else {
5211 			end_at_eof = 0;
5212 		}
5213 
5214 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5215 		    "bspace: mt_op=%x, count=%lx, fileno=%x, blkno=%lx\n",
5216 		    mtop->mt_op, mtop->mt_count, un->un_fileno, un->un_blkno);
5217 
5218 		/*
5219 		 * Handle the simple case of BOT
5220 		 * playing a role in these cmds.
5221 		 * We do this by calculating the
5222 		 * ending file number. If the ending
5223 		 * file is < BOT, rewind and set an
5224 		 * error and mark resid appropriately.
5225 		 * If we're backspacing a file (not a
5226 		 * filemark) and the target file is
5227 		 * the first file on the tape, just
5228 		 * rewind.
5229 		 */
5230 
5231 		tmp = un->un_fileno - mtop->mt_count;
5232 		if ((end_at_eof && tmp < 0) || (end_at_eof == 0 && tmp <= 0)) {
5233 			if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
5234 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5235 				    "st_ioctl : EIO : bspace : end_at_eof && "
5236 				    "tmp < 0");
5237 				rval = EIO;
5238 			}
5239 			if (tmp < 0) {
5240 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5241 				    "st_ioctl : EIO : bspace : tmp < 0");
5242 				rval = EIO;
5243 				un->un_err_resid = -tmp;
5244 				un->un_status = SUN_KEY_BOT;
5245 			}
5246 			break;
5247 		}
5248 
5249 		if (un->un_dp->options & ST_BSF) {
5250 			skip_cnt = 1 - end_at_eof;
5251 			/*
5252 			 * If we are going to end up at the beginning
5253 			 * of the file, we have to space one extra file
5254 			 * first, and then space forward later.
5255 			 */
5256 			tmp = -(mtop->mt_count + skip_cnt);
5257 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5258 			    "skip_cnt=%x, tmp=%x\n", skip_cnt, tmp);
5259 			if (st_cmd(dev, SCMD_SPACE, Fmk(tmp), SYNC_CMD)) {
5260 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5261 				    "st_ioctl : EIO : bspace : can't space "
5262 				    "tmp");
5263 				rval = EIO;
5264 			}
5265 		} else {
5266 			if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
5267 				rval = EIO;
5268 			} else {
5269 				skip_cnt = tmp + end_at_eof;
5270 			}
5271 		}
5272 
5273 		/*
5274 		 * If we have to space forward, do so...
5275 		 */
5276 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5277 		    "space forward skip_cnt=%x, rval=%x\n", skip_cnt, rval);
5278 		if (rval == 0 && skip_cnt) {
5279 			if (st_cmd(dev, SCMD_SPACE, Fmk(skip_cnt), SYNC_CMD)) {
5280 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5281 				    "st_ioctl : EIO : bspace : can't space "
5282 				    "skip_cnt");
5283 				rval = EIO;
5284 			} else if (end_at_eof) {
5285 				/*
5286 				 * If we had to space forward, and we're
5287 				 * not a tape that can backspace, mark state
5288 				 * as if we'd just seen a filemark during a
5289 				 * a read.
5290 				 */
5291 				if ((un->un_dp->options & ST_BSF) == 0) {
5292 					un->un_eof = ST_EOF_PENDING;
5293 					un->un_fileno -= 1;
5294 					un->un_blkno = INF;
5295 				}
5296 			}
5297 		}
5298 
5299 		if (rval != 0) {
5300 			un->un_fileno = -1;
5301 		}
5302 		break;
5303 	}
5304 
5305 	case MTNBSF:
5306 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5307 		    "nbsf: count=%lx, eof=%x\n", mtop->mt_count,
5308 			un->un_eof);
5309 		/*
5310 		 * backward space file to beginning of file
5311 		 *
5312 		 * If a negative count (which implies a forward space op)
5313 		 * is specified, and we're at logical or physical eot,
5314 		 * bounce the request.
5315 		 */
5316 
5317 		if (un->un_eof >= ST_EOT && mtop->mt_count < 0) {
5318 			un->un_err_resid = mtop->mt_count;
5319 			un->un_status = SUN_KEY_EOT;
5320 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5321 			    "st_ioctl : EIO : > EOT and count < 0");
5322 			return (EIO);
5323 		}
5324 		/*
5325 		 * physical tape position may not be what we've been
5326 		 * telling the user; adjust the request accordingly
5327 		 */
5328 		if (IN_EOF(un)) {
5329 			un->un_fileno++;
5330 			un->un_blkno = 0;
5331 			mtop->mt_count++;
5332 		}
5333 
5334 		if (st_check_density_or_wfm(dev, 1, 0, STEPBACK)) {
5335 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5336 			    "st_ioctl : EIO : MTNBSF check den and wfm");
5337 			return (EIO);
5338 		}
5339 
5340 mtnbsf:
5341 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5342 		    "mtnbsf: count=%lx, eof=%x\n", mtop->mt_count,
5343 			un->un_eof);
5344 		if (mtop->mt_count <= 0) {
5345 			mtop->mt_op = MTFSF;
5346 			mtop->mt_count = -mtop->mt_count;
5347 			goto fspace;
5348 		}
5349 		goto bspace;
5350 
5351 	case MTBSR:
5352 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5353 		    "bsr: count=%lx, eof=%x\n", mtop->mt_count,
5354 			un->un_eof);
5355 		/*
5356 		 * backward space into inter-record gap
5357 		 *
5358 		 * If a negative count (which implies a forward space op)
5359 		 * is specified, and we're at logical or physical eot,
5360 		 * bounce the request.
5361 		 */
5362 		if (un->un_eof >= ST_EOT && mtop->mt_count < 0) {
5363 			un->un_err_resid = mtop->mt_count;
5364 			un->un_status = SUN_KEY_EOT;
5365 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5366 			    "st_ioctl : EIO : MTBSR > EOT");
5367 			return (EIO);
5368 		}
5369 
5370 		if (mtop->mt_count == 0) {
5371 			un->un_err_fileno = un->un_fileno;
5372 			un->un_err_blkno = un->un_blkno;
5373 			un->un_err_resid = 0;
5374 			if (IN_EOF(un) && SVR4_BEHAVIOR) {
5375 				un->un_status = SUN_KEY_EOF;
5376 			}
5377 			return (0);
5378 		}
5379 
5380 		/*
5381 		 * physical tape position may not be what we've been
5382 		 * telling the user; adjust the position accordingly.
5383 		 * bsr can not skip filemarks and continue to skip records
5384 		 * therefore if we are logically before the filemark but
5385 		 * physically at the EOT side of the filemark, we need to step
5386 		 * back; this allows fsr N where N > number of blocks in file
5387 		 * followed by bsr 1 to position at the beginning of last block
5388 		 */
5389 		if (IN_EOF(un)) {
5390 			int blkno = un->un_blkno;
5391 			int fileno = un->un_fileno;
5392 			uchar_t lastop = un->un_lastop;
5393 			if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)
5394 			    == -1) {
5395 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5396 				    "st_write_fm : EIO : MTBSR can't space");
5397 				return (EIO);
5398 			}
5399 
5400 			un->un_blkno = blkno;
5401 			un->un_fileno = fileno;
5402 			un->un_lastop = lastop;
5403 		}
5404 
5405 		un->un_eof = ST_NO_EOF;
5406 
5407 		if (st_check_density_or_wfm(dev, 1, 0, STEPBACK)) {
5408 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5409 			    "st_ioctl : EIO : MTBSR : can't set density or "
5410 			    "wfm");
5411 			return (EIO);
5412 		}
5413 
5414 		mtop->mt_count = -mtop->mt_count;
5415 		goto space_records;
5416 
5417 	case MTSRSZ:
5418 
5419 		/*
5420 		 * Set record-size to that sent by user
5421 		 * Check to see if there is reason that the requested
5422 		 * block size should not be set.
5423 		 */
5424 
5425 		/* If requesting variable block size is it ok? */
5426 		if ((mtop->mt_count == 0) &&
5427 		    ((un->un_dp->options & ST_VARIABLE) == 0)) {
5428 			return (ENOTTY);
5429 		}
5430 
5431 		/*
5432 		 * If requested block size is not variable "0",
5433 		 * is it less then minimum.
5434 		 */
5435 		if ((mtop->mt_count != 0) &&
5436 		    (mtop->mt_count < un->un_minbsize)) {
5437 			return (EINVAL);
5438 		}
5439 
5440 		/* Is the requested block size more then maximum */
5441 		if ((mtop->mt_count > min(un->un_maxbsize, un->un_maxdma)) &&
5442 		    (un->un_maxbsize != 0)) {
5443 			return (EINVAL);
5444 		}
5445 
5446 		/* Is requested block size a modulus the device likes */
5447 		if ((mtop->mt_count % un->un_data_mod) != 0) {
5448 			return (EINVAL);
5449 		}
5450 
5451 		if (st_change_block_size(dev, (uint32_t)mtop->mt_count) != 0) {
5452 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5453 			    "st_ioctl : MTSRSZ : EIO : cant set block size");
5454 			return (EIO);
5455 		}
5456 
5457 		return (0);
5458 
5459 	case MTGRSZ:
5460 	{
5461 #ifdef _MULTI_DATAMODEL
5462 	/*
5463 	 * For use when a 32 bit app makes a call into a
5464 	 * 64 bit ioctl
5465 	 */
5466 	struct mtop32	mtop_32_for_64;
5467 #endif /* _MULTI_DATAMODEL */
5468 
5469 
5470 		/*
5471 		 * Get record-size to the user
5472 		 */
5473 		mtop->mt_count = un->un_bsize;
5474 
5475 #ifdef _MULTI_DATAMODEL
5476 		switch (ddi_model_convert_from(flag & FMODELS)) {
5477 		case DDI_MODEL_ILP32:
5478 			/*
5479 			 * Convert 64 bit back to 32 bit before doing
5480 			 * copyout. This is what the ILP32 app expects.
5481 			 */
5482 			mtop_32_for_64.mt_op = mtop->mt_op;
5483 			mtop_32_for_64.mt_count = mtop->mt_count;
5484 
5485 			if (ddi_copyout(&mtop_32_for_64, (void *)arg,
5486 			    sizeof (struct mtop32), flag)) {
5487 				return (EFAULT);
5488 			}
5489 			break;
5490 
5491 		case DDI_MODEL_NONE:
5492 			if (ddi_copyout(mtop, (void *)arg,
5493 			    sizeof (struct mtop), flag)) {
5494 				return (EFAULT);
5495 			}
5496 			break;
5497 		}
5498 #else /* ! _MULTI_DATAMODE */
5499 		if (ddi_copyout(mtop, (void *)arg, sizeof (struct mtop), flag))
5500 			return (EFAULT);
5501 
5502 #endif /* _MULTI_DATAMODE */
5503 
5504 		return (0);
5505 	}
5506 	default:
5507 		rval = ENOTTY;
5508 	}
5509 
5510 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5511 	    "st_ioctl: fileno=%x, blkno=%lx, un_eof=%x\n", un->un_fileno,
5512 	    un->un_blkno, un->un_eof);
5513 
5514 	if (un->un_fileno < 0) {
5515 		un->un_density_known = 0;
5516 	}
5517 
5518 	ASSERT(mutex_owned(ST_MUTEX));
5519 	return (rval);
5520 }
5521 
5522 
5523 /*
5524  * Run a command for uscsi ioctl.
5525  * cdbspace is address space of cdb.
5526  * dataspace is address space of the uscsi data buffer.
5527  */
5528 static int
5529 st_ioctl_cmd(dev_t dev, struct uscsi_cmd *ucmd,
5530 	enum uio_seg cdbspace, enum uio_seg dataspace,
5531 	enum uio_seg rqbufspace)
5532 {
5533 	struct buf *bp;
5534 	struct uscsi_cmd *kcmd;
5535 	caddr_t kcdb;
5536 	int flag;
5537 	int err;
5538 	int rqlen;
5539 	int offline_state = 0;
5540 	char *krqbuf = NULL;
5541 
5542 	GET_SOFT_STATE(dev);
5543 
5544 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5545 	    "st_ioctl_cmd(dev = 0x%lx)\n", dev);
5546 
5547 	ASSERT(mutex_owned(ST_MUTEX));
5548 
5549 	/*
5550 	 * We really don't know what commands are coming in here and
5551 	 * we don't want to limit the commands coming in.
5552 	 *
5553 	 * If st_tape_init() gets called from st_strategy(), then we
5554 	 * will hang the process waiting for un->un_sbuf_busy to be cleared,
5555 	 * which it never will, as we set it below.  To prevent
5556 	 * st_tape_init() from getting called, we have to set state to other
5557 	 * than ST_STATE_OFFLINE, so we choose ST_STATE_INITIALIZING, which
5558 	 * achieves this purpose already
5559 	 *
5560 	 * We use offline_state to preserve the OFFLINE state, if it exists,
5561 	 * so other entry points to the driver might have the chance to call
5562 	 * st_tape_init().
5563 	 */
5564 	if (un->un_state == ST_STATE_OFFLINE) {
5565 		un->un_laststate = ST_STATE_OFFLINE;
5566 		un->un_state = ST_STATE_INITIALIZING;
5567 		offline_state = 1;
5568 	}
5569 	/*
5570 	 * Is this a request to reset the bus?
5571 	 * If so, we need go no further.
5572 	 */
5573 	if (ucmd->uscsi_flags & (USCSI_RESET|USCSI_RESET_ALL)) {
5574 		flag = ((ucmd->uscsi_flags & USCSI_RESET_ALL)) ?
5575 			RESET_ALL : RESET_TARGET;
5576 
5577 		mutex_exit(ST_MUTEX);
5578 		err = (scsi_reset(ROUTE, flag)) ? 0 : EIO;
5579 		mutex_enter(ST_MUTEX);
5580 
5581 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5582 			"reset %s %s\n",
5583 			(flag == RESET_ALL) ? "all" : "target",
5584 			(err == 0) ? "ok" : "failed");
5585 		/*
5586 		 * If scsi reset successful, don't write any filemarks.
5587 		 */
5588 		if (err == 0) {
5589 			un->un_fmneeded = 0;
5590 		} else {
5591 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5592 			    "st_ioctl_cmd : EIO : scsi_reset failed");
5593 		}
5594 		goto exit;
5595 	}
5596 
5597 	/*
5598 	 * First do some sanity checks for USCSI commands.
5599 	 */
5600 	if (ucmd->uscsi_cdblen <= 0) {
5601 		return (EINVAL);
5602 	}
5603 
5604 	/*
5605 	 * In order to not worry about where the uscsi structure
5606 	 * or cdb it points to came from, we kmem_alloc copies
5607 	 * of them here.  This will allow reference to the data
5608 	 * they contain long after this process has gone to
5609 	 * sleep and its kernel stack has been unmapped, etc.
5610 	 */
5611 
5612 	kcdb = kmem_alloc((size_t)ucmd->uscsi_cdblen, KM_SLEEP);
5613 	if (cdbspace == UIO_SYSSPACE) {
5614 		bcopy(ucmd->uscsi_cdb, kcdb, ucmd->uscsi_cdblen);
5615 	} else {
5616 		if (ddi_copyin(ucmd->uscsi_cdb, kcdb,
5617 		    (size_t)ucmd->uscsi_cdblen, 0)) {
5618 			kmem_free(kcdb, (size_t)ucmd->uscsi_cdblen);
5619 			err = EFAULT;
5620 			goto exit;
5621 		}
5622 	}
5623 
5624 	kcmd = kmem_alloc(sizeof (struct uscsi_cmd), KM_SLEEP);
5625 	bcopy(ucmd, kcmd, sizeof (struct uscsi_cmd));
5626 	kcmd->uscsi_cdb = kcdb;
5627 
5628 	flag = (kcmd->uscsi_flags & USCSI_READ) ? B_READ : B_WRITE;
5629 
5630 #ifdef STDEBUG
5631 	if (st_debug > 6) {
5632 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
5633 		    "uscsi cdb", kcdb, kcmd->uscsi_cdblen);
5634 		if (kcmd->uscsi_buflen) {
5635 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5636 			"uscsi %s of %ld bytes %s %s space\n",
5637 			(flag == B_READ) ? rd_str : wr_str,
5638 			kcmd->uscsi_buflen,
5639 			(flag == B_READ) ? "to" : "from",
5640 			(dataspace == UIO_SYSSPACE) ? "system" : "user");
5641 		}
5642 	}
5643 #endif /* ST_DEBUG */
5644 
5645 	/*
5646 	 * Initialize Request Sense buffering, if requested.
5647 	 * For user processes, allocate a kernel copy of the sense buffer
5648 	 */
5649 	if ((kcmd->uscsi_flags & USCSI_RQENABLE) &&
5650 			kcmd->uscsi_rqlen && kcmd->uscsi_rqbuf) {
5651 		if (rqbufspace == UIO_USERSPACE) {
5652 			krqbuf = kmem_alloc(SENSE_LENGTH, KM_SLEEP);
5653 		}
5654 		kcmd->uscsi_rqlen = SENSE_LENGTH;
5655 		kcmd->uscsi_rqresid = SENSE_LENGTH;
5656 	} else {
5657 		kcmd->uscsi_rqlen = 0;
5658 		kcmd->uscsi_rqresid = 0;
5659 	}
5660 
5661 	/*
5662 	 * Get buffer resources...
5663 	 */
5664 	while (un->un_sbuf_busy)
5665 		cv_wait(&un->un_sbuf_cv, ST_MUTEX);
5666 	un->un_sbuf_busy = 1;
5667 
5668 	un->un_srqbufp = krqbuf;
5669 	bp = un->un_sbufp;
5670 	bzero(bp, sizeof (buf_t));
5671 
5672 	/*
5673 	 * Force asynchronous mode, if necessary.
5674 	 */
5675 	if (ucmd->uscsi_flags & USCSI_ASYNC) {
5676 		mutex_exit(ST_MUTEX);
5677 		if (scsi_ifgetcap(ROUTE, "synchronous", 1) == 1) {
5678 			if (scsi_ifsetcap(ROUTE, "synchronous", 0, 1) == 1) {
5679 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
5680 				    "forced async ok\n");
5681 			} else {
5682 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
5683 				    "forced async failed\n");
5684 				err = EINVAL;
5685 				mutex_enter(ST_MUTEX);
5686 				goto done;
5687 			}
5688 		}
5689 		mutex_enter(ST_MUTEX);
5690 	}
5691 
5692 	/*
5693 	 * Re-enable synchronous mode, if requested
5694 	 */
5695 	if (ucmd->uscsi_flags & USCSI_SYNC) {
5696 		mutex_exit(ST_MUTEX);
5697 		if (scsi_ifgetcap(ROUTE, "synchronous", 1) == 0) {
5698 			int i = scsi_ifsetcap(ROUTE, "synchronous", 1, 1);
5699 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
5700 				"re-enabled sync %s\n",
5701 				(i == 1) ? "ok" : "failed");
5702 		}
5703 		mutex_enter(ST_MUTEX);
5704 	}
5705 
5706 	if (kcmd->uscsi_buflen) {
5707 		/*
5708 		 * We're going to do actual I/O.
5709 		 * Set things up for physio.
5710 		 */
5711 		struct iovec aiov;
5712 		struct uio auio;
5713 		struct uio *uio = &auio;
5714 
5715 		bzero(&auio, sizeof (struct uio));
5716 		bzero(&aiov, sizeof (struct iovec));
5717 		aiov.iov_base = kcmd->uscsi_bufaddr;
5718 		aiov.iov_len = kcmd->uscsi_buflen;
5719 
5720 		uio->uio_iov = &aiov;
5721 		uio->uio_iovcnt = 1;
5722 		uio->uio_resid = aiov.iov_len;
5723 		uio->uio_segflg = dataspace;
5724 
5725 		/*
5726 		 * Let physio do the rest...
5727 		 */
5728 		bp->b_forw = (struct buf *)(uintptr_t)kcdb[0];
5729 		bp->b_back = (struct buf *)kcmd;
5730 
5731 		mutex_exit(ST_MUTEX);
5732 		err = physio(st_strategy, bp, dev, flag, st_uscsi_minphys, uio);
5733 		mutex_enter(ST_MUTEX);
5734 	} else {
5735 		/*
5736 		 * Mimic physio
5737 		 */
5738 		bp->b_forw = (struct buf *)(uintptr_t)kcdb[0];
5739 		bp->b_back = (struct buf *)kcmd;
5740 		bp->b_flags = B_BUSY | flag;
5741 		bp->b_edev = dev;
5742 		bp->b_dev = cmpdev(dev);
5743 		bp->b_bcount = 0;
5744 		bp->b_blkno = 0;
5745 		bp->b_resid = 0;
5746 		mutex_exit(ST_MUTEX);
5747 		(void) st_strategy(bp);
5748 
5749 		/*
5750 		 * BugTraq #4260046
5751 		 * ----------------
5752 		 * See comments in st_cmd.
5753 		 */
5754 
5755 		err = biowait(bp);
5756 		mutex_enter(ST_MUTEX);
5757 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5758 		    "st_ioctl_cmd: biowait returns %d\n", err);
5759 	}
5760 
5761 	/*
5762 	 * Copy status from kernel copy of uscsi_cmd to user copy
5763 	 * of uscsi_cmd - this was saved in st_done_and_mutex_exit()
5764 	 */
5765 	ucmd->uscsi_status = kcmd->uscsi_status;
5766 
5767 done:
5768 	ucmd->uscsi_resid = bp->b_resid;
5769 
5770 	/*
5771 	 * Update the Request Sense status and resid
5772 	 */
5773 	rqlen = kcmd->uscsi_rqlen - kcmd->uscsi_rqresid;
5774 	rqlen = min(((int)ucmd->uscsi_rqlen), rqlen);
5775 	ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen;
5776 	ucmd->uscsi_rqstatus = kcmd->uscsi_rqstatus;
5777 	/*
5778 	 * Copy out the sense data for user processes
5779 	 */
5780 	if (ucmd->uscsi_rqbuf && rqlen && rqbufspace == UIO_USERSPACE) {
5781 		if (copyout(krqbuf, ucmd->uscsi_rqbuf, rqlen)) {
5782 			err = EFAULT;
5783 		}
5784 	}
5785 
5786 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5787 	    "st_ioctl_cmd status is 0x%x, resid is 0x%lx\n",
5788 	    ucmd->uscsi_status, ucmd->uscsi_resid);
5789 	if (DEBUGGING && (rqlen != 0)) {
5790 		int i, n, len;
5791 		char *data = krqbuf;
5792 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
5793 			"rqstatus=0x%x	rqlen=0x%x  rqresid=0x%x\n",
5794 			ucmd->uscsi_rqstatus, ucmd->uscsi_rqlen,
5795 			ucmd->uscsi_rqresid);
5796 		len = (int)ucmd->uscsi_rqlen - ucmd->uscsi_rqresid;
5797 		for (i = 0; i < len; i += 16) {
5798 			n = min(16, len-1);
5799 			st_clean_print(ST_DEVINFO, st_label, CE_NOTE,
5800 				"  ", &data[i], n);
5801 		}
5802 	}
5803 
5804 exit_free:
5805 	/*
5806 	 * Free resources
5807 	 */
5808 	un->un_sbuf_busy = 0;
5809 	un->un_srqbufp = NULL;
5810 	cv_signal(&un->un_sbuf_cv);
5811 
5812 	if (krqbuf) {
5813 		kmem_free(krqbuf, SENSE_LENGTH);
5814 	}
5815 	kmem_free(kcdb, kcmd->uscsi_cdblen);
5816 	kmem_free(kcmd, sizeof (struct uscsi_cmd));
5817 
5818 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5819 	    "st_ioctl_cmd returns 0x%x\n", err);
5820 
5821 
5822 exit:
5823 	/* don't lose offline state */
5824 	if (offline_state)
5825 		un->un_state = ST_STATE_OFFLINE;
5826 
5827 	ASSERT(mutex_owned(ST_MUTEX));
5828 	return (err);
5829 }
5830 
5831 static int
5832 st_write_fm(dev_t dev, int wfm)
5833 {
5834 	int i;
5835 
5836 	GET_SOFT_STATE(dev);
5837 
5838 	ASSERT(mutex_owned(ST_MUTEX));
5839 
5840 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5841 	    "st_write_fm(dev = 0x%lx, wfm = %d)\n", dev, wfm);
5842 
5843 	/*
5844 	 * write one filemark at the time after EOT
5845 	 */
5846 	if (un->un_eof >= ST_EOT) {
5847 		for (i = 0; i < wfm; i++) {
5848 			if (st_cmd(dev, SCMD_WRITE_FILE_MARK, 1, SYNC_CMD)) {
5849 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5850 				    "st_write_fm : EIO : write EOT file mark");
5851 				return (EIO);
5852 			}
5853 		}
5854 	} else if (st_cmd(dev, SCMD_WRITE_FILE_MARK, wfm, SYNC_CMD)) {
5855 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5856 		    "st_write_fm : EIO : write file mark");
5857 		return (EIO);
5858 	}
5859 
5860 	ASSERT(mutex_owned(ST_MUTEX));
5861 	return (0);
5862 }
5863 
5864 #ifdef STDEBUG
5865 static void
5866 start_dump(struct scsi_tape *un, struct buf *bp)
5867 {
5868 	struct scsi_pkt *pkt = BP_PKT(bp);
5869 	uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp;
5870 
5871 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5872 	    "st_start: cmd=0x%p count=%ld resid=%ld flags=0x%x pkt=0x%p\n",
5873 	    (void *)bp->b_forw, bp->b_bcount,
5874 	    bp->b_resid, bp->b_flags, (void *)BP_PKT(bp));
5875 
5876 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5877 	    "st_start: cdb %x %x %x %x %x %x, fileno=%d, blk=%ld\n",
5878 	    cdbp[0], cdbp[1], cdbp[2],
5879 	    cdbp[3], cdbp[4], cdbp[5], un->un_fileno,
5880 	    un->un_blkno);
5881 }
5882 #endif
5883 
5884 
5885 /*
5886  * Command start && done functions
5887  */
5888 
5889 /*
5890  * st_start()
5891  *
5892  * Called from:
5893  *  st_strategy() to start a command.
5894  *  st_runout() to retry when scsi_pkt allocation fails on previous attempt(s).
5895  *  st_attach() when resuming from power down state.
5896  *  st_start_restart() to retry transport when device was previously busy.
5897  *  st_done_and_mutex_exit() to start the next command when previous is done.
5898  *
5899  * On entry:
5900  *  scsi_pkt may or may not be allocated.
5901  *
5902  */
5903 static void
5904 st_start(struct scsi_tape *un)
5905 {
5906 	struct buf *bp;
5907 	int status;
5908 
5909 	ASSERT(mutex_owned(ST_MUTEX));
5910 
5911 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5912 	    "st_start(): dev = 0x%lx\n", un->un_dev);
5913 
5914 	if ((bp = un->un_quef) == NULL) {
5915 		return;
5916 	}
5917 
5918 	ASSERT((bp->b_flags & B_DONE) == 0);
5919 
5920 	/*
5921 	 * Don't send more than un_throttle commands to the HBA
5922 	 */
5923 	if ((un->un_throttle <= 0) || (un->un_ncmds >= un->un_throttle)) {
5924 		return;
5925 	}
5926 
5927 	/*
5928 	 * If the buf has no scsi_pkt call st_make_cmd() to get one and
5929 	 * build the command.
5930 	 */
5931 	if (BP_PKT(bp) == NULL) {
5932 		ASSERT((bp->b_flags & B_DONE) == 0);
5933 		st_make_cmd(un, bp, st_runout);
5934 		ASSERT((bp->b_flags & B_DONE) == 0);
5935 		status = geterror(bp);
5936 
5937 		/*
5938 		 * Some HBA's don't call bioerror() to set an error.
5939 		 * And geterror() returns zero if B_ERROR is not set.
5940 		 * So if we get zero we must check b_error.
5941 		 */
5942 		if (status == 0 && bp->b_error != 0) {
5943 			status = bp->b_error;
5944 			bioerror(bp, status);
5945 		}
5946 
5947 		/*
5948 		 * Some HBA's convert DDI_DMA_NORESOURCES into ENOMEM.
5949 		 * In tape ENOMEM has special meaning so we'll change it.
5950 		 */
5951 		if (status == ENOMEM) {
5952 			status = 0;
5953 			bioerror(bp, status);
5954 		}
5955 
5956 		/*
5957 		 * Did it fail and is it retryable?
5958 		 * If so return and wait for the callback through st_runout.
5959 		 * Also looks like scsi_init_pkt() will setup a callback even
5960 		 * if it isn't retryable.
5961 		 */
5962 		if (BP_PKT(bp) == NULL) {
5963 			if (status == 0) {
5964 				/*
5965 				 * If first attempt save state.
5966 				 */
5967 				if (un->un_state != ST_STATE_RESOURCE_WAIT) {
5968 					un->un_laststate = un->un_state;
5969 					un->un_state = ST_STATE_RESOURCE_WAIT;
5970 				}
5971 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5972 				    "temp no resources for pkt\n");
5973 			} else {
5974 				/*
5975 				 * Unlikely that it would be retryable then not.
5976 				 */
5977 				if (un->un_state == ST_STATE_RESOURCE_WAIT) {
5978 					un->un_state = un->un_laststate;
5979 				}
5980 				scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
5981 				    "perm no resources for pkt errno = 0x%x\n",
5982 				    status);
5983 			}
5984 			return;
5985 		}
5986 		/*
5987 		 * Worked this time set the state back.
5988 		 */
5989 		if (un->un_state == ST_STATE_RESOURCE_WAIT) {
5990 			un->un_state = un->un_laststate;
5991 		}
5992 	}
5993 
5994 	/*
5995 	 * move from waitq to runq
5996 	 */
5997 	un->un_quef = bp->b_actf;
5998 	if (un->un_quel == bp) {
5999 		/*
6000 		 *  For the case of queue having one
6001 		 *  element, set the tail pointer to
6002 		 *  point to the element.
6003 		 */
6004 		un->un_quel = bp->b_actf;
6005 	}
6006 
6007 	bp->b_actf = NULL;
6008 
6009 	if (un->un_runqf) {
6010 		un->un_runql->b_actf = bp;
6011 	} else {
6012 		un->un_runqf = bp;
6013 	}
6014 	un->un_runql = bp;
6015 
6016 
6017 #ifdef STDEBUG
6018 	start_dump(un, bp);
6019 #endif
6020 
6021 	/* could not get here if throttle was zero */
6022 	un->un_last_throttle = un->un_throttle;
6023 	un->un_throttle = 0;	/* so nothing else will come in here */
6024 	un->un_ncmds++;
6025 
6026 	ST_DO_KSTATS(bp, kstat_waitq_to_runq);
6027 
6028 	mutex_exit(ST_MUTEX);
6029 
6030 	status = scsi_transport(BP_PKT(bp));
6031 
6032 	mutex_enter(ST_MUTEX);
6033 
6034 	if (un->un_last_throttle) {
6035 		un->un_throttle = un->un_last_throttle;
6036 	}
6037 
6038 	if (status != TRAN_ACCEPT) {
6039 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
6040 		mutex_exit(ST_MUTEX);
6041 
6042 		if (status == TRAN_BUSY) {
6043 			/* if too many retries, fail the transport */
6044 			if (st_handle_start_busy(un, bp,
6045 			    ST_TRAN_BUSY_TIMEOUT) == 0)
6046 				goto done;
6047 		}
6048 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
6049 		    "transport rejected\n");
6050 		bp->b_resid = bp->b_bcount;
6051 
6052 
6053 #ifndef __lock_lint
6054 		/*
6055 		 * warlock doesn't understand this potential
6056 		 * recursion?
6057 		 */
6058 		mutex_enter(ST_MUTEX);
6059 		ST_DO_KSTATS(bp, kstat_waitq_exit);
6060 		ST_DO_ERRSTATS(un, st_transerrs);
6061 		st_bioerror(bp, EIO);
6062 		SET_PE_FLAG(un);
6063 		st_done_and_mutex_exit(un, bp);
6064 #endif
6065 	} else {
6066 		un->un_tran_retry_ct = 0;
6067 		mutex_exit(ST_MUTEX);
6068 	}
6069 
6070 done:
6071 
6072 	mutex_enter(ST_MUTEX);
6073 }
6074 
6075 /*
6076  * if the transport is busy, then put this bp back on the waitq
6077  */
6078 static int
6079 st_handle_start_busy(struct scsi_tape *un, struct buf *bp,
6080     clock_t timeout_interval)
6081 {
6082 	struct buf *last_quef, *runq_bp;
6083 	int rval = 0;
6084 
6085 	mutex_enter(ST_MUTEX);
6086 
6087 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6088 	    "st_handle_start_busy()\n");
6089 
6090 	/*
6091 	 * Check to see if we hit the retry timeout and one last check for
6092 	 * making sure this is the last on the runq, if it is not, we have
6093 	 * to fail
6094 	 */
6095 	if (((int)un->un_tran_retry_ct++ > st_retry_count) ||
6096 	    (un->un_runql != bp)) {
6097 		rval = -1;
6098 		goto exit;
6099 	}
6100 
6101 	/* put the bp back on the waitq */
6102 	if (un->un_quef) {
6103 		last_quef = un->un_quef;
6104 		un->un_quef = bp;
6105 		bp->b_actf = last_quef;
6106 	} else  {
6107 		bp->b_actf = NULL;
6108 		un->un_quef = bp;
6109 		un->un_quel = bp;
6110 	}
6111 
6112 	/*
6113 	 * Decrement un_ncmds so that this
6114 	 * gets thru' st_start() again.
6115 	 */
6116 	un->un_ncmds--;
6117 
6118 	/*
6119 	 * since this is an error case, we won't have to do
6120 	 * this list walking much.  We've already made sure this bp was the
6121 	 * last on the runq
6122 	 */
6123 	runq_bp = un->un_runqf;
6124 
6125 	if (un->un_runqf == bp) {
6126 		un->un_runqf = NULL;
6127 		un->un_runql = NULL;
6128 	} else {
6129 		while (runq_bp) {
6130 			if (runq_bp->b_actf == bp) {
6131 				runq_bp->b_actf = NULL;
6132 				un->un_runql = runq_bp;
6133 				break;
6134 			}
6135 			runq_bp = runq_bp->b_actf;
6136 		}
6137 	}
6138 
6139 
6140 	/*
6141 	 * send a marker pkt, if appropriate
6142 	 */
6143 	st_hba_unflush(un);
6144 
6145 	/*
6146 	 * all queues are aligned, we are just waiting to
6147 	 * transport, don't alloc any more buf p's, when
6148 	 * st_start is reentered.
6149 	 */
6150 	(void) timeout(st_start_restart, un, timeout_interval);
6151 
6152 exit:
6153 	mutex_exit(ST_MUTEX);
6154 	return (rval);
6155 }
6156 
6157 
6158 
6159 /*
6160  * st_runout a callback that is called what a resource allocatation failed
6161  */
6162 static int
6163 st_runout(caddr_t arg)
6164 {
6165 	struct scsi_tape *un = (struct scsi_tape *)arg;
6166 	struct buf *bp;
6167 
6168 	ASSERT(un != NULL);
6169 
6170 	mutex_enter(ST_MUTEX);
6171 
6172 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_runout()\n");
6173 
6174 	bp = un->un_quef;
6175 
6176 	/*
6177 	 * failed scsi_init_pkt(). If errno is zero its retryable.
6178 	 */
6179 	if ((bp != NULL) && (geterror(bp) != 0)) {
6180 
6181 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
6182 		    "errors after pkt alloc (b_flags=0x%x, b_error=0x%x)\n",
6183 		    bp->b_flags, geterror(bp));
6184 		ASSERT((bp->b_flags & B_DONE) == 0);
6185 
6186 		un->un_quef = bp->b_actf;
6187 		if (un->un_quel == bp) {
6188 			/*
6189 			 *  For the case of queue having one
6190 			 *  element, set the tail pointer to
6191 			 *  point to the element.
6192 			 */
6193 			un->un_quel = bp->b_actf;
6194 		}
6195 		bp->b_actf = NULL;
6196 
6197 		ASSERT((bp->b_flags & B_DONE) == 0);
6198 
6199 		/*
6200 		 * Set resid, Error already set, then unblock calling thread.
6201 		 */
6202 		bp->b_resid = bp->b_bcount;
6203 		biodone(bp);
6204 	} else {
6205 		/*
6206 		 * Try Again
6207 		 */
6208 		st_start(un);
6209 	}
6210 
6211 	mutex_exit(ST_MUTEX);
6212 
6213 	/*
6214 	 * Comments courtesy of sd.c
6215 	 * The scsi_init_pkt routine allows for the callback function to
6216 	 * return a 0 indicating the callback should be rescheduled or a 1
6217 	 * indicating not to reschedule. This routine always returns 1
6218 	 * because the driver always provides a callback function to
6219 	 * scsi_init_pkt. This results in a callback always being scheduled
6220 	 * (via the scsi_init_pkt callback implementation) if a resource
6221 	 * failure occurs.
6222 	 */
6223 
6224 	return (1);
6225 }
6226 
6227 /*
6228  * st_done_and_mutex_exit()
6229  *	- remove bp from runq
6230  *	- start up the next request
6231  *	- if this was an asynch bp, clean up
6232  *	- exit with released mutex
6233  */
6234 static void
6235 st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp)
6236 {
6237 	struct buf *runqbp, *prevbp;
6238 	int	pe_flagged = 0;
6239 
6240 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
6241 #if !defined(lint)
6242 	_NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex))
6243 #endif
6244 	ASSERT(mutex_owned(ST_MUTEX));
6245 
6246 	/*
6247 	 * if bp is still on the runq (anywhere), then remove it
6248 	 */
6249 	prevbp = NULL;
6250 	for (runqbp = un->un_runqf; runqbp != 0; runqbp = runqbp->b_actf) {
6251 		if (runqbp == bp) {
6252 			if (runqbp == un->un_runqf) {
6253 				un->un_runqf = bp->b_actf;
6254 			} else {
6255 				prevbp->b_actf = bp->b_actf;
6256 			}
6257 			if (un->un_runql == bp) {
6258 				un->un_runql = prevbp;
6259 			}
6260 			break;
6261 		}
6262 		prevbp = runqbp;
6263 	}
6264 	bp->b_actf = NULL;
6265 
6266 	un->un_ncmds--;
6267 	cv_signal(&un->un_queue_cv);
6268 
6269 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6270 	"st_done_and_mutex_exit(): cmd=0x%x count=%ld resid=%ld  flags=0x%x\n",
6271 		(int)*((caddr_t)(BP_PKT(bp))->pkt_cdbp),
6272 		bp->b_bcount, bp->b_resid, bp->b_flags);
6273 
6274 
6275 	/*
6276 	 * update kstats with transfer count info
6277 	 */
6278 	if (un->un_stats && (bp != un->un_sbufp) && IS_RW(bp)) {
6279 		uint32_t n_done =  bp->b_bcount - bp->b_resid;
6280 		if (bp->b_flags & B_READ) {
6281 			IOSP->reads++;
6282 			IOSP->nread += n_done;
6283 		} else {
6284 			IOSP->writes++;
6285 			IOSP->nwritten += n_done;
6286 		}
6287 	}
6288 
6289 	/*
6290 	 * Start the next one before releasing resources on this one, if
6291 	 * there is something on the queue and persistent errors has not been
6292 	 * flagged
6293 	 */
6294 
6295 	if ((pe_flagged = IS_PE_FLAG_SET(un)) != 0) {
6296 		un->un_last_resid = bp->b_resid;
6297 		un->un_last_count = bp->b_bcount;
6298 	}
6299 
6300 	if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
6301 		cv_broadcast(&un->un_tape_busy_cv);
6302 	} else if (un->un_quef && un->un_throttle && !pe_flagged) {
6303 		st_start(un);
6304 	}
6305 
6306 	if (bp == un->un_sbufp && (bp->b_flags & B_ASYNC)) {
6307 		/*
6308 		 * Since we marked this ourselves as ASYNC,
6309 		 * there isn't anybody around waiting for
6310 		 * completion any more.
6311 		 */
6312 		uchar_t com = (uchar_t)(uintptr_t)bp->b_forw;
6313 		if (com == SCMD_READ || com == SCMD_WRITE) {
6314 			bp->b_un.b_addr = (caddr_t)0;
6315 		}
6316 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6317 		    "st_done_and_mutex_exit(async): freeing pkt\n");
6318 		scsi_destroy_pkt(BP_PKT(bp));
6319 		un->un_sbuf_busy = 0;
6320 		cv_signal(&un->un_sbuf_cv);
6321 		mutex_exit(ST_MUTEX);
6322 		return;
6323 	}
6324 
6325 	if (bp == un->un_sbufp && BP_UCMD(bp)) {
6326 		/*
6327 		 * Copy status from scsi_pkt to uscsi_cmd
6328 		 * since st_ioctl_cmd needs it
6329 		 */
6330 		BP_UCMD(bp)->uscsi_status = SCBP_C(BP_PKT(bp));
6331 	}
6332 
6333 
6334 #ifdef STDEBUG
6335 	if ((st_debug >= 4) &&
6336 	    (((un->un_blkno % 100) == 0) || IS_PE_FLAG_SET(un))) {
6337 
6338 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6339 		    "st_d_a_m_exit(): ncmds = %d, thr = %d, "
6340 		    "un_errno = %d, un_pe = %d\n",
6341 		    un->un_ncmds, un->un_throttle, un->un_errno,
6342 		    un->un_persist_errors);
6343 	}
6344 
6345 #endif
6346 
6347 	mutex_exit(ST_MUTEX);
6348 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6349 	    "st_done_and_mutex_exit: freeing pkt\n");
6350 
6351 	scsi_destroy_pkt(BP_PKT(bp));
6352 
6353 	biodone(bp);
6354 
6355 	/*
6356 	 * now that we biodoned that command, if persistent errors have been
6357 	 * flagged, flush the waitq
6358 	 */
6359 	if (pe_flagged)
6360 		st_flush(un);
6361 }
6362 
6363 
6364 /*
6365  * Tape error, flush tape driver queue.
6366  */
6367 static void
6368 st_flush(struct scsi_tape *un)
6369 {
6370 	struct buf *bp;
6371 
6372 	mutex_enter(ST_MUTEX);
6373 
6374 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6375 	    "st_flush(), ncmds = %d, quef = 0x%p\n",
6376 	    un->un_ncmds, (void *)un->un_quef);
6377 
6378 	/*
6379 	 * if we still have commands outstanding, wait for them to come in
6380 	 * before flushing the queue, and make sure there is a queue
6381 	 */
6382 	if (un->un_ncmds || !un->un_quef)
6383 		goto exit;
6384 
6385 	/*
6386 	 * we have no more commands outstanding, so let's deal with special
6387 	 * cases in the queue for EOM and FM. If we are here, and un_errno
6388 	 * is 0, then we know there was no error and we return a 0 read or
6389 	 * write before showing errors
6390 	 */
6391 
6392 	/* Flush the wait queue. */
6393 	while ((bp = un->un_quef) != NULL) {
6394 		un->un_quef = bp->b_actf;
6395 
6396 		bp->b_resid = bp->b_bcount;
6397 
6398 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6399 		    "st_flush() : blkno=%ld, err=%d, b_bcount=%ld\n",
6400 		    un->un_blkno, un->un_errno, bp->b_bcount);
6401 
6402 		st_set_pe_errno(un);
6403 
6404 		bioerror(bp, un->un_errno);
6405 
6406 		mutex_exit(ST_MUTEX);
6407 		/* it should have one, but check anyway */
6408 		if (BP_PKT(bp)) {
6409 			scsi_destroy_pkt(BP_PKT(bp));
6410 		}
6411 		biodone(bp);
6412 		mutex_enter(ST_MUTEX);
6413 	}
6414 
6415 	/*
6416 	 * It's not a bad practice to reset the
6417 	 * waitq tail pointer to NULL.
6418 	 */
6419 	un->un_quel = NULL;
6420 
6421 exit:
6422 	/* we mucked with the queue, so let others know about it */
6423 	cv_signal(&un->un_queue_cv);
6424 	mutex_exit(ST_MUTEX);
6425 }
6426 
6427 
6428 /*
6429  * Utility functions
6430  */
6431 static int
6432 st_determine_generic(dev_t dev)
6433 {
6434 	int bsize;
6435 	static char *cart = "0.25 inch cartridge";
6436 	char *sizestr;
6437 
6438 	GET_SOFT_STATE(dev);
6439 
6440 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6441 	    "st_determine_generic(dev = 0x%lx)\n", dev);
6442 
6443 	ASSERT(mutex_owned(ST_MUTEX));
6444 
6445 	if (st_modesense(un)) {
6446 		return (-1);
6447 	}
6448 
6449 	bsize = (un->un_mspl->high_bl << 16)	|
6450 		(un->un_mspl->mid_bl << 8)	|
6451 		(un->un_mspl->low_bl);
6452 
6453 	if (bsize == 0) {
6454 		un->un_dp->options |= ST_VARIABLE;
6455 		un->un_dp->bsize = 0;
6456 		un->un_bsize = 0;
6457 	} else if (bsize > ST_MAXRECSIZE_FIXED) {
6458 		/*
6459 		 * record size of this device too big.
6460 		 * try and convert it to variable record length.
6461 		 *
6462 		 */
6463 		un->un_dp->options |= ST_VARIABLE;
6464 		if (st_change_block_size(dev, 0) != 0) {
6465 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
6466 			    "Fixed Record Size %d is too large\n", bsize);
6467 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
6468 			    "Cannot switch to variable record size\n");
6469 			un->un_dp->options &= ~ST_VARIABLE;
6470 			return (-1);
6471 		}
6472 	} else if (st_change_block_size(dev, 0) == 0) {
6473 		/*
6474 		 * If the drive was set to a non zero block size,
6475 		 * See if it can be set to a zero block size.
6476 		 * If it works, ST_VARIABLE so user can set it as they want.
6477 		 */
6478 		un->un_dp->options |= ST_VARIABLE;
6479 		un->un_dp->bsize = 0;
6480 		un->un_bsize = 0;
6481 	} else {
6482 		un->un_dp->bsize = bsize;
6483 		un->un_bsize = bsize;
6484 	}
6485 
6486 
6487 	switch (un->un_mspl->density) {
6488 	default:
6489 	case 0x0:
6490 		/*
6491 		 * default density, cannot determine any other
6492 		 * information.
6493 		 */
6494 		sizestr = "Unknown type- assuming 0.25 inch cartridge";
6495 		un->un_dp->type = ST_TYPE_DEFAULT;
6496 		un->un_dp->options |= (ST_AUTODEN_OVERRIDE|ST_QIC);
6497 		break;
6498 	case 0x1:
6499 	case 0x2:
6500 	case 0x3:
6501 	case 0x6:
6502 		/*
6503 		 * 1/2" reel
6504 		 */
6505 		sizestr = "0.50 inch reel";
6506 		un->un_dp->type = ST_TYPE_REEL;
6507 		un->un_dp->options |= ST_REEL;
6508 		un->un_dp->densities[0] = 0x1;
6509 		un->un_dp->densities[1] = 0x2;
6510 		un->un_dp->densities[2] = 0x6;
6511 		un->un_dp->densities[3] = 0x3;
6512 		break;
6513 	case 0x4:
6514 	case 0x5:
6515 	case 0x7:
6516 	case 0x0b:
6517 
6518 		/*
6519 		 * Quarter inch.
6520 		 */
6521 		sizestr = cart;
6522 		un->un_dp->type = ST_TYPE_DEFAULT;
6523 		un->un_dp->options |= ST_QIC;
6524 
6525 		un->un_dp->densities[1] = 0x4;
6526 		un->un_dp->densities[2] = 0x5;
6527 		un->un_dp->densities[3] = 0x7;
6528 		un->un_dp->densities[0] = 0x0b;
6529 		break;
6530 
6531 	case 0x0f:
6532 	case 0x10:
6533 	case 0x11:
6534 	case 0x12:
6535 		/*
6536 		 * QIC-120, QIC-150, QIC-320, QIC-600
6537 		 */
6538 		sizestr = cart;
6539 		un->un_dp->type = ST_TYPE_DEFAULT;
6540 		un->un_dp->options |= ST_QIC;
6541 		un->un_dp->densities[0] = 0x0f;
6542 		un->un_dp->densities[1] = 0x10;
6543 		un->un_dp->densities[2] = 0x11;
6544 		un->un_dp->densities[3] = 0x12;
6545 		break;
6546 
6547 	case 0x09:
6548 	case 0x0a:
6549 	case 0x0c:
6550 	case 0x0d:
6551 		/*
6552 		 * 1/2" cartridge tapes. Include HI-TC.
6553 		 */
6554 		sizestr = cart;
6555 		sizestr[2] = '5';
6556 		sizestr[3] = '0';
6557 		un->un_dp->type = ST_TYPE_HIC;
6558 		un->un_dp->densities[0] = 0x09;
6559 		un->un_dp->densities[1] = 0x0a;
6560 		un->un_dp->densities[2] = 0x0c;
6561 		un->un_dp->densities[3] = 0x0d;
6562 		break;
6563 
6564 	case 0x13:
6565 			/* DDS-2/DDS-3 scsi spec densities */
6566 	case 0x24:
6567 	case 0x25:
6568 	case 0x26:
6569 		sizestr = "DAT Data Storage (DDS)";
6570 		un->un_dp->type = ST_TYPE_DAT;
6571 		un->un_dp->options |= ST_AUTODEN_OVERRIDE;
6572 		break;
6573 
6574 	case 0x14:
6575 		/*
6576 		 * Helical Scan (Exabyte) devices
6577 		 */
6578 		sizestr = "8mm helical scan cartridge";
6579 		un->un_dp->type = ST_TYPE_EXABYTE;
6580 		un->un_dp->options |= ST_AUTODEN_OVERRIDE;
6581 		break;
6582 	}
6583 
6584 	/*
6585 	 * Assume LONG ERASE, BSF and BSR
6586 	 */
6587 
6588 	un->un_dp->options |= (ST_LONG_ERASE|ST_UNLOADABLE|ST_BSF|
6589 				ST_BSR|ST_KNOWS_EOD);
6590 
6591 	/*
6592 	 * Only if mode sense data says no buffered write, set NOBUF
6593 	 */
6594 	if (un->un_mspl->bufm == 0)
6595 		un->un_dp->options |= ST_NOBUF;
6596 
6597 	/*
6598 	 * set up large read and write retry counts
6599 	 */
6600 
6601 	un->un_dp->max_rretries = un->un_dp->max_wretries = 1000;
6602 
6603 	/*
6604 	 * If this is a 0.50 inch reel tape, and
6605 	 * it is *not* variable mode, try and
6606 	 * set it to variable record length
6607 	 * mode.
6608 	 */
6609 	if ((un->un_dp->options & ST_REEL) && un->un_bsize != 0 &&
6610 	    (un->un_dp->options & ST_VARIABLE)) {
6611 		if (st_change_block_size(dev, 0) == 0) {
6612 			un->un_dp->bsize = 0;
6613 			un->un_mspl->high_bl = un->un_mspl->mid_bl =
6614 			    un->un_mspl->low_bl = 0;
6615 		}
6616 	}
6617 
6618 	/*
6619 	 * Write to console about type of device found
6620 	 */
6621 	ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
6622 	    "Generic Drive, Vendor=%s\n\t%s", un->un_dp->name,
6623 	    sizestr);
6624 	if (un->un_dp->options & ST_VARIABLE) {
6625 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
6626 		    "!Variable record length I/O\n");
6627 	} else {
6628 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
6629 		    "!Fixed record length (%d byte blocks) I/O\n",
6630 		    un->un_dp->bsize);
6631 	}
6632 	ASSERT(mutex_owned(ST_MUTEX));
6633 	return (0);
6634 }
6635 
6636 static int
6637 st_determine_density(dev_t dev, int rw)
6638 {
6639 	int rval = 0;
6640 
6641 	GET_SOFT_STATE(dev);
6642 
6643 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6644 	    "st_determine_density(dev = 0x%lx, rw = %s)\n",
6645 	    dev, (rw == B_WRITE ? wr_str: rd_str));
6646 
6647 	ASSERT(mutex_owned(ST_MUTEX));
6648 
6649 	/*
6650 	 * If we're past BOT, density is determined already.
6651 	 */
6652 	if (un->un_fileno > 0 || (un->un_fileno == 0 && un->un_blkno != 0)) {
6653 		/*
6654 		 * XXX: put in a bitch message about attempting to
6655 		 * XXX: change density past BOT.
6656 		 */
6657 		goto exit;
6658 	}
6659 
6660 	/*
6661 	 * If we're going to be writing, we set the density
6662 	 */
6663 	if (rw == 0 || rw == B_WRITE) {
6664 		/* un_curdens is used as an index into densities table */
6665 		un->un_curdens = MT_DENSITY(un->un_dev);
6666 		if (st_set_density(dev)) {
6667 			rval = -1;
6668 		}
6669 		goto exit;
6670 	}
6671 
6672 	/*
6673 	 * If density is known already,
6674 	 * we don't have to get it again.(?)
6675 	 */
6676 	if (!un->un_density_known) {
6677 		if (st_get_density(dev)) {
6678 			rval = -1;
6679 		}
6680 	}
6681 
6682 exit:
6683 	ASSERT(mutex_owned(ST_MUTEX));
6684 	return (rval);
6685 }
6686 
6687 
6688 /*
6689  * Try to determine density. We do this by attempting to read the
6690  * first record off the tape, cycling through the available density
6691  * codes as we go.
6692  */
6693 
6694 static int
6695 st_get_density(dev_t dev)
6696 {
6697 	int succes = 0, rval = -1, i;
6698 	uint_t size;
6699 	uchar_t dens, olddens;
6700 
6701 	GET_SOFT_STATE(dev);
6702 
6703 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6704 	    "st_get_density(dev = 0x%lx)\n", dev);
6705 
6706 	ASSERT(mutex_owned(ST_MUTEX));
6707 
6708 	/*
6709 	 * If Auto Density override is enabled The drive has
6710 	 * only one density and there is no point in attempting
6711 	 * find the correct one.
6712 	 *
6713 	 * Since most modern drives auto detect the density
6714 	 * and format of the recorded media before they come
6715 	 * ready. What this function does is a legacy behavior
6716 	 * and modern drives not only don't need it, The backup
6717 	 * utilities that do positioning via uscsi find the un-
6718 	 * expected rewinds problematic.
6719 	 *
6720 	 * The drives that need this are old reel to reel devices.
6721 	 * I took a swag and said they must be scsi-1 or older.
6722 	 * I don't beleave there will any of the newer devices
6723 	 * that need this. There will be some scsi-1 devices that
6724 	 * don't need this but I don't think they will be using the
6725 	 * BIG aftermarket backup and restore utilitys.
6726 	 */
6727 	if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) ||
6728 	    (un->un_sd->sd_inq->inq_ansi > 1)) {
6729 		un->un_density_known = 1;
6730 		rval = 0;
6731 		goto exit;
6732 	}
6733 
6734 	/*
6735 	 * This will only work on variable record length tapes
6736 	 * if and only if all variable record length tapes autodensity
6737 	 * select.
6738 	 */
6739 	size = (unsigned)(un->un_dp->bsize ? un->un_dp->bsize : SECSIZE);
6740 	un->un_tmpbuf = kmem_alloc(size, KM_SLEEP);
6741 
6742 	/*
6743 	 * Start at the specified density
6744 	 */
6745 
6746 	dens = olddens = un->un_curdens = MT_DENSITY(un->un_dev);
6747 
6748 	for (i = 0; i < NDENSITIES; i++, ((un->un_curdens == NDENSITIES - 1) ?
6749 					(un->un_curdens = 0) :
6750 					(un->un_curdens += 1))) {
6751 		/*
6752 		 * If we've done this density before,
6753 		 * don't bother to do it again.
6754 		 */
6755 		dens = un->un_dp->densities[un->un_curdens];
6756 		if (i > 0 && dens == olddens)
6757 			continue;
6758 		olddens = dens;
6759 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6760 		    "trying density 0x%x\n", dens);
6761 		if (st_set_density(dev)) {
6762 			continue;
6763 		}
6764 
6765 		/*
6766 		 * XXX - the creates lots of headaches and slowdowns - must
6767 		 * fix.
6768 		 */
6769 		succes = (st_cmd(dev, SCMD_READ, (int)size, SYNC_CMD) == 0);
6770 		if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
6771 			break;
6772 		}
6773 		if (succes) {
6774 			st_init(un);
6775 			rval = 0;
6776 			un->un_density_known = 1;
6777 			break;
6778 		}
6779 	}
6780 	kmem_free(un->un_tmpbuf, size);
6781 	un->un_tmpbuf = 0;
6782 
6783 exit:
6784 	ASSERT(mutex_owned(ST_MUTEX));
6785 	return (rval);
6786 }
6787 
6788 static int
6789 st_set_density(dev_t dev)
6790 {
6791 	int rval = 0;
6792 
6793 	GET_SOFT_STATE(dev);
6794 
6795 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6796 	    "st_set_density(dev = 0x%lx): density = 0x%x\n", dev,
6797 	    un->un_dp->densities[un->un_curdens]);
6798 
6799 	ASSERT(mutex_owned(ST_MUTEX));
6800 
6801 	un->un_mspl->density = un->un_dp->densities[un->un_curdens];
6802 
6803 	if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) == 0) {
6804 		/*
6805 		 * If auto density override is not set, Use mode select
6806 		 * to set density and compression.
6807 		 */
6808 		if (st_modeselect(un)) {
6809 			rval = -1;
6810 		}
6811 	} else if ((un->un_dp->options & ST_MODE_SEL_COMP) != 0) {
6812 		/*
6813 		 * If auto density and mode select compression are set,
6814 		 * This is a drive with one density code but compression
6815 		 * can be enabled or disabled.
6816 		 * Set compression but no need to set density.
6817 		 */
6818 		rval = st_set_compression(un);
6819 		if ((rval != 0) && (rval != EALREADY)) {
6820 			rval = -1;
6821 		} else {
6822 			rval = 0;
6823 		}
6824 	}
6825 
6826 	/* If sucessful set density and/or compression, mark density known */
6827 	if (rval == 0) {
6828 		un->un_density_known = 1;
6829 	}
6830 
6831 	ASSERT(mutex_owned(ST_MUTEX));
6832 	return (rval);
6833 }
6834 
6835 static int
6836 st_loadtape(dev_t dev)
6837 {
6838 	int rval = 0;
6839 
6840 	GET_SOFT_STATE(dev);
6841 
6842 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6843 	    "st_loadtape(dev = 0x%lx)\n", dev);
6844 
6845 	ASSERT(mutex_owned(ST_MUTEX));
6846 
6847 	/*
6848 	 * 'LOAD' the tape to BOT by rewinding
6849 	 */
6850 	if (st_cmd(dev, SCMD_REWIND, 1, SYNC_CMD)) {
6851 		rval = -1;
6852 	} else {
6853 		st_init(un);
6854 		un->un_density_known = 0;
6855 	}
6856 
6857 	ASSERT(mutex_owned(ST_MUTEX));
6858 	return (rval);
6859 }
6860 
6861 
6862 /*
6863  * Note: QIC devices aren't so smart.  If you try to append
6864  * after EOM, the write can fail because the device doesn't know
6865  * it's at EOM.	 In that case, issue a read.  The read should fail
6866  * because there's no data, but the device knows it's at EOM,
6867  * so a subsequent write should succeed.  To further confuse matters,
6868  * the target returns the same error if the tape is positioned
6869  * such that a write would overwrite existing data.  That's why
6870  * we have to do the append test.  A read in the middle of
6871  * recorded data would succeed, thus indicating we're attempting
6872  * something illegal.
6873  */
6874 
6875 void bp_mapin(struct buf *bp);
6876 
6877 static void
6878 st_test_append(struct buf *bp)
6879 {
6880 	dev_t dev = bp->b_edev;
6881 	struct scsi_tape *un;
6882 	uchar_t status;
6883 	unsigned bcount;
6884 
6885 	un = ddi_get_soft_state(st_state, MTUNIT(dev));
6886 
6887 	ASSERT(mutex_owned(ST_MUTEX));
6888 
6889 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6890 	    "st_test_append(): fileno %d\n", un->un_fileno);
6891 
6892 	un->un_laststate = un->un_state;
6893 	un->un_state = ST_STATE_APPEND_TESTING;
6894 	un->un_test_append = 0;
6895 
6896 	/*
6897 	 * first, map in the buffer, because we're doing a double write --
6898 	 * first into the kernel, then onto the tape.
6899 	 */
6900 	bp_mapin(bp);
6901 
6902 	/*
6903 	 * get a copy of the data....
6904 	 */
6905 	un->un_tmpbuf = kmem_alloc((unsigned)bp->b_bcount, KM_SLEEP);
6906 	bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount);
6907 
6908 	/*
6909 	 * attempt the write..
6910 	 */
6911 
6912 	if (st_cmd(dev, (int)SCMD_WRITE, (int)bp->b_bcount, SYNC_CMD) == 0) {
6913 success:
6914 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6915 		    "append write succeeded\n");
6916 		bp->b_resid = un->un_sbufp->b_resid;
6917 		mutex_exit(ST_MUTEX);
6918 		bcount = (unsigned)bp->b_bcount;
6919 		biodone(bp);
6920 		mutex_enter(ST_MUTEX);
6921 		un->un_laststate = un->un_state;
6922 		un->un_state = ST_STATE_OPEN;
6923 		kmem_free(un->un_tmpbuf, bcount);
6924 		un->un_tmpbuf = NULL;
6925 		return;
6926 	}
6927 
6928 	/*
6929 	 * The append failed. Do a short read. If that fails,  we are at EOM
6930 	 * so we can retry the write command. If that succeeds, than we're
6931 	 * all screwed up (the controller reported a real error).
6932 	 *
6933 	 * XXX: should the dummy read be > SECSIZE? should it be the device's
6934 	 * XXX: block size?
6935 	 *
6936 	 */
6937 	status = un->un_status;
6938 	un->un_status = 0;
6939 	(void) st_cmd(dev, SCMD_READ, SECSIZE, SYNC_CMD);
6940 	if (un->un_status == KEY_BLANK_CHECK) {
6941 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6942 		    "append at EOM\n");
6943 		/*
6944 		 * Okay- the read failed. We should actually have confused
6945 		 * the controller enough to allow writing. In any case, the
6946 		 * i/o is on its own from here on out.
6947 		 */
6948 		un->un_laststate = un->un_state;
6949 		un->un_state = ST_STATE_OPEN;
6950 		bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount);
6951 		if (st_cmd(dev, (int)SCMD_WRITE, (int)bp->b_bcount,
6952 		    SYNC_CMD) == 0) {
6953 			goto success;
6954 		}
6955 	}
6956 
6957 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6958 	    "append write failed- not at EOM\n");
6959 	bp->b_resid = bp->b_bcount;
6960 	st_bioerror(bp, EIO);
6961 
6962 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6963 	    "st_test_append : EIO : append write failed - not at EOM");
6964 
6965 	/*
6966 	 * backspace one record to get back to where we were
6967 	 */
6968 	if (st_cmd(dev, SCMD_SPACE, Blk(-1), SYNC_CMD)) {
6969 		un->un_fileno = -1;
6970 	}
6971 
6972 	un->un_err_resid = bp->b_resid;
6973 	un->un_status = status;
6974 
6975 	/*
6976 	 * Note: biodone will do a bp_mapout()
6977 	 */
6978 	mutex_exit(ST_MUTEX);
6979 	bcount = (unsigned)bp->b_bcount;
6980 	biodone(bp);
6981 	mutex_enter(ST_MUTEX);
6982 	un->un_laststate = un->un_state;
6983 	un->un_state = ST_STATE_OPEN_PENDING_IO;
6984 	kmem_free(un->un_tmpbuf, bcount);
6985 	un->un_tmpbuf = NULL;
6986 }
6987 
6988 /*
6989  * Special command handler
6990  */
6991 
6992 /*
6993  * common st_cmd code. The fourth parameter states
6994  * whether the caller wishes to await the results
6995  * Note the release of the mutex during most of the function
6996  */
6997 static int
6998 st_cmd(dev_t dev, int com, int count, int wait)
6999 {
7000 	struct buf *bp;
7001 	int err;
7002 
7003 	GET_SOFT_STATE(dev);
7004 
7005 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7006 	    "st_cmd(dev = 0x%lx, com = 0x%x, count = %x, wait = %d)\n",
7007 	    dev, com, count, wait);
7008 
7009 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
7010 	ASSERT(mutex_owned(ST_MUTEX));
7011 
7012 #ifdef STDEBUG
7013 	if (st_debug)
7014 		st_debug_cmds(un, com, count, wait);
7015 #endif
7016 
7017 	while (un->un_sbuf_busy)
7018 		cv_wait(&un->un_sbuf_cv, ST_MUTEX);
7019 	un->un_sbuf_busy = 1;
7020 
7021 	bp = un->un_sbufp;
7022 	bzero(bp, sizeof (buf_t));
7023 
7024 	bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC;
7025 
7026 	/*
7027 	 * Set count to the actual size of the data tranfer.
7028 	 * For commands with no data transfer, set bp->b_bcount
7029 	 * to the value to be used when constructing the
7030 	 * cdb in st_make_cmd().
7031 	 */
7032 	switch (com) {
7033 	case SCMD_READ:
7034 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7035 		    "special read %d\n", count);
7036 		bp->b_flags |= B_READ;
7037 		bp->b_un.b_addr = un->un_tmpbuf;
7038 		break;
7039 
7040 	case SCMD_WRITE:
7041 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7042 		    "special write %d\n", count);
7043 		bp->b_un.b_addr = un->un_tmpbuf;
7044 		break;
7045 
7046 	case SCMD_WRITE_FILE_MARK:
7047 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7048 		    "write %d file marks\n", count);
7049 		bp->b_bcount = count;
7050 		count = 0;
7051 		break;
7052 
7053 	case SCMD_REWIND:
7054 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "rewind\n");
7055 		bp->b_bcount = 0;
7056 		count = 0;
7057 		break;
7058 
7059 	case SCMD_SPACE:
7060 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "space\n");
7061 		bp->b_bcount = count;
7062 		count = 0;
7063 		break;
7064 
7065 	case SCMD_RESERVE:
7066 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "reserve");
7067 		bp->b_bcount = 0;
7068 		count = 0;
7069 		break;
7070 
7071 	case SCMD_RELEASE:
7072 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "release");
7073 		bp->b_bcount = 0;
7074 		count = 0;
7075 		break;
7076 
7077 	case SCMD_LOAD:
7078 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7079 		    "%s tape\n", (count) ? "load" : "unload");
7080 		bp->b_bcount = count;
7081 		count = 0;
7082 		break;
7083 
7084 	case SCMD_ERASE:
7085 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7086 		    "erase tape\n");
7087 		bp->b_bcount = 0;
7088 		count = 0;
7089 		break;
7090 
7091 	case SCMD_MODE_SENSE:
7092 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7093 		    "mode sense\n");
7094 		bp->b_flags |= B_READ;
7095 		bp->b_un.b_addr = (caddr_t)(un->un_mspl);
7096 		break;
7097 
7098 	case SCMD_MODE_SELECT:
7099 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7100 		    "mode select\n");
7101 		bp->b_un.b_addr = (caddr_t)(un->un_mspl);
7102 		break;
7103 
7104 	case SCMD_READ_BLKLIM:
7105 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7106 		    "read block limits\n");
7107 		bp->b_flags |= B_READ;
7108 		bp->b_un.b_addr = (caddr_t)(un->un_rbl);
7109 		break;
7110 
7111 	case SCMD_TEST_UNIT_READY:
7112 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7113 		    "test unit ready\n");
7114 		bp->b_bcount = 0;
7115 		count = 0;
7116 		break;
7117 	default:
7118 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
7119 		    "Unhandled scsi command 0x%x in st_cmd()\n", com);
7120 	}
7121 
7122 	mutex_exit(ST_MUTEX);
7123 
7124 	if (count > 0) {
7125 		/*
7126 		 * We're going to do actual I/O.
7127 		 * Set things up for physio.
7128 		 */
7129 		struct iovec aiov;
7130 		struct uio auio;
7131 		struct uio *uio = &auio;
7132 
7133 		bzero(&auio, sizeof (struct uio));
7134 		bzero(&aiov, sizeof (struct iovec));
7135 		aiov.iov_base = bp->b_un.b_addr;
7136 		aiov.iov_len = count;
7137 
7138 		uio->uio_iov = &aiov;
7139 		uio->uio_iovcnt = 1;
7140 		uio->uio_resid = aiov.iov_len;
7141 		uio->uio_segflg = UIO_SYSSPACE;
7142 
7143 		/*
7144 		 * Let physio do the rest...
7145 		 */
7146 		bp->b_forw = (struct buf *)(uintptr_t)com;
7147 		bp->b_back = NULL;
7148 		err = physio(st_strategy, bp, dev,
7149 			(bp->b_flags & B_READ) ? B_READ : B_WRITE,
7150 			st_minphys, uio);
7151 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7152 		    "st_cmd: physio returns %d\n", err);
7153 	} else {
7154 		/*
7155 		 * Mimic physio
7156 		 */
7157 		bp->b_forw = (struct buf *)(uintptr_t)com;
7158 		bp->b_back = NULL;
7159 		bp->b_edev = dev;
7160 		bp->b_dev = cmpdev(dev);
7161 		bp->b_blkno = 0;
7162 		bp->b_resid = 0;
7163 		(void) st_strategy(bp);
7164 		if (!wait) {
7165 			/*
7166 			 * This is an async command- the caller won't wait
7167 			 * and doesn't care about errors.
7168 			 */
7169 			mutex_enter(ST_MUTEX);
7170 			return (0);
7171 		}
7172 
7173 		/*
7174 		 * BugTraq #4260046
7175 		 * ----------------
7176 		 * Restore Solaris 2.5.1 behavior, namely call biowait
7177 		 * unconditionally. The old comment said...
7178 		 *
7179 		 * "if strategy was flagged with  persistent errors, we would
7180 		 *  have an error here, and the bp would never be sent, so we
7181 		 *  don't want to wait on a bp that was never sent...or hang"
7182 		 *
7183 		 * The new rationale, courtesy of Chitrank...
7184 		 *
7185 		 * "we should unconditionally biowait() here because
7186 		 *  st_strategy() will do a biodone() in the persistent error
7187 		 *  case and the following biowait() will return immediately.
7188 		 *  If not, in the case of "errors after pkt alloc" in
7189 		 *  st_start(), we will not biowait here which will cause the
7190 		 *  next biowait() to return immediately which will cause
7191 		 *  us to send out the next command. In the case where both of
7192 		 *  these use the sbuf, when the first command completes we'll
7193 		 *  free the packet attached to sbuf and the same pkt will
7194 		 *  get freed again when we complete the second command.
7195 		 *  see esc 518987.  BTW, it is necessary to do biodone() in
7196 		 *  st_start() for the pkt alloc failure case because physio()
7197 		 *  does biowait() and will hang if we don't do biodone()"
7198 		 */
7199 
7200 		err = biowait(bp);
7201 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7202 		    "st_cmd: biowait returns %d\n", err);
7203 	}
7204 	mutex_enter(ST_MUTEX);
7205 
7206 	un->un_sbuf_busy = 0;
7207 	cv_signal(&un->un_sbuf_cv);
7208 	return (err);
7209 }
7210 
7211 static int
7212 st_set_compression(struct scsi_tape *un)
7213 {
7214 	int rval;
7215 	int turn_compression_on;
7216 	minor_t minor;
7217 
7218 	/*
7219 	 * Drive either dosn't have compression or it is controlled with
7220 	 * special density codes. Return ENOTTY so caller
7221 	 * knows nothing was done.
7222 	 */
7223 	if ((un->un_dp->options & ST_MODE_SEL_COMP) == 0) {
7224 		un->un_comp_page = 0;
7225 		return (ENOTTY);
7226 	}
7227 
7228 	/* set compression based on minor node opened */
7229 	minor = MT_DENSITY(un->un_dev);
7230 
7231 	/*
7232 	 * If this the compression density or
7233 	 * the drive has two densities and uses mode select for
7234 	 * control of compression turn on compression for MT_DENSITY2
7235 	 * as well.
7236 	 */
7237 	if ((minor == ST_COMPRESSION_DENSITY) ||
7238 	    (minor == MT_DENSITY(MT_DENSITY2)) &&
7239 	    (un->un_dp->densities[0] == un->un_dp->densities[1]) &&
7240 	    (un->un_dp->densities[2] == un->un_dp->densities[3]) &&
7241 	    (un->un_dp->densities[0] != un->un_dp->densities[2])) {
7242 
7243 		turn_compression_on = 1;
7244 	} else {
7245 		turn_compression_on = 0;
7246 	}
7247 
7248 	un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16);
7249 	un->un_mspl->mid_bl  = (uchar_t)(un->un_bsize >> 8);
7250 	un->un_mspl->low_bl  = (uchar_t)(un->un_bsize);
7251 
7252 	/*
7253 	 * Need to determine which page does the device use for compression.
7254 	 * First try the data compression page. If this fails try the device
7255 	 * configuration page
7256 	 */
7257 
7258 	if ((un->un_comp_page & ST_DEV_DATACOMP_PAGE) == ST_DEV_DATACOMP_PAGE) {
7259 		rval = st_set_datacomp_page(un, turn_compression_on);
7260 		if (rval == EALREADY) {
7261 			return (rval);
7262 		}
7263 		if (rval != 0) {
7264 			if (un->un_status == KEY_ILLEGAL_REQUEST) {
7265 				/*
7266 				 * This device does not support data
7267 				 * compression page
7268 				 */
7269 				un->un_comp_page = ST_DEV_CONFIG_PAGE;
7270 			} else if (un->un_state >= ST_STATE_OPEN) {
7271 				un->un_fileno = -1;
7272 				rval = EIO;
7273 			} else {
7274 				rval = -1;
7275 			}
7276 		} else {
7277 			un->un_comp_page = ST_DEV_DATACOMP_PAGE;
7278 		}
7279 	}
7280 
7281 	if ((un->un_comp_page & ST_DEV_CONFIG_PAGE) == ST_DEV_CONFIG_PAGE) {
7282 		rval = st_set_devconfig_page(un, turn_compression_on);
7283 		if (rval == EALREADY) {
7284 			return (rval);
7285 		}
7286 		if (rval != 0) {
7287 			if (un->un_status == KEY_ILLEGAL_REQUEST) {
7288 				/*
7289 				 * This device does not support
7290 				 * compression at all advice the
7291 				 * user and unset ST_MODE_SEL_COMP
7292 				 */
7293 				un->un_dp->options &= ~ST_MODE_SEL_COMP;
7294 				un->un_comp_page = 0;
7295 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
7296 				    "Device Does Not Support Compression\n");
7297 			} else if (un->un_state >= ST_STATE_OPEN) {
7298 				un->un_fileno = -1;
7299 				rval = EIO;
7300 			} else {
7301 				rval = -1;
7302 			}
7303 		}
7304 	}
7305 
7306 	return (rval);
7307 }
7308 
7309 /*
7310  * set or unset compression thru device configuration page.
7311  */
7312 static int
7313 st_set_devconfig_page(struct scsi_tape *un, int compression_on)
7314 {
7315 	unsigned char cflag;
7316 	int rval = 0;
7317 
7318 	ASSERT(mutex_owned(ST_MUTEX));
7319 
7320 	/*
7321 	 * Figure what to set compression flag to.
7322 	 */
7323 	if (compression_on) {
7324 		/* They have selected a compression node */
7325 		if (un->un_dp->type == ST_TYPE_FUJI) {
7326 			cflag = 0x84;   /* use EDRC */
7327 		} else {
7328 			cflag = ST_DEV_CONFIG_DEF_COMP;
7329 		}
7330 	} else {
7331 		cflag = ST_DEV_CONFIG_NO_COMP;
7332 	}
7333 
7334 	/*
7335 	 * If compression is already set the way it was requested.
7336 	 * And if this not the first time we has tried.
7337 	 */
7338 	if ((cflag == un->un_mspl->page.dev.comp_alg) &&
7339 	    (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) {
7340 		return (EALREADY);
7341 	}
7342 
7343 	un->un_mspl->page.dev.comp_alg = cflag;
7344 	/*
7345 	 * need to send mode select even if correct compression is
7346 	 * already set since need to set density code
7347 	 */
7348 
7349 #ifdef STDEBUG
7350 	if (st_debug >= 6) {
7351 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
7352 		    "st_set_devconfig_page: sense data for mode select",
7353 		    (char *)un->un_mspl, sizeof (struct seq_mode));
7354 	}
7355 #endif
7356 	rval = st_gen_mode_select(un, un->un_mspl, sizeof (struct seq_mode));
7357 
7358 	return (rval);
7359 }
7360 
7361 /*
7362  * set/reset compression bit thru data compression page
7363  */
7364 static int
7365 st_set_datacomp_page(struct scsi_tape *un, int compression_on)
7366 {
7367 	int compression_on_already;
7368 	int rval = 0;
7369 
7370 	ASSERT(mutex_owned(ST_MUTEX));
7371 
7372 	/*
7373 	 * If drive is not capable of compression (at this time)
7374 	 * return EALREADY so caller doesn't think that this page
7375 	 * is not supported. This check is for drives that can
7376 	 * disable compression from the front panel or configuration.
7377 	 * I doubt that a drive that supports this page is not really
7378 	 * capable of compression.
7379 	 */
7380 	if (un->un_mspl->page.comp.dcc == 0) {
7381 		return (EALREADY);
7382 	}
7383 
7384 	/* See if compression currently turned on */
7385 	if (un->un_mspl->page.comp.dce) {
7386 		compression_on_already = 1;
7387 	} else {
7388 		compression_on_already = 0;
7389 	}
7390 
7391 	/*
7392 	 * If compression is already set the way it was requested.
7393 	 * And if this not the first time we has tried.
7394 	 */
7395 	if ((compression_on == compression_on_already) &&
7396 	    (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) {
7397 		return (EALREADY);
7398 	}
7399 
7400 	/*
7401 	 * if we are already set to the appropriate compression
7402 	 * mode, don't set it again
7403 	 */
7404 	if (compression_on) {
7405 		/* compression selected */
7406 		un->un_mspl->page.comp.dce = 1;
7407 	} else {
7408 		un->un_mspl->page.comp.dce = 0;
7409 	}
7410 
7411 
7412 #ifdef STDEBUG
7413 	if (st_debug >= 6) {
7414 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
7415 		    "st_set_datacomp_page: sense data for mode select",
7416 		    (char *)un->un_mspl, sizeof (struct seq_mode));
7417 	}
7418 #endif
7419 	rval = st_gen_mode_select(un, un->un_mspl, sizeof (struct seq_mode));
7420 
7421 	return (rval);
7422 }
7423 
7424 static int
7425 st_modesense(struct scsi_tape *un)
7426 {
7427 	int rval;
7428 	uchar_t page;
7429 
7430 	page = un->un_comp_page;
7431 
7432 	switch (page) {
7433 	case ST_DEV_DATACOMP_PAGE:
7434 	case ST_DEV_CONFIG_PAGE: /* fall through */
7435 		rval = st_gen_mode_sense(un, page, un->un_mspl,
7436 		    sizeof (struct seq_mode));
7437 		break;
7438 
7439 	case ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE:
7440 		if (un->un_dp->options & ST_MODE_SEL_COMP) {
7441 			page = ST_DEV_DATACOMP_PAGE;
7442 			rval = st_gen_mode_sense(un, page, un->un_mspl,
7443 			    sizeof (struct seq_mode));
7444 			if (rval == 0 && un->un_mspl->page_code == page) {
7445 				un->un_comp_page = page;
7446 				break;
7447 			}
7448 			page = ST_DEV_CONFIG_PAGE;
7449 			rval = st_gen_mode_sense(un, page, un->un_mspl,
7450 			    sizeof (struct seq_mode));
7451 			if (rval == 0 && un->un_mspl->page_code == page) {
7452 				un->un_comp_page = page;
7453 				break;
7454 			}
7455 			un->un_dp->options &= ~ST_MODE_SEL_COMP;
7456 			un->un_comp_page = 0;
7457 		} else {
7458 			un->un_comp_page = 0;
7459 		}
7460 
7461 	default:	/* fall through */
7462 		rval = st_cmd(un->un_dev, SCMD_MODE_SENSE, MSIZE, SYNC_CMD);
7463 	}
7464 	return (rval);
7465 }
7466 
7467 static int
7468 st_modeselect(struct scsi_tape *un)
7469 {
7470 	int rval = 0;
7471 	int ix;
7472 
7473 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7474 	    "st_modeselect(dev = 0x%lx): density = 0x%x\n",
7475 	    un->un_dev, un->un_mspl->density);
7476 
7477 	ASSERT(mutex_owned(ST_MUTEX));
7478 
7479 	/*
7480 	 * The parameter list should be the same for all of the
7481 	 * cases that follow so set them here
7482 	 *
7483 	 * Try mode select first if if fails set fields manually
7484 	 */
7485 	rval = st_modesense(un);
7486 	if (rval != 0) {
7487 		ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
7488 		    "st_modeselect: First mode sense failed\n");
7489 		un->un_mspl->bd_len  = 8;
7490 		un->un_mspl->high_nb = 0;
7491 		un->un_mspl->mid_nb  = 0;
7492 		un->un_mspl->low_nb  = 0;
7493 	}
7494 	un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16);
7495 	un->un_mspl->mid_bl  = (uchar_t)(un->un_bsize >> 8);
7496 	un->un_mspl->low_bl  = (uchar_t)(un->un_bsize);
7497 
7498 
7499 	/*
7500 	 * If configured to use a specific density code for a media type.
7501 	 * curdens is previously set by the minor node opened.
7502 	 * If the media type doesn't match the minor node we change it so it
7503 	 * looks like the correct one was opened.
7504 	 */
7505 	if (un->un_dp->options & ST_KNOWS_MEDIA) {
7506 		uchar_t best;
7507 
7508 		for (best = 0xff, ix = 0; ix < NDENSITIES; ix++) {
7509 			if (un->un_mspl->media_type ==
7510 			    un->un_dp->mediatype[ix]) {
7511 				best = ix;
7512 				/*
7513 				 * It matches but it might not be the only one.
7514 				 * Use the highest matching media type but not
7515 				 * to exceed the density selected by the open.
7516 				 */
7517 				if (ix < un->un_curdens) {
7518 					continue;
7519 				}
7520 				un->un_curdens = ix;
7521 				break;
7522 			}
7523 		}
7524 		/* If a match was found best will not be 0xff any more */
7525 		if (best < NDENSITIES) {
7526 			ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
7527 			    "found media 0x%X using density 0x%X\n",
7528 			    un->un_mspl->media_type,
7529 			    un->un_dp->densities[best]);
7530 		}
7531 
7532 		un->un_mspl->density = un->un_dp->densities[best];
7533 
7534 	} else {
7535 		/* Otherwise set density based on minor node opened */
7536 		un->un_mspl->density = un->un_dp->densities[un->un_curdens];
7537 	}
7538 
7539 	if (un->un_dp->options & ST_NOBUF) {
7540 		un->un_mspl->bufm = 0;
7541 	} else {
7542 		un->un_mspl->bufm = 1;
7543 	}
7544 
7545 	rval = st_set_compression(un);
7546 
7547 	/*
7548 	 * If st_set_compression returned invalid or already it
7549 	 * found no need to do the mode select.
7550 	 * So do it here.
7551 	 */
7552 	if ((rval == ENOTTY) || (rval == EALREADY)) {
7553 
7554 		/* Zero non-writeable fields */
7555 		un->un_mspl->data_len = 0;
7556 		un->un_mspl->media_type = 0;
7557 		un->un_mspl->wp = 0;
7558 
7559 		/* need to set the density code */
7560 		rval = st_cmd(un->un_dev, SCMD_MODE_SELECT, MSIZE, SYNC_CMD);
7561 		if (rval != 0) {
7562 			if (un->un_state >= ST_STATE_OPEN) {
7563 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
7564 				    "unable to set tape mode\n");
7565 				un->un_fileno = -1;
7566 				rval = EIO;
7567 			} else {
7568 				rval = -1;
7569 			}
7570 		}
7571 	}
7572 
7573 	/*
7574 	 * The spec recommends to send a mode sense after a mode select
7575 	 */
7576 	(void) st_modesense(un);
7577 
7578 	ASSERT(mutex_owned(ST_MUTEX));
7579 
7580 	return (rval);
7581 }
7582 
7583 /*
7584  * st_gen_mode_sense
7585  *
7586  * generic mode sense.. it allows for any page
7587  */
7588 static int
7589 st_gen_mode_sense(struct scsi_tape *un, int page, struct seq_mode *page_data,
7590     int page_size)
7591 {
7592 
7593 	int r;
7594 	char	cdb[CDB_GROUP0];
7595 	struct uscsi_cmd *com;
7596 
7597 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
7598 
7599 	bzero(cdb, CDB_GROUP0);
7600 	cdb[0] = SCMD_MODE_SENSE;
7601 	cdb[2] = (char)page;
7602 	cdb[4] = (char)page_size;
7603 
7604 	com->uscsi_cdb = cdb;
7605 	com->uscsi_cdblen = CDB_GROUP0;
7606 	com->uscsi_bufaddr = (caddr_t)page_data;
7607 	com->uscsi_buflen = page_size;
7608 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
7609 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT |
7610 			    USCSI_READ | USCSI_RQENABLE;
7611 
7612 	r = st_ioctl_cmd(un->un_dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
7613 		UIO_SYSSPACE);
7614 	kmem_free(com, sizeof (*com));
7615 	return (r);
7616 }
7617 
7618 /*
7619  * st_gen_mode_select
7620  *
7621  * generic mode select.. it allows for any page
7622  */
7623 static int
7624 st_gen_mode_select(struct scsi_tape *un, struct seq_mode *page_data,
7625     int page_size)
7626 {
7627 
7628 	int r;
7629 	char cdb[CDB_GROUP0];
7630 	struct uscsi_cmd *com;
7631 
7632 	/* Zero non-writeable fields */
7633 	page_data->data_len = 0;
7634 	page_data->media_type = 0;
7635 	page_data->wp = 0;
7636 
7637 	/*
7638 	 * If mode select has any page data, zero the ps (Page Savable) bit.
7639 	 */
7640 	if (page_size > MSIZE) {
7641 		page_data->ps = 0;
7642 	}
7643 
7644 
7645 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
7646 
7647 	/*
7648 	 * then, do a mode select to set what ever info
7649 	 */
7650 	bzero(cdb, CDB_GROUP0);
7651 	cdb[0] = SCMD_MODE_SELECT;
7652 	cdb[1] = 0x10;		/* set PF bit for many third party drives */
7653 	cdb[4] = (char)page_size;
7654 
7655 	com->uscsi_cdb = cdb;
7656 	com->uscsi_cdblen = CDB_GROUP0;
7657 	com->uscsi_bufaddr = (caddr_t)page_data;
7658 	com->uscsi_buflen = page_size;
7659 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
7660 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT
7661 		| USCSI_WRITE | USCSI_RQENABLE;
7662 
7663 	r = st_ioctl_cmd(un->un_dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
7664 		UIO_SYSSPACE);
7665 
7666 	kmem_free(com, sizeof (*com));
7667 	return (r);
7668 }
7669 
7670 /*
7671  * Changes devices blocksize and bsize to requested blocksize nblksz.
7672  * Returns returned value from first failed call or zero on success.
7673  */
7674 static int
7675 st_change_block_size(dev_t dev, uint32_t nblksz)
7676 {
7677 	struct seq_mode *current;
7678 	int rval;
7679 	uint32_t oldblksz;
7680 
7681 	GET_SOFT_STATE(dev);
7682 
7683 	current = kmem_zalloc(MSIZE, KM_SLEEP);
7684 
7685 	/* Read current settings */
7686 	rval = st_gen_mode_sense(un, 0, current, MSIZE);
7687 	if (rval != 0) {
7688 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
7689 		    "mode sense for change block size failed: rval = %d", rval);
7690 		goto finish;
7691 	}
7692 
7693 	/* Figure the current block size */
7694 	oldblksz =
7695 	    (current->high_bl << 16) |
7696 	    (current->mid_bl << 8) |
7697 	    (current->low_bl);
7698 
7699 	/* If current block size is the same as requested were done */
7700 	if (oldblksz == nblksz) {
7701 		un->un_bsize = nblksz;
7702 		rval = 0;
7703 		goto finish;
7704 	}
7705 
7706 	/* Change to requested block size */
7707 	current->high_bl = (uchar_t)(nblksz >> 16);
7708 	current->mid_bl  = (uchar_t)(nblksz >> 8);
7709 	current->low_bl  = (uchar_t)(nblksz);
7710 
7711 	/* Attempt to change block size */
7712 	rval = st_gen_mode_select(un, current, MSIZE);
7713 	if (rval != 0) {
7714 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
7715 		    "Set new block size failed: rval = %d", rval);
7716 		goto finish;
7717 	}
7718 
7719 	/* Read back and verify setting */
7720 	rval = st_modesense(un);
7721 	if (rval == 0) {
7722 		un->un_bsize =
7723 		    (un->un_mspl->high_bl << 16) |
7724 		    (un->un_mspl->mid_bl << 8) |
7725 		    (un->un_mspl->low_bl);
7726 
7727 		if (un->un_bsize != nblksz) {
7728 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
7729 			    "Blocksize set does not equal requested blocksize"
7730 			    "(read: %u requested: %u)\n", nblksz, un->un_bsize);
7731 			rval = EIO;
7732 		}
7733 	}
7734 finish:
7735 	kmem_free(current, MSIZE);
7736 	return (rval);
7737 }
7738 
7739 
7740 static void
7741 st_init(struct scsi_tape *un)
7742 {
7743 	ASSERT(mutex_owned(ST_MUTEX));
7744 
7745 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7746 	"st_init(): dev = 0x%lx, will reset fileno, blkno, eof\n", un->un_dev);
7747 
7748 	un->un_blkno = 0;
7749 	un->un_fileno = 0;
7750 	un->un_lastop = ST_OP_NIL;
7751 	un->un_eof = ST_NO_EOF;
7752 	un->un_pwr_mgmt = ST_PWR_NORMAL;
7753 	if (st_error_level != SCSI_ERR_ALL) {
7754 		if (DEBUGGING) {
7755 			st_error_level = SCSI_ERR_ALL;
7756 		} else {
7757 			st_error_level = SCSI_ERR_RETRYABLE;
7758 		}
7759 	}
7760 }
7761 
7762 
7763 static void
7764 st_make_cmd(struct scsi_tape *un, struct buf *bp, int (*func)(caddr_t))
7765 {
7766 	struct scsi_pkt *pkt;
7767 	struct uscsi_cmd *ucmd;
7768 	int count, tval = 0;
7769 	int flags = 0;
7770 	uchar_t com;
7771 	char fixbit;
7772 
7773 	ASSERT(mutex_owned(ST_MUTEX));
7774 
7775 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7776 	    "st_make_cmd(): dev = 0x%lx\n", un->un_dev);
7777 
7778 
7779 	/*
7780 	 * fixbit is for setting the Fixed Mode and Suppress Incorrect
7781 	 * Length Indicator bits on read/write commands, for setting
7782 	 * the Long bit on erase commands, and for setting the Code
7783 	 * Field bits on space commands.
7784 	 * XXX why do we set lastop here?
7785 	 */
7786 
7787 	if (bp != un->un_sbufp) {		/* regular raw I/O */
7788 		int stat_size = (un->un_arq_enabled ?
7789 			sizeof (struct scsi_arq_status) : 1);
7790 		pkt = scsi_init_pkt(ROUTE, NULL, bp,
7791 		    CDB_GROUP0, stat_size, 0, 0, func, (caddr_t)un);
7792 		if (pkt == NULL) {
7793 			goto exit;
7794 		}
7795 		SET_BP_PKT(bp, pkt);
7796 		if (un->un_bsize == 0) {
7797 			count = bp->b_bcount;
7798 			fixbit = 0;
7799 		} else {
7800 			count = bp->b_bcount / un->un_bsize;
7801 			fixbit = 1;
7802 		}
7803 		if (bp->b_flags & B_READ) {
7804 			com = SCMD_READ;
7805 			un->un_lastop = ST_OP_READ;
7806 			if ((un->un_bsize == 0) && /* Not Fixed Block */
7807 			    (un->un_dp->options & ST_READ_IGNORE_ILI)) {
7808 				fixbit = 2;
7809 			}
7810 		} else {
7811 			com = SCMD_WRITE;
7812 			un->un_lastop = ST_OP_WRITE;
7813 		}
7814 
7815 		tval = un->un_dp->io_timeout;
7816 
7817 		/*
7818 		 * For really large xfers, increase timeout
7819 		 */
7820 		if (bp->b_bcount > (10 * ONE_MEG))
7821 			tval *= bp->b_bcount/(10 * ONE_MEG);
7822 
7823 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7824 		    "%s %ld amt 0x%lx\n", (com == SCMD_WRITE) ?
7825 		    wr_str: rd_str, un->un_blkno, bp->b_bcount);
7826 
7827 	} else if ((ucmd = BP_UCMD(bp)) != NULL) {
7828 		/*
7829 		 * uscsi - build command, allocate scsi resources
7830 		 */
7831 		st_make_uscsi_cmd(un, ucmd, bp, func);
7832 		goto exit;
7833 
7834 	} else {				/* special I/O */
7835 		struct buf *allocbp = NULL;
7836 		int stat_size = (un->un_arq_enabled ?
7837 			sizeof (struct scsi_arq_status) : 1);
7838 
7839 
7840 		com = (uchar_t)(uintptr_t)bp->b_forw;
7841 		count = bp->b_bcount;
7842 
7843 		switch (com) {
7844 		case SCMD_READ:
7845 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7846 			    "special read %d\n", count);
7847 			if (un->un_bsize == 0) {
7848 				fixbit = 2;	/* suppress SILI */
7849 			} else {
7850 				fixbit = 1;	/* Fixed Block Mode */
7851 				count /= un->un_bsize;
7852 			}
7853 			allocbp = bp;
7854 			un->un_lastop = ST_OP_READ;
7855 			tval = un->un_dp->io_timeout;
7856 			break;
7857 
7858 		case SCMD_WRITE:
7859 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7860 			    "special write %d\n", count);
7861 			if (un->un_bsize != 0) {
7862 				fixbit = 1;	/* Fixed Block Mode */
7863 				count /= un->un_bsize;
7864 			} else {
7865 				fixbit = 0;
7866 			}
7867 			allocbp = bp;
7868 			un->un_lastop = ST_OP_WRITE;
7869 			tval = un->un_dp->io_timeout;
7870 			break;
7871 
7872 		case SCMD_WRITE_FILE_MARK:
7873 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7874 			    "write %d file marks\n", count);
7875 			un->un_lastop = ST_OP_WEOF;
7876 			fixbit = 0;
7877 			tval = un->un_dp->io_timeout;
7878 			break;
7879 
7880 		case SCMD_REWIND:
7881 			fixbit = 0;
7882 			count = 0;
7883 			un->un_lastop = ST_OP_CTL;
7884 			tval = un->un_dp->rewind_timeout;
7885 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7886 			    "rewind\n");
7887 			break;
7888 
7889 		case SCMD_SPACE:
7890 			fixbit = Isfmk(count);
7891 			count = (int)space_cnt(count);
7892 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7893 			    "space %d %s from file %d blk %ld\n",
7894 			    count, (fixbit) ? "filemarks" : "records",
7895 			    un->un_fileno, un->un_blkno);
7896 			un->un_lastop = ST_OP_CTL;
7897 			tval = un->un_dp->space_timeout;
7898 			break;
7899 
7900 		case SCMD_LOAD:
7901 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7902 			    "%s tape\n", (count & 1) ? "load" : "unload");
7903 			fixbit = 0;
7904 
7905 			/* Loading or Unloading */
7906 			if (count & 1) {
7907 				tval = un->un_dp->load_timeout;
7908 			} else {
7909 				tval = un->un_dp->unload_timeout;
7910 			}
7911 			/* Is Retension requested */
7912 			if (count & 2) {
7913 				tval += un->un_dp->rewind_timeout;
7914 			}
7915 			un->un_lastop = ST_OP_CTL;
7916 			break;
7917 
7918 		case SCMD_ERASE:
7919 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7920 			    "erase tape\n");
7921 			count = 0;
7922 			/*
7923 			 * We support long erase only
7924 			 */
7925 			fixbit = 1;
7926 			tval = un->un_dp->erase_timeout;
7927 			un->un_lastop = ST_OP_CTL;
7928 			break;
7929 
7930 		case SCMD_MODE_SENSE:
7931 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7932 			    "mode sense\n");
7933 			allocbp = bp;
7934 			fixbit = 0;
7935 			tval = un->un_dp->non_motion_timeout;
7936 			break;
7937 
7938 		case SCMD_MODE_SELECT:
7939 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7940 			    "mode select\n");
7941 			allocbp = bp;
7942 			fixbit = 0;
7943 			tval = un->un_dp->non_motion_timeout;
7944 			break;
7945 
7946 		case SCMD_RESERVE:
7947 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7948 			    "reserve\n");
7949 			fixbit = 0;
7950 			tval = un->un_dp->non_motion_timeout;
7951 			break;
7952 
7953 		case SCMD_RELEASE:
7954 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7955 			    "release\n");
7956 			fixbit = 0;
7957 			tval = un->un_dp->non_motion_timeout;
7958 			break;
7959 
7960 		case SCMD_READ_BLKLIM:
7961 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7962 			    "read block limits\n");
7963 			allocbp = bp;
7964 			fixbit = count = 0;
7965 			tval = un->un_dp->non_motion_timeout;
7966 			break;
7967 
7968 		case SCMD_TEST_UNIT_READY:
7969 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7970 			    "test unit ready\n");
7971 			fixbit = 0;
7972 			tval = un->un_dp->non_motion_timeout;
7973 			break;
7974 		default:
7975 			ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
7976 			    "Unhandled scsi command 0x%x in st_make_cmd()\n",
7977 			    com);
7978 		}
7979 		pkt = scsi_init_pkt(ROUTE, NULL, allocbp,
7980 			CDB_GROUP0, stat_size, 0, 0, func, (caddr_t)un);
7981 		if (pkt == NULL) {
7982 			goto exit;
7983 		}
7984 		if (allocbp)
7985 			ASSERT(geterror(allocbp) == 0);
7986 
7987 	}
7988 
7989 	(void) scsi_setup_cdb((union scsi_cdb *)pkt->pkt_cdbp,
7990 	    com, 0, (uint_t)count, 0);
7991 	FILL_SCSI1_LUN(un->un_sd, pkt);
7992 	/*
7993 	 * Initialize the SILI/Fixed bits of the byte 1 of cdb.
7994 	 */
7995 	((union scsi_cdb *)(pkt->pkt_cdbp))->t_code = fixbit;
7996 	pkt->pkt_flags = flags;
7997 
7998 	/*
7999 	 * If ST_SHORT_FILEMARKS bit is ON for EXABYTE
8000 	 * device, set the Vendor Unique bit to
8001 	 * write Short File Mark.
8002 	 */
8003 	if (com == SCMD_WRITE_FILE_MARK &&
8004 		un->un_dp->options & ST_SHORT_FILEMARKS) {
8005 		switch (un->un_dp->type) {
8006 		case ST_TYPE_EXB8500:
8007 		case ST_TYPE_EXABYTE:
8008 			/*
8009 			 * Now the Vendor Unique bit 7 in Byte 5 of CDB
8010 			 * is set to to write Short File Mark
8011 			 */
8012 			((union scsi_cdb *)pkt->pkt_cdbp)->g0_vu_1 = 1;
8013 			break;
8014 
8015 		default:
8016 			/*
8017 			 * Well, if ST_SHORT_FILEMARKS is set for other
8018 			 * tape drives, it is just ignored
8019 			 */
8020 			break;
8021 		}
8022 	}
8023 	ASSERT(tval);
8024 	pkt->pkt_time = tval;
8025 	pkt->pkt_comp = st_intr;
8026 	pkt->pkt_private = (opaque_t)bp;
8027 	SET_BP_PKT(bp, pkt);
8028 
8029 exit:
8030 	ASSERT(mutex_owned(ST_MUTEX));
8031 }
8032 
8033 
8034 /*
8035  * Build a command based on a uscsi command;
8036  */
8037 static void
8038 st_make_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd,
8039     struct buf *bp, int (*func)(caddr_t))
8040 {
8041 	struct scsi_pkt *pkt;
8042 	caddr_t cdb;
8043 	int	cdblen;
8044 	int stat_size;
8045 
8046 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8047 	    "st_make_uscsi_cmd(): dev = 0x%lx\n", un->un_dev);
8048 
8049 	if (ucmd->uscsi_flags & USCSI_RQENABLE) {
8050 		stat_size = (un->un_arq_enabled ?
8051 		    sizeof (struct scsi_arq_status) : 1);
8052 	} else {
8053 		stat_size = 1;
8054 	}
8055 
8056 	ASSERT(mutex_owned(ST_MUTEX));
8057 
8058 	un->un_lastop = ST_OP_CTL;	/* usual */
8059 
8060 	cdb = ucmd->uscsi_cdb;
8061 	cdblen = ucmd->uscsi_cdblen;
8062 
8063 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8064 	    "st_make_uscsi_cmd: buflen=%ld bcount=%ld\n",
8065 		ucmd->uscsi_buflen, bp->b_bcount);
8066 	pkt = scsi_init_pkt(ROUTE, NULL,
8067 		(bp->b_bcount > 0) ? bp : NULL,
8068 		cdblen, stat_size, 0, 0, func, (caddr_t)un);
8069 	if (pkt == NULL) {
8070 		goto exit;
8071 	}
8072 
8073 	bcopy(cdb, pkt->pkt_cdbp, (uint_t)cdblen);
8074 
8075 #ifdef STDEBUG
8076 	if (st_debug >= 6) {
8077 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
8078 		    "pkt_cdbp", (char *)cdb, cdblen);
8079 	}
8080 #endif
8081 
8082 	if (ucmd->uscsi_flags & USCSI_SILENT) {
8083 		pkt->pkt_flags |= FLAG_SILENT;
8084 	}
8085 
8086 	pkt->pkt_time = ucmd->uscsi_timeout;
8087 	pkt->pkt_comp = st_intr;
8088 	pkt->pkt_private = (opaque_t)bp;
8089 	SET_BP_PKT(bp, pkt);
8090 exit:
8091 	ASSERT(mutex_owned(ST_MUTEX));
8092 }
8093 
8094 
8095 /*
8096  * restart cmd currently at the head of the runq
8097  *
8098  * If scsi_transport() succeeds or the retries
8099  * count exhausted, restore the throttle that was
8100  * zeroed out in st_handle_intr_busy().
8101  *
8102  */
8103 static void
8104 st_intr_restart(void *arg)
8105 {
8106 	struct scsi_tape *un = arg;
8107 	struct buf *bp;
8108 	int status = TRAN_ACCEPT;
8109 
8110 	mutex_enter(ST_MUTEX);
8111 
8112 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8113 		"st_intr_restart(), un = 0x%p\n", (void *)un);
8114 
8115 	un->un_hib_tid = 0;
8116 
8117 	/*
8118 	 * move from waitq to runq, if there is anything on the waitq
8119 	 */
8120 	if ((bp = un->un_quef) == NULL) {
8121 		mutex_exit(ST_MUTEX);
8122 		return;
8123 	}
8124 
8125 	/*
8126 	 * Here we know :
8127 	 *	throttle = 0, via st_handle_intr_busy
8128 	 */
8129 
8130 	if (un->un_quel == bp) {
8131 		un->un_quel = NULL;
8132 		un->un_quef = NULL;	/* we know it's the first one */
8133 	} else {
8134 		un->un_quef = bp->b_actf;
8135 	}
8136 	bp->b_actf = NULL;
8137 
8138 	if (un->un_runqf) {
8139 		/*
8140 		 * not good, we don't want to requeue something after
8141 		 * another.
8142 		 */
8143 		mutex_exit(ST_MUTEX);
8144 		goto done_error;
8145 	} else {
8146 		un->un_runqf = bp;
8147 		un->un_runql = bp;
8148 	}
8149 
8150 	ST_DO_KSTATS(bp, kstat_waitq_to_runq);
8151 
8152 	mutex_exit(ST_MUTEX);
8153 
8154 	status = scsi_transport(BP_PKT(bp));
8155 
8156 	mutex_enter(ST_MUTEX);
8157 
8158 	if (status != TRAN_ACCEPT) {
8159 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
8160 		mutex_exit(ST_MUTEX);
8161 
8162 		if (status == TRAN_BUSY) {
8163 			if (st_handle_intr_busy(un, bp,
8164 			    ST_TRAN_BUSY_TIMEOUT) == 0)
8165 				return;	/* timeout is setup again */
8166 		}
8167 
8168 	} else {
8169 		un->un_tran_retry_ct = 0;
8170 		if (un->un_last_throttle) {
8171 			un->un_throttle = un->un_last_throttle;
8172 		}
8173 		mutex_exit(ST_MUTEX);
8174 		return;
8175 	}
8176 
8177 done_error:
8178 	ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
8179 	    "restart transport rejected\n");
8180 	bp->b_resid = bp->b_bcount;
8181 
8182 #ifndef __lock_lint
8183 	/*
8184 	 * warlock doesn't understand this potential
8185 	 * recursion?
8186 	 */
8187 	mutex_enter(ST_MUTEX);
8188 	if (un->un_last_throttle) {
8189 		un->un_throttle = un->un_last_throttle;
8190 	}
8191 	if (status != TRAN_ACCEPT)
8192 		ST_DO_ERRSTATS(un, st_transerrs);
8193 	ST_DO_KSTATS(bp, kstat_waitq_exit);
8194 	SET_PE_FLAG(un);
8195 	st_bioerror(bp, EIO);
8196 	st_done_and_mutex_exit(un, bp);
8197 #endif
8198 	ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
8199 	    "busy restart aborted\n");
8200 }
8201 
8202 /*
8203  * st_check_media():
8204  * Periodically check the media state using scsi_watch service;
8205  * this service calls back after TUR and possibly request sense
8206  * the callback handler (st_media_watch_cb()) decodes the request sense
8207  * data (if any)
8208  */
8209 
8210 static int
8211 st_check_media(dev_t dev, enum mtio_state state)
8212 {
8213 	int rval = 0;
8214 	enum mtio_state	prev_state;
8215 	opaque_t token = NULL;
8216 
8217 	GET_SOFT_STATE(dev);
8218 
8219 	mutex_enter(ST_MUTEX);
8220 
8221 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8222 		"st_check_media:state=%x, mediastate=%x\n",
8223 		state, un->un_mediastate);
8224 
8225 	prev_state = un->un_mediastate;
8226 
8227 	/*
8228 	 * is there anything to do?
8229 	 */
8230 retry:
8231 	if (state == un->un_mediastate || un->un_mediastate == MTIO_NONE) {
8232 		/*
8233 		 * submit the request to the scsi_watch service;
8234 		 * scsi_media_watch_cb() does the real work
8235 		 */
8236 		mutex_exit(ST_MUTEX);
8237 		token = scsi_watch_request_submit(ST_SCSI_DEVP,
8238 			st_check_media_time, SENSE_LENGTH,
8239 			st_media_watch_cb, (caddr_t)dev);
8240 		if (token == NULL) {
8241 			rval = EAGAIN;
8242 			goto done;
8243 		}
8244 		mutex_enter(ST_MUTEX);
8245 
8246 		un->un_swr_token = token;
8247 		un->un_specified_mediastate = state;
8248 
8249 		/*
8250 		 * now wait for media change
8251 		 * we will not be signalled unless mediastate == state but it
8252 		 * still better to test for this condition, since there
8253 		 * is a 5 sec cv_broadcast delay when
8254 		 *  mediastate == MTIO_INSERTED
8255 		 */
8256 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8257 			"st_check_media:waiting for media state change\n");
8258 		while (un->un_mediastate == state) {
8259 			if (cv_wait_sig(&un->un_state_cv, ST_MUTEX) == 0) {
8260 				mutex_exit(ST_MUTEX);
8261 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8262 				    "st_check_media:waiting for media state "
8263 				    "was interrupted\n");
8264 				rval = EINTR;
8265 				goto done;
8266 			}
8267 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8268 			    "st_check_media:received signal, state=%x\n",
8269 			    un->un_mediastate);
8270 		}
8271 	}
8272 
8273 	/*
8274 	 * if we transitioned to MTIO_INSERTED, media has really been
8275 	 * inserted.  If TUR fails, it is probably a exabyte slow spin up.
8276 	 * Reset and retry the state change.  If everything is ok, replay
8277 	 * the open() logic.
8278 	 */
8279 	if ((un->un_mediastate == MTIO_INSERTED) &&
8280 	    (un->un_state == ST_STATE_OFFLINE)) {
8281 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8282 		    "st_check_media: calling st_cmd to confirm inserted\n");
8283 
8284 		/*
8285 		 * set this early so that TUR will make it through strategy
8286 		 * without triggering a st_tape_init().  We needed it set
8287 		 * before calling st_tape_init() ourselves anyway.  If TUR
8288 		 * fails, set it back
8289 		 */
8290 		un->un_state = ST_STATE_INITIALIZING;
8291 		/*
8292 		 * If we haven't done/checked reservation on the
8293 		 * tape unit do it now.
8294 		 */
8295 		if (ST_RESERVE_SUPPORTED(un) &&
8296 			!(un->un_rsvd_status & ST_INIT_RESERVE)) {
8297 				if (rval = st_tape_reservation_init(dev)) {
8298 					mutex_exit(ST_MUTEX);
8299 					goto done;
8300 				}
8301 		}
8302 
8303 		if (st_cmd(dev, SCMD_TEST_UNIT_READY, 0, SYNC_CMD)) {
8304 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8305 			    "st_check_media: TUR failed, going to retry\n");
8306 			un->un_mediastate = prev_state;
8307 			un->un_state = ST_STATE_OFFLINE;
8308 			goto retry;
8309 		}
8310 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8311 		    "st_check_media: media inserted\n");
8312 
8313 		/* this also rewinds the tape */
8314 		rval = st_tape_init(dev);
8315 		if (rval != 0) {
8316 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8317 			    "st_check_media : OFFLINE init failure ");
8318 			un->un_state = ST_STATE_OFFLINE;
8319 			un->un_fileno = -1;
8320 		} else {
8321 			un->un_state = ST_STATE_OPEN_PENDING_IO;
8322 			un->un_fileno = 0;
8323 			un->un_blkno = 0;
8324 		}
8325 	} else if ((un->un_mediastate == MTIO_EJECTED) &&
8326 		(un->un_state != ST_STATE_OFFLINE)) {
8327 		/*
8328 		 * supported devices must be rewound before ejection
8329 		 * rewind resets fileno & blkno
8330 		 */
8331 		un->un_laststate = un->un_state;
8332 		un->un_state = ST_STATE_OFFLINE;
8333 	}
8334 	mutex_exit(ST_MUTEX);
8335 done:
8336 	if (token) {
8337 		(void) scsi_watch_request_terminate(token,
8338 				SCSI_WATCH_TERMINATE_WAIT);
8339 		mutex_enter(ST_MUTEX);
8340 		un->un_swr_token = (opaque_t)NULL;
8341 		mutex_exit(ST_MUTEX);
8342 	}
8343 
8344 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_media: done\n");
8345 
8346 	return (rval);
8347 }
8348 
8349 /*
8350  * st_media_watch_cb() is called by scsi_watch_thread for
8351  * verifying the request sense data (if any)
8352  */
8353 static int
8354 st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
8355 {
8356 	struct scsi_status *statusp = resultp->statusp;
8357 	struct scsi_extended_sense *sensep = resultp->sensep;
8358 	uchar_t actual_sense_length = resultp->actual_sense_length;
8359 	struct scsi_tape *un;
8360 	enum mtio_state state = MTIO_NONE;
8361 	int instance;
8362 	dev_t dev = (dev_t)arg;
8363 
8364 	instance = MTUNIT(dev);
8365 	if ((un = ddi_get_soft_state(st_state, instance)) == NULL) {
8366 		return (-1);
8367 	}
8368 
8369 	mutex_enter(ST_MUTEX);
8370 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8371 		"st_media_watch_cb: status=%x, sensep=%p, len=%x\n",
8372 			*((char *)statusp), (void *)sensep,
8373 			actual_sense_length);
8374 
8375 	/*
8376 	 * if there was a check condition then sensep points to valid
8377 	 * sense data
8378 	 * if status was not a check condition but a reservation or busy
8379 	 * status then the new state is MTIO_NONE
8380 	 */
8381 	if (sensep) {
8382 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8383 		    "st_media_watch_cb: KEY=%x, ASC=%x, ASCQ=%x\n",
8384 		    sensep->es_key, sensep->es_add_code, sensep->es_qual_code);
8385 
8386 		switch (un->un_dp->type) {
8387 		default:
8388 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8389 	    "st_media_watch_cb: unknown drive type %d, default to ST_TYPE_HP\n",
8390 	    un->un_dp->type);
8391 		/* FALLTHROUGH */
8392 
8393 		case ST_TYPE_STC3490:	/* STK 4220 1/2" cartridge */
8394 		case ST_TYPE_FUJI:	/* 1/2" cartridge */
8395 		case ST_TYPE_HP:	/* HP 88780 1/2" reel */
8396 			if (un->un_dp->type == ST_TYPE_FUJI) {
8397 				ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8398 				    "st_media_watch_cb: ST_TYPE_FUJI\n");
8399 			} else {
8400 				ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8401 				    "st_media_watch_cb: ST_TYPE_HP\n");
8402 			}
8403 			switch (sensep->es_key) {
8404 			case KEY_UNIT_ATTENTION:
8405 				/* not ready to ready transition */
8406 				/* hp/es_qual_code == 80 on>off>on */
8407 				/* hp/es_qual_code == 0 on>off>unld>ld>on */
8408 				if (sensep->es_add_code == 0x28) {
8409 					state = MTIO_INSERTED;
8410 				}
8411 				break;
8412 			case KEY_NOT_READY:
8413 				/* in process, rewinding or loading */
8414 				if ((sensep->es_add_code == 0x04) &&
8415 				    (sensep->es_qual_code == 0x00)) {
8416 					state = MTIO_EJECTED;
8417 				}
8418 				break;
8419 			}
8420 			break;
8421 
8422 		case ST_TYPE_EXB8500:	/* Exabyte 8500 */
8423 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8424 			    "st_media_watch_cb: ST_TYPE_EXB8500\n");
8425 			switch (sensep->es_key) {
8426 			case KEY_UNIT_ATTENTION:
8427 				/* operator medium removal request */
8428 				if ((sensep->es_add_code == 0x5a) &&
8429 				    (sensep->es_qual_code == 0x01)) {
8430 					state = MTIO_EJECTED;
8431 				/* not ready to ready transition */
8432 				} else if ((sensep->es_add_code == 0x28) &&
8433 				    (sensep->es_qual_code == 0x00)) {
8434 					state = MTIO_INSERTED;
8435 				}
8436 				break;
8437 			case KEY_NOT_READY:
8438 				/* medium not present */
8439 				if (sensep->es_add_code == 0x3a) {
8440 					state = MTIO_EJECTED;
8441 				}
8442 				break;
8443 			}
8444 			break;
8445 		case ST_TYPE_EXABYTE:	/* Exabyte 8200 */
8446 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8447 			    "st_media_watch_cb: ST_TYPE_EXABYTE\n");
8448 			switch (sensep->es_key) {
8449 			case KEY_NOT_READY:
8450 				if ((sensep->es_add_code == 0x04) &&
8451 				    (sensep->es_qual_code == 0x00)) {
8452 					/* volume not mounted? */
8453 					state = MTIO_EJECTED;
8454 				} else if (sensep->es_add_code == 0x3a) {
8455 					state = MTIO_EJECTED;
8456 				}
8457 				break;
8458 			case KEY_UNIT_ATTENTION:
8459 				state = MTIO_EJECTED;
8460 				break;
8461 			}
8462 			break;
8463 
8464 		case ST_TYPE_DLT:		/* quantum DLT4xxx */
8465 			switch (sensep->es_key) {
8466 			case KEY_UNIT_ATTENTION:
8467 				if (sensep->es_add_code == 0x28) {
8468 					state = MTIO_INSERTED;
8469 				}
8470 				break;
8471 			case KEY_NOT_READY:
8472 				if (sensep->es_add_code == 0x04) {
8473 					/* in transition but could be either */
8474 					state = un->un_specified_mediastate;
8475 				} else if ((sensep->es_add_code == 0x3a) &&
8476 				    (sensep->es_qual_code == 0x00)) {
8477 					state = MTIO_EJECTED;
8478 				}
8479 				break;
8480 			}
8481 			break;
8482 		}
8483 	} else if (*((char *)statusp) == STATUS_GOOD) {
8484 		state = MTIO_INSERTED;
8485 	}
8486 
8487 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8488 		"st_media_watch_cb:state=%x, specified=%x\n",
8489 		state, un->un_specified_mediastate);
8490 
8491 	/*
8492 	 * now signal the waiting thread if this is *not* the specified state;
8493 	 * delay the signal if the state is MTIO_INSERTED
8494 	 * to allow the target to recover
8495 	 */
8496 	if (state != un->un_specified_mediastate) {
8497 		un->un_mediastate = state;
8498 		if (state == MTIO_INSERTED) {
8499 			/*
8500 			 * delay the signal to give the drive a chance
8501 			 * to do what it apparently needs to do
8502 			 */
8503 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8504 			    "st_media_watch_cb:delayed cv_broadcast\n");
8505 			un->un_delay_tid = timeout(st_delayed_cv_broadcast,
8506 			    un, drv_usectohz((clock_t)MEDIA_ACCESS_DELAY));
8507 		} else {
8508 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8509 				"st_media_watch_cb:immediate cv_broadcast\n");
8510 			cv_broadcast(&un->un_state_cv);
8511 		}
8512 	}
8513 	mutex_exit(ST_MUTEX);
8514 	return (0);
8515 }
8516 
8517 /*
8518  * delayed cv_broadcast to allow for target to recover
8519  * from media insertion
8520  */
8521 static void
8522 st_delayed_cv_broadcast(void *arg)
8523 {
8524 	struct scsi_tape *un = arg;
8525 
8526 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8527 		"st_delayed_cv_broadcast:delayed cv_broadcast\n");
8528 
8529 	mutex_enter(ST_MUTEX);
8530 	cv_broadcast(&un->un_state_cv);
8531 	mutex_exit(ST_MUTEX);
8532 }
8533 
8534 /*
8535  * restart cmd currently at the start of the waitq
8536  */
8537 static void
8538 st_start_restart(void *arg)
8539 {
8540 	struct scsi_tape *un = arg;
8541 
8542 	ASSERT(un != NULL);
8543 
8544 	mutex_enter(ST_MUTEX);
8545 
8546 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8547 		"st_tran_restart()\n");
8548 
8549 	if (un->un_quef) {
8550 		st_start(un);
8551 	}
8552 
8553 	mutex_exit(ST_MUTEX);
8554 }
8555 
8556 
8557 /*
8558  * Command completion processing
8559  *
8560  */
8561 static void
8562 st_intr(struct scsi_pkt *pkt)
8563 {
8564 	struct scsi_tape *un;
8565 	struct buf *last_runqf;
8566 	struct buf *bp;
8567 	int action = COMMAND_DONE;
8568 	clock_t	timout;
8569 	int	status;
8570 
8571 	bp = (struct buf *)pkt->pkt_private;
8572 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
8573 
8574 	mutex_enter(ST_MUTEX);
8575 
8576 	un->un_rqs_state &= ~(ST_RQS_ERROR);
8577 
8578 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_intr()\n");
8579 
8580 	if (pkt->pkt_reason != CMD_CMPLT) {
8581 
8582 		/* If device has gone away not much else to do */
8583 		if (pkt->pkt_reason == CMD_DEV_GONE) {
8584 			action = COMMAND_DONE_ERROR;
8585 		} else if (un->un_state == ST_STATE_SENSING) {
8586 			ST_DO_ERRSTATS(un, st_transerrs);
8587 			action = COMMAND_DONE_ERROR;
8588 		} else {
8589 			action = st_handle_incomplete(un, bp);
8590 		}
8591 	/*
8592 	 * At this point we know that the command was successfully
8593 	 * completed. Now what?
8594 	 */
8595 	} else if (un->un_arq_enabled &&
8596 	    (pkt->pkt_state & STATE_ARQ_DONE)) {
8597 		/*
8598 		 * the transport layer successfully completed an autorqsense
8599 		 */
8600 		action = st_handle_autosense(un, bp);
8601 
8602 	} else if (un->un_state == ST_STATE_SENSING) {
8603 		/*
8604 		 * okay. We were running a REQUEST SENSE. Find
8605 		 * out what to do next.
8606 		 * some actions are based on un_state, hence
8607 		 * restore the state st was in before ST_STATE_SENSING.
8608 		 */
8609 		un->un_state = un->un_laststate;
8610 		action = st_handle_sense(un, bp);
8611 		/*
8612 		 * set pkt back to original packet in case we will have
8613 		 * to requeue it
8614 		 */
8615 		pkt = BP_PKT(bp);
8616 	} else  if ((SCBP(pkt)->sts_busy) || (SCBP(pkt)->sts_chk)) {
8617 		/*
8618 		 * Okay, we weren't running a REQUEST SENSE. Call a routine
8619 		 * to see if the status bits we're okay. If a request sense
8620 		 * is to be run, that will happen.
8621 		 */
8622 		action = st_check_error(un, pkt);
8623 	}
8624 
8625 	if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
8626 		switch (action) {
8627 			case QUE_COMMAND:
8628 				/*
8629 				 * return cmd to head to the queue
8630 				 * since we are suspending so that
8631 				 * it gets restarted during resume
8632 				 */
8633 				if (un->un_runqf) {
8634 					last_runqf = un->un_runqf;
8635 					un->un_runqf = bp;
8636 					bp->b_actf = last_runqf;
8637 				} else {
8638 					bp->b_actf = NULL;
8639 					un->un_runqf = bp;
8640 					un->un_runql = bp;
8641 				}
8642 				action = JUST_RETURN;
8643 				break;
8644 
8645 			case QUE_SENSE:
8646 				action = COMMAND_DONE_ERROR;
8647 				break;
8648 
8649 			default:
8650 				break;
8651 		}
8652 	}
8653 
8654 	/*
8655 	 * Restore old state if we were sensing.
8656 	 */
8657 	if (un->un_state == ST_STATE_SENSING && action != QUE_SENSE) {
8658 		un->un_state = un->un_laststate;
8659 	}
8660 
8661 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8662 	    "st_intr: pkt=%p, bp=%p, action=%x, status=%x\n",
8663 	    (void *)pkt, (void *)bp, action, SCBP_C(pkt));
8664 
8665 
8666 	switch (action) {
8667 	case COMMAND_DONE_EACCES:
8668 		/* this is to report a reservation conflict */
8669 		st_bioerror(bp, EACCES);
8670 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8671 			"Reservation Conflict \n");
8672 
8673 		/*FALLTHROUGH*/
8674 	case COMMAND_DONE_ERROR:
8675 		if (un->un_eof < ST_EOT_PENDING &&
8676 		    un->un_state >= ST_STATE_OPEN) {
8677 			/*
8678 			 * all errors set state of the tape to 'unknown'
8679 			 * unless we're at EOT or are doing append testing.
8680 			 * If sense key was illegal request, preserve state.
8681 			 */
8682 			if (un->un_status != KEY_ILLEGAL_REQUEST) {
8683 				un->un_fileno = -1;
8684 			}
8685 		}
8686 		un->un_err_resid = bp->b_resid = bp->b_bcount;
8687 		/*
8688 		 * since we have an error (COMMAND_DONE_ERROR), we want to
8689 		 * make sure an error ocurrs, so make sure at least EIO is
8690 		 * returned
8691 		 */
8692 		if (geterror(bp) == 0)
8693 			st_bioerror(bp, EIO);
8694 
8695 		SET_PE_FLAG(un);
8696 		if (!(un->un_rqs_state & ST_RQS_ERROR) &&
8697 		    (un->un_errno == EIO)) {
8698 			un->un_rqs_state &= ~(ST_RQS_VALID);
8699 		}
8700 		goto done;
8701 
8702 	case COMMAND_DONE_ERROR_RECOVERED:
8703 		un->un_err_resid = bp->b_resid = bp->b_bcount;
8704 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
8705 		    "st_intr(): COMMAND_DONE_ERROR_RECOVERED");
8706 		if (geterror(bp) == 0)
8707 			st_bioerror(bp, EIO);
8708 		SET_PE_FLAG(un);
8709 		if (!(un->un_rqs_state & ST_RQS_ERROR) &&
8710 		    (un->un_errno == EIO)) {
8711 			un->un_rqs_state &= ~(ST_RQS_VALID);
8712 		}
8713 		/*FALLTHROUGH*/
8714 	case COMMAND_DONE:
8715 		st_set_state(un);
8716 done:
8717 		ST_DO_KSTATS(bp, kstat_runq_exit);
8718 		st_done_and_mutex_exit(un, bp);
8719 		return;
8720 
8721 	case QUE_SENSE:
8722 		if ((un->un_ncmds > 1) && !un->un_flush_on_errors)
8723 			goto sense_error;
8724 
8725 		if (un->un_state != ST_STATE_SENSING) {
8726 			un->un_laststate = un->un_state;
8727 			un->un_state = ST_STATE_SENSING;
8728 		}
8729 
8730 		un->un_rqs->pkt_private = (opaque_t)bp;
8731 		bzero(ST_RQSENSE, SENSE_LENGTH);
8732 
8733 		if (un->un_throttle) {
8734 			un->un_last_throttle = un->un_throttle;
8735 			un->un_throttle = 0;
8736 		}
8737 
8738 		mutex_exit(ST_MUTEX);
8739 
8740 		/*
8741 		 * never retry this, some other command will have nuked the
8742 		 * sense, anyway
8743 		 */
8744 		status = scsi_transport(un->un_rqs);
8745 
8746 		mutex_enter(ST_MUTEX);
8747 
8748 		if (un->un_last_throttle) {
8749 			un->un_throttle = un->un_last_throttle;
8750 		}
8751 
8752 		if (status == TRAN_ACCEPT) {
8753 			mutex_exit(ST_MUTEX);
8754 			return;
8755 		}
8756 		if (status != TRAN_BUSY)
8757 			ST_DO_ERRSTATS(un, st_transerrs);
8758 sense_error:
8759 		un->un_fileno = -1;
8760 		st_bioerror(bp, EIO);
8761 		SET_PE_FLAG(un);
8762 		goto done;
8763 
8764 	case QUE_BUSY_COMMAND:
8765 		/* longish timeout */
8766 		timout = ST_STATUS_BUSY_TIMEOUT;
8767 		goto que_it_up;
8768 
8769 	case QUE_COMMAND:
8770 		/* short timeout */
8771 		timout = ST_TRAN_BUSY_TIMEOUT;
8772 que_it_up:
8773 		/*
8774 		 * let st_handle_intr_busy put this bp back on waitq and make
8775 		 * checks to see if it is ok to requeue the command.
8776 		 */
8777 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
8778 
8779 		/*
8780 		 * Save the throttle before setting up the timeout
8781 		 */
8782 		if (un->un_throttle) {
8783 			un->un_last_throttle = un->un_throttle;
8784 		}
8785 		mutex_exit(ST_MUTEX);
8786 		if (st_handle_intr_busy(un, bp, timout) == 0)
8787 			return;		/* timeout is setup again */
8788 
8789 		mutex_enter(ST_MUTEX);
8790 		un->un_fileno = -1;
8791 		un->un_err_resid = bp->b_resid = bp->b_bcount;
8792 		st_bioerror(bp, EIO);
8793 		SET_PE_FLAG(un);
8794 		goto done;
8795 
8796 	case QUE_LAST_COMMAND:
8797 
8798 		if ((un->un_ncmds > 1) && !un->un_flush_on_errors) {
8799 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
8800 			    "un_ncmds: %d can't retry cmd \n", un->un_ncmds);
8801 			goto last_command_error;
8802 		}
8803 		mutex_exit(ST_MUTEX);
8804 		if (st_handle_intr_retry_lcmd(un, bp) == 0)
8805 			return;
8806 		mutex_enter(ST_MUTEX);
8807 last_command_error:
8808 		un->un_err_resid = bp->b_resid = bp->b_bcount;
8809 		un->un_fileno = -1;
8810 		st_bioerror(bp, EIO);
8811 		SET_PE_FLAG(un);
8812 		goto done;
8813 
8814 	case JUST_RETURN:
8815 	default:
8816 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
8817 		mutex_exit(ST_MUTEX);
8818 		return;
8819 	}
8820 	/*NOTREACHED*/
8821 }
8822 
8823 static int
8824 st_handle_incomplete(struct scsi_tape *un, struct buf *bp)
8825 {
8826 	static char *fail = "SCSI transport failed: reason '%s': %s\n";
8827 	int rval = COMMAND_DONE_ERROR;
8828 	struct scsi_pkt *pkt = (un->un_state == ST_STATE_SENSING) ?
8829 			un->un_rqs : BP_PKT(bp);
8830 	int result;
8831 
8832 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8833 		"st_handle_incomplete(): dev = 0x%lx\n", un->un_dev);
8834 
8835 	ASSERT(mutex_owned(ST_MUTEX));
8836 
8837 	switch (pkt->pkt_reason) {
8838 	case CMD_INCOMPLETE:	/* tran stopped with not normal state */
8839 		/*
8840 		 * this occurs when accessing a powered down drive, no
8841 		 * need to complain; just fail the open
8842 		 */
8843 #ifdef STDEBUG
8844 		if (st_debug >= 1) {
8845 			st_clean_print(ST_DEVINFO, st_label, CE_WARN,
8846 			    "Failed CDB", (char *)pkt->pkt_cdbp, CDB_SIZE);
8847 		}
8848 
8849 #endif
8850 		/*
8851 		 * if we have commands outstanding in HBA, and a command
8852 		 * comes back incomplete, we're hosed, so reset target
8853 		 * If we have the bus, but cmd_incomplete, we probably just
8854 		 * have a failed selection, so don't reset the target, just
8855 		 * requeue the command and try again
8856 		 */
8857 		if ((un->un_ncmds > 1) || (pkt->pkt_state != STATE_GOT_BUS)) {
8858 			goto reset_target;
8859 		}
8860 
8861 		/*
8862 		 * Retry selection a couple more times if we're
8863 		 * open.  If opening, we only try just once to
8864 		 * reduce probe time for nonexistant devices.
8865 		 */
8866 		if ((un->un_laststate > ST_STATE_OPENING) &&
8867 		    ((int)un->un_retry_ct < st_selection_retry_count)) {
8868 			rval = QUE_COMMAND;
8869 		}
8870 		ST_DO_ERRSTATS(un, st_transerrs);
8871 		break;
8872 
8873 	case CMD_ABORTED:
8874 		/*
8875 		 * most likely this is caused by flush-on-error support. If
8876 		 * it was not there, the we're in trouble.
8877 		 */
8878 		if (!un->un_flush_on_errors) {
8879 			un->un_status = SUN_KEY_FATAL;
8880 			goto reset_target;
8881 		}
8882 
8883 		st_set_pe_errno(un);
8884 		bioerror(bp, un->un_errno);
8885 		if (un->un_errno)
8886 			return (COMMAND_DONE_ERROR);
8887 		else
8888 			return (COMMAND_DONE);
8889 
8890 	case CMD_TIMEOUT:	/* Command timed out */
8891 		un->un_status = SUN_KEY_TIMEOUT;
8892 
8893 		/*FALLTHROUGH*/
8894 	default:
8895 reset_target:
8896 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
8897 		    "transport completed with %s\n",
8898 		    scsi_rname(pkt->pkt_reason));
8899 		ST_DO_ERRSTATS(un, st_transerrs);
8900 		if ((pkt->pkt_state & STATE_GOT_TARGET) &&
8901 		    ((pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET |
8902 			STAT_ABORTED)) == 0)) {
8903 
8904 			mutex_exit(ST_MUTEX);
8905 
8906 			result = scsi_reset(ROUTE, RESET_TARGET);
8907 			/*
8908 			 * if target reset fails, then pull the chain
8909 			 */
8910 			if (result == 0) {
8911 				result = scsi_reset(ROUTE, RESET_ALL);
8912 			}
8913 			mutex_enter(ST_MUTEX);
8914 
8915 			if ((result == 0) && (un->un_state >= ST_STATE_OPEN)) {
8916 				/* no hope left to recover */
8917 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
8918 				    "recovery by resets failed\n");
8919 				return (rval);
8920 			}
8921 		}
8922 	}
8923 
8924 	if ((pkt->pkt_reason == CMD_RESET) || (pkt->pkt_statistics &
8925 		(STAT_BUS_RESET | STAT_DEV_RESET))) {
8926 		if ((un->un_rsvd_status & ST_RESERVE)) {
8927 			un->un_rsvd_status |= ST_LOST_RESERVE;
8928 			ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
8929 				"Lost Reservation\n");
8930 		}
8931 	}
8932 
8933 	if ((int)un->un_retry_ct++ < st_retry_count) {
8934 		if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
8935 			rval = QUE_COMMAND;
8936 		} else if (bp == un->un_sbufp) {
8937 			switch ((uchar_t)(uintptr_t)bp->b_forw) {
8938 			case SCMD_MODE_SENSE:
8939 			case SCMD_MODE_SELECT:
8940 			case SCMD_READ_BLKLIM:
8941 			case SCMD_REWIND:
8942 			case SCMD_LOAD:
8943 			case SCMD_TEST_UNIT_READY:
8944 				/*
8945 				 * These commands can be rerun with impunity
8946 				 */
8947 				rval = QUE_COMMAND;
8948 				break;
8949 
8950 			default:
8951 				break;
8952 			}
8953 		}
8954 	} else {
8955 		rval = COMMAND_DONE_ERROR;
8956 	}
8957 
8958 	if (un->un_state >= ST_STATE_OPEN) {
8959 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
8960 		    fail, scsi_rname(pkt->pkt_reason),
8961 		    (rval == COMMAND_DONE_ERROR)?
8962 		    "giving up" : "retrying command");
8963 	}
8964 	return (rval);
8965 }
8966 
8967 /*
8968  * if the device is busy, then put this bp back on the waitq, on the
8969  * interrupt thread, where we want the head of the queue and not the
8970  * end
8971  *
8972  * The callers of this routine should take measures to save the
8973  * un_throttle in un_last_throttle which will be restored in
8974  * st_intr_restart(). The only exception should be st_intr_restart()
8975  * calling this routine for which the saving is already done.
8976  */
8977 static int
8978 st_handle_intr_busy(struct scsi_tape *un, struct buf *bp,
8979 	clock_t timeout_interval)
8980 {
8981 	struct buf *last_quef;
8982 	int rval = 0;
8983 
8984 	mutex_enter(ST_MUTEX);
8985 
8986 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8987 	    "st_handle_intr_busy(), un = 0x%p\n", (void *)un);
8988 
8989 	/*
8990 	 * Check to see if we hit the retry timeout. We check to make sure
8991 	 * this is the first one on the runq and make sure we have not
8992 	 * queued up any more, so this one has to be the last on the list
8993 	 * also. If it is not, we have to fail.  If it is not the first, but
8994 	 * is the last we are in trouble anyway, as we are in the interrupt
8995 	 * context here.
8996 	 */
8997 	if (((int)un->un_tran_retry_ct++ > st_retry_count) ||
8998 	    ((un->un_runqf != bp) && (un->un_runql != bp))) {
8999 		rval = -1;
9000 		goto exit;
9001 	}
9002 
9003 	/* put the bp back on the waitq */
9004 	if (un->un_quef) {
9005 		last_quef = un->un_quef;
9006 		un->un_quef = bp;
9007 		bp->b_actf = last_quef;
9008 	} else  {
9009 		bp->b_actf = NULL;
9010 		un->un_quef = bp;
9011 		un->un_quel = bp;
9012 	}
9013 
9014 	/*
9015 	 * We know that this is the first and last on the runq at this time,
9016 	 * so we just nullify those two queues
9017 	 */
9018 	un->un_runqf = NULL;
9019 	un->un_runql = NULL;
9020 
9021 	/*
9022 	 * We don't want any other commands being started in the mean time.
9023 	 * If start had just released mutex after putting something on the
9024 	 * runq, we won't even get here.
9025 	 */
9026 	un->un_throttle = 0;
9027 
9028 	/*
9029 	 * send a marker pkt, if appropriate
9030 	 */
9031 	st_hba_unflush(un);
9032 
9033 	/*
9034 	 * all queues are aligned, we are just waiting to
9035 	 * transport
9036 	 */
9037 	un->un_hib_tid = timeout(st_intr_restart, un, timeout_interval);
9038 
9039 exit:
9040 	mutex_exit(ST_MUTEX);
9041 	return (rval);
9042 }
9043 
9044 static int
9045 st_handle_sense(struct scsi_tape *un, struct buf *bp)
9046 {
9047 	struct scsi_pkt *rqpkt = un->un_rqs;
9048 	int rval = COMMAND_DONE_ERROR;
9049 	int amt;
9050 
9051 	ASSERT(mutex_owned(ST_MUTEX));
9052 
9053 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9054 		"st_handle_sense()\n");
9055 
9056 	if (SCBP(rqpkt)->sts_busy) {
9057 		ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN,
9058 		    "busy unit on request sense\n");
9059 		if ((int)un->un_retry_ct++ < st_retry_count) {
9060 			rval = QUE_BUSY_COMMAND;
9061 		}
9062 		return (rval);
9063 	} else if (SCBP(rqpkt)->sts_chk) {
9064 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9065 		    "Check Condition on REQUEST SENSE\n");
9066 		return (rval);
9067 	}
9068 
9069 	/* was there enough data? */
9070 	amt = (int)SENSE_LENGTH - rqpkt->pkt_resid;
9071 	if ((rqpkt->pkt_state & STATE_XFERRED_DATA) == 0 ||
9072 	    (amt < SUN_MIN_SENSE_LENGTH)) {
9073 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9074 		    "REQUEST SENSE couldn't get sense data\n");
9075 		return (rval);
9076 	}
9077 	return (st_decode_sense(un, bp, amt, SCBP(rqpkt)));
9078 }
9079 
9080 static int
9081 st_handle_autosense(struct scsi_tape *un, struct buf *bp)
9082 {
9083 	struct scsi_pkt *pkt = BP_PKT(bp);
9084 	struct scsi_arq_status *arqstat =
9085 	    (struct scsi_arq_status *)pkt->pkt_scbp;
9086 	int rval = COMMAND_DONE_ERROR;
9087 	int amt;
9088 
9089 	ASSERT(mutex_owned(ST_MUTEX));
9090 
9091 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9092 		"st_handle_autosense()\n");
9093 
9094 	if (arqstat->sts_rqpkt_status.sts_busy) {
9095 		ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN,
9096 		    "busy unit on request sense\n");
9097 		/*
9098 		 * we return QUE_SENSE so st_intr will setup the SENSE cmd.
9099 		 * the disadvantage is that we do not have any delay for the
9100 		 * second retry of rqsense and we have to keep a packet around
9101 		 */
9102 		return (QUE_SENSE);
9103 
9104 	} else if (arqstat->sts_rqpkt_reason != CMD_CMPLT) {
9105 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9106 		    "transport error on REQUEST SENSE\n");
9107 		if ((arqstat->sts_rqpkt_state & STATE_GOT_TARGET) &&
9108 		    ((arqstat->sts_rqpkt_statistics &
9109 		    (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) == 0)) {
9110 			mutex_exit(ST_MUTEX);
9111 			if (scsi_reset(ROUTE, RESET_TARGET) == 0) {
9112 				/*
9113 				 * if target reset fails, then pull the chain
9114 				 */
9115 				if (scsi_reset(ROUTE, RESET_ALL) == 0) {
9116 					ST_DEBUG6(ST_DEVINFO, st_label,
9117 					    CE_WARN,
9118 					    "recovery by resets failed\n");
9119 				}
9120 			}
9121 			mutex_enter(ST_MUTEX);
9122 		}
9123 		return (rval);
9124 
9125 	} else if (arqstat->sts_rqpkt_status.sts_chk) {
9126 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9127 		    "Check Condition on REQUEST SENSE\n");
9128 		return (rval);
9129 	}
9130 
9131 
9132 	/* was there enough data? */
9133 	amt = (int)SENSE_LENGTH - arqstat->sts_rqpkt_resid;
9134 	if ((arqstat->sts_rqpkt_state & STATE_XFERRED_DATA) == 0 ||
9135 	    (amt < SUN_MIN_SENSE_LENGTH)) {
9136 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9137 		    "REQUEST SENSE couldn't get sense data\n");
9138 		return (rval);
9139 	}
9140 
9141 	bcopy(&arqstat->sts_sensedata, ST_RQSENSE, SENSE_LENGTH);
9142 
9143 	return (st_decode_sense(un, bp, amt, &arqstat->sts_rqpkt_status));
9144 }
9145 
9146 static int
9147 st_decode_sense(struct scsi_tape *un, struct buf *bp,  int amt,
9148 	struct scsi_status *statusp)
9149 {
9150 	struct scsi_pkt *pkt = BP_PKT(bp);
9151 	int rval = COMMAND_DONE_ERROR;
9152 	long resid;
9153 	struct scsi_extended_sense *sensep = ST_RQSENSE;
9154 	int severity;
9155 	int get_error;
9156 
9157 	ASSERT(mutex_owned(ST_MUTEX));
9158 
9159 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9160 		"st_decode_sense()\n");
9161 
9162 	/*
9163 	 * For uscsi commands, squirrel away a copy of the
9164 	 * results of the Request Sense.
9165 	 */
9166 	if (USCSI_CMD(bp)) {
9167 		struct uscsi_cmd *ucmd = BP_UCMD(bp);
9168 		ucmd->uscsi_rqstatus = *(uchar_t *)statusp;
9169 		if (ucmd->uscsi_rqlen && un->un_srqbufp) {
9170 			uchar_t rqlen = min((uchar_t)amt, ucmd->uscsi_rqlen);
9171 			ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen;
9172 			bcopy(ST_RQSENSE, un->un_srqbufp, rqlen);
9173 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9174 				"st_decode_sense: stat=0x%x resid=0x%x\n",
9175 				ucmd->uscsi_rqstatus, ucmd->uscsi_rqresid);
9176 		}
9177 	}
9178 
9179 	/*
9180 	 * If the drive is an MT-02, reposition the
9181 	 * secondary error code into the proper place.
9182 	 *
9183 	 * XXX	MT-02 is non-CCS tape, so secondary error code
9184 	 * is in byte 8.  However, in SCSI-2, tape has CCS definition
9185 	 * so it's in byte 12.
9186 	 */
9187 	if (un->un_dp->type == ST_TYPE_EMULEX) {
9188 		sensep->es_code = sensep->es_add_info[0];
9189 	}
9190 
9191 	/* for normal I/O check extract the resid values. */
9192 	if (bp != un->un_sbufp) {
9193 		if (sensep->es_valid) {
9194 			resid = (sensep->es_info_1 << 24) |
9195 				(sensep->es_info_2 << 16) |
9196 				(sensep->es_info_3 << 8)  |
9197 				(sensep->es_info_4);
9198 			if (un->un_bsize) {
9199 				resid *= un->un_bsize;
9200 			}
9201 		} else if (pkt->pkt_state & STATE_XFERRED_DATA) {
9202 			resid = pkt->pkt_resid;
9203 		} else {
9204 			resid = bp->b_bcount;
9205 		}
9206 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9207 		    "st_handle_sense (rw): xferred bit = %d, resid=%ld (%d), "
9208 		    "pkt_resid=%ld\n", pkt->pkt_state & STATE_XFERRED_DATA,
9209 		    resid,
9210 		    (sensep->es_info_1 << 24) |
9211 		    (sensep->es_info_2 << 16) |
9212 		    (sensep->es_info_3 << 8)  |
9213 		    (sensep->es_info_4),
9214 		    pkt->pkt_resid);
9215 		/*
9216 		 * The problem is, what should we believe?
9217 		 */
9218 		if (resid && (pkt->pkt_resid == 0)) {
9219 			pkt->pkt_resid = resid;
9220 		}
9221 	} else {
9222 		/*
9223 		 * If the command is SCMD_SPACE, we need to get the
9224 		 * residual as returned in the sense data, to adjust
9225 		 * our idea of current tape position correctly
9226 		 */
9227 		if ((CDBP(pkt)->scc_cmd == SCMD_SPACE ||
9228 		    CDBP(pkt)->scc_cmd == SCMD_WRITE_FILE_MARK) &&
9229 		    (sensep->es_valid)) {
9230 			resid = (sensep->es_info_1 << 24) |
9231 			    (sensep->es_info_2 << 16) |
9232 			    (sensep->es_info_3 << 8)  |
9233 			    (sensep->es_info_4);
9234 			bp->b_resid = resid;
9235 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9236 			    "st_handle_sense(other):	resid=%ld\n",
9237 			    resid);
9238 		} else {
9239 			/*
9240 			 * If the special command is SCMD_READ,
9241 			 * the correct resid will be set later.
9242 			 */
9243 			resid = bp->b_bcount;
9244 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9245 			    "st_handle_sense(special read):  resid=%ld\n",
9246 				resid);
9247 		}
9248 	}
9249 
9250 	if ((un->un_state >= ST_STATE_OPEN) &&
9251 	    (DEBUGGING || st_error_level == SCSI_ERR_ALL)) {
9252 		st_clean_print(ST_DEVINFO, st_label, CE_NOTE,
9253 		    "Failed CDB", (char *)pkt->pkt_cdbp, CDB_SIZE);
9254 		st_clean_print(ST_DEVINFO, st_label, CE_CONT,
9255 		    "sense data", (char *)sensep, amt);
9256 		scsi_log(ST_DEVINFO, st_label, CE_CONT,
9257 		    "count 0x%lx resid 0x%lx pktresid 0x%lx\n",
9258 		    bp->b_bcount, resid, pkt->pkt_resid);
9259 	}
9260 
9261 	switch (un->un_status = sensep->es_key) {
9262 	case KEY_NO_SENSE:
9263 		severity = SCSI_ERR_INFO;
9264 		goto common;
9265 
9266 	case KEY_RECOVERABLE_ERROR:
9267 		severity = SCSI_ERR_RECOVERED;
9268 		if ((sensep->es_class == CLASS_EXTENDED_SENSE) &&
9269 		    (sensep->es_code == ST_DEFERRED_ERROR)) {
9270 		    if (un->un_dp->options &
9271 			ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) {
9272 			    rval = QUE_LAST_COMMAND;
9273 			    scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity,
9274 				un->un_blkno, un->un_err_blkno, scsi_cmds,
9275 				sensep);
9276 			    scsi_log(ST_DEVINFO, st_label, CE_CONT,
9277 				"Command will be retried\n");
9278 			} else {
9279 			    severity = SCSI_ERR_FATAL;
9280 			    rval = COMMAND_DONE_ERROR_RECOVERED;
9281 			    ST_DO_ERRSTATS(un, st_softerrs);
9282 			    scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity,
9283 				un->un_blkno, un->un_err_blkno, scsi_cmds,
9284 				sensep);
9285 			}
9286 			break;
9287 		}
9288 common:
9289 		/*
9290 		 * XXX only want reads to be stopped by filemarks.
9291 		 * Don't want them to be stopped by EOT.  EOT matters
9292 		 * only on write.
9293 		 */
9294 		if (sensep->es_filmk && !sensep->es_eom) {
9295 			rval = COMMAND_DONE;
9296 		} else if (sensep->es_eom) {
9297 			rval = COMMAND_DONE;
9298 		} else if (sensep->es_ili) {
9299 			/*
9300 			 * Fun with variable length record devices:
9301 			 * for specifying larger blocks sizes than the
9302 			 * actual physical record size.
9303 			 */
9304 			if (un->un_bsize == 0 && resid > 0) {
9305 				/*
9306 				 * XXX! Ugly.
9307 				 * The requested blocksize is > tape blocksize,
9308 				 * so this is ok, so we just return the
9309 				 * actual size xferred.
9310 				 */
9311 				pkt->pkt_resid = resid;
9312 				rval = COMMAND_DONE;
9313 			} else if (un->un_bsize == 0 && resid < 0) {
9314 				/*
9315 				 * The requested blocksize is < tape blocksize,
9316 				 * so this is not ok, so we err with ENOMEM
9317 				 */
9318 				rval = COMMAND_DONE_ERROR_RECOVERED;
9319 				st_bioerror(bp, ENOMEM);
9320 			} else {
9321 				ST_DO_ERRSTATS(un, st_softerrs);
9322 				severity = SCSI_ERR_FATAL;
9323 				rval = COMMAND_DONE_ERROR;
9324 				st_bioerror(bp, EINVAL);
9325 			}
9326 		} else {
9327 			/*
9328 			 * we hope and pray for this just being
9329 			 * something we can ignore (ie. a
9330 			 * truly recoverable soft error)
9331 			 */
9332 			rval = COMMAND_DONE;
9333 		}
9334 		if (sensep->es_filmk) {
9335 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9336 			    "filemark\n");
9337 			un->un_status = SUN_KEY_EOF;
9338 			un->un_eof = ST_EOF_PENDING;
9339 			SET_PE_FLAG(un);
9340 		}
9341 
9342 		/*
9343 		 * ignore eom when reading, a fmk should terminate reading
9344 		 */
9345 		if ((sensep->es_eom) &&
9346 		    (CDBP(pkt)->scc_cmd != SCMD_READ)) {
9347 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "eom\n");
9348 			un->un_status = SUN_KEY_EOT;
9349 			un->un_eof = ST_EOM;
9350 			SET_PE_FLAG(un);
9351 		}
9352 
9353 		break;
9354 
9355 	case KEY_ILLEGAL_REQUEST:
9356 
9357 		if (un->un_laststate >= ST_STATE_OPEN) {
9358 			ST_DO_ERRSTATS(un, st_softerrs);
9359 			severity = SCSI_ERR_FATAL;
9360 		} else {
9361 			severity = SCSI_ERR_INFO;
9362 		}
9363 		break;
9364 
9365 	case KEY_MEDIUM_ERROR:
9366 		ST_DO_ERRSTATS(un, st_harderrs);
9367 		severity = SCSI_ERR_FATAL;
9368 
9369 		/*
9370 		 * for (buffered) writes, a medium error must be fatal
9371 		 */
9372 		if (CDBP(pkt)->scc_cmd != SCMD_WRITE) {
9373 			rval = COMMAND_DONE_ERROR_RECOVERED;
9374 		}
9375 
9376 check_keys:
9377 		/*
9378 		 * attempt to process the keys in the presence of
9379 		 * other errors
9380 		 */
9381 		if (sensep->es_ili && rval != COMMAND_DONE_ERROR) {
9382 			/*
9383 			 * Fun with variable length record devices:
9384 			 * for specifying larger blocks sizes than the
9385 			 * actual physical record size.
9386 			 */
9387 			if (un->un_bsize == 0 && resid > 0) {
9388 				/*
9389 				 * XXX! Ugly
9390 				 */
9391 				pkt->pkt_resid = resid;
9392 			} else if (un->un_bsize == 0 && resid < 0) {
9393 				st_bioerror(bp, EINVAL);
9394 			} else {
9395 				severity = SCSI_ERR_FATAL;
9396 				rval = COMMAND_DONE_ERROR;
9397 				st_bioerror(bp, EINVAL);
9398 			}
9399 		}
9400 		if (sensep->es_filmk) {
9401 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9402 			    "filemark\n");
9403 			un->un_status = SUN_KEY_EOF;
9404 			un->un_eof = ST_EOF_PENDING;
9405 			SET_PE_FLAG(un);
9406 		}
9407 
9408 		/*
9409 		 * ignore eom when reading, a fmk should terminate reading
9410 		 */
9411 		if ((sensep->es_eom) &&
9412 		    (CDBP(pkt)->scc_cmd != SCMD_READ)) {
9413 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "eom\n");
9414 			un->un_status = SUN_KEY_EOT;
9415 			un->un_eof = ST_EOM;
9416 			SET_PE_FLAG(un);
9417 		}
9418 
9419 		break;
9420 
9421 	case KEY_VOLUME_OVERFLOW:
9422 		ST_DO_ERRSTATS(un, st_softerrs);
9423 		un->un_eof = ST_EOM;
9424 		severity = SCSI_ERR_FATAL;
9425 		rval = COMMAND_DONE_ERROR;
9426 		goto check_keys;
9427 
9428 	case KEY_HARDWARE_ERROR:
9429 		ST_DO_ERRSTATS(un, st_harderrs);
9430 		severity = SCSI_ERR_FATAL;
9431 		rval = COMMAND_DONE_ERROR;
9432 		if (un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE)
9433 			un->un_eject_tape_on_failure = st_check_asc_ascq(un);
9434 		break;
9435 
9436 	case KEY_BLANK_CHECK:
9437 		ST_DO_ERRSTATS(un, st_softerrs);
9438 		severity = SCSI_ERR_INFO;
9439 
9440 		/*
9441 		 * if not a special request and some data was xferred then it
9442 		 * it is not an error yet
9443 		 */
9444 		if (bp != un->un_sbufp && (bp->b_flags & B_READ)) {
9445 			/*
9446 			 * no error for read with or without data xferred
9447 			 */
9448 			un->un_status = SUN_KEY_EOT;
9449 			un->un_eof = ST_EOT;
9450 			rval = COMMAND_DONE_ERROR;
9451 			SET_PE_FLAG(un);
9452 			goto check_keys;
9453 		} else if (bp != un->un_sbufp &&
9454 		    (pkt->pkt_state & STATE_XFERRED_DATA)) {
9455 			rval = COMMAND_DONE;
9456 		} else {
9457 			rval = COMMAND_DONE_ERROR_RECOVERED;
9458 		}
9459 
9460 		if (un->un_laststate >= ST_STATE_OPEN) {
9461 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9462 			    "blank check\n");
9463 			un->un_eof = ST_EOM;
9464 		}
9465 		if ((CDBP(pkt)->scc_cmd == SCMD_SPACE) &&
9466 		    (un->un_dp->options & ST_KNOWS_EOD) &&
9467 		    (severity = SCSI_ERR_INFO)) {
9468 			/*
9469 			 * we were doing a fast forward by skipping
9470 			 * multiple fmk at the time
9471 			 */
9472 			st_bioerror(bp, EIO);
9473 			severity = SCSI_ERR_RECOVERED;
9474 			rval	 = COMMAND_DONE;
9475 		}
9476 		SET_PE_FLAG(un);
9477 		goto check_keys;
9478 
9479 	case KEY_WRITE_PROTECT:
9480 		if (st_wrongtapetype(un)) {
9481 			un->un_status = SUN_KEY_WRONGMEDIA;
9482 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9483 		"wrong tape for writing- use DC6150 tape (or equivalent)\n");
9484 			severity = SCSI_ERR_UNKNOWN;
9485 		} else {
9486 			severity = SCSI_ERR_FATAL;
9487 		}
9488 		ST_DO_ERRSTATS(un, st_harderrs);
9489 		rval = COMMAND_DONE_ERROR;
9490 		st_bioerror(bp, EACCES);
9491 		break;
9492 
9493 	case KEY_UNIT_ATTENTION:
9494 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9495 		    "KEY_UNIT_ATTENTION : un_state = %d\n", un->un_state);
9496 
9497 		/*
9498 		 * If we have detected a Bus Reset and the tape
9499 		 * drive has been reserved.
9500 		 */
9501 		if (ST_RQSENSE->es_add_code == 0x29 &&
9502 			(un->un_rsvd_status & ST_RESERVE)) {
9503 			un->un_rsvd_status |= ST_LOST_RESERVE;
9504 			ST_DEBUG(ST_DEVINFO, st_label, CE_WARN,
9505 				"st_decode_sense: Lost Reservation\n");
9506 		}
9507 
9508 		if (un->un_state <= ST_STATE_OPENING) {
9509 			/*
9510 			 * Look, the tape isn't open yet, now determine
9511 			 * if the cause is a BUS RESET, Save the file and
9512 			 * Block positions for the callers to recover from
9513 			 * the loss of position.
9514 			 */
9515 			if ((un->un_fileno >= 0) &&
9516 			(un->un_fileno || un->un_blkno)) {
9517 				if (ST_RQSENSE->es_add_code == 0x29) {
9518 					un->un_save_fileno = un->un_fileno;
9519 					un->un_save_blkno = un->un_blkno;
9520 					un->un_restore_pos = 1;
9521 				}
9522 			}
9523 
9524 			if ((int)un->un_retry_ct++ < st_retry_count) {
9525 				rval = QUE_COMMAND;
9526 			} else {
9527 				rval = COMMAND_DONE_ERROR;
9528 			}
9529 			severity = SCSI_ERR_INFO;
9530 
9531 		} else {
9532 			/*
9533 			 * Check if it is an Unexpected Unit Attention.
9534 			 * If state is >= ST_STATE_OPEN, we have
9535 			 * already done the initialization .
9536 			 * In this case it is Fatal Error
9537 			 * since no further reading/writing
9538 			 * can be done with fileno set to < 0.
9539 			 */
9540 			if (un->un_state >= ST_STATE_OPEN) {
9541 				ST_DO_ERRSTATS(un, st_harderrs);
9542 				severity = SCSI_ERR_FATAL;
9543 			} else {
9544 				severity = SCSI_ERR_INFO;
9545 			}
9546 			rval = COMMAND_DONE_ERROR;
9547 		}
9548 		un->un_fileno = -1;
9549 
9550 		break;
9551 
9552 	case KEY_NOT_READY:
9553 		/*
9554 		 * If in process of getting ready retry.
9555 		 */
9556 		if (sensep->es_add_code  == 0x04 &&
9557 		    sensep->es_qual_code == 0x01 &&
9558 		    un->un_retry_ct++ < st_retry_count) {
9559 			rval = QUE_COMMAND;
9560 			severity = SCSI_ERR_INFO;
9561 		} else {
9562 			/* give up */
9563 			rval = COMMAND_DONE_ERROR;
9564 			severity = SCSI_ERR_FATAL;
9565 		}
9566 
9567 		/*
9568 		 * If this was an error and after device opened
9569 		 * do error stats.
9570 		 */
9571 		if (rval == COMMAND_DONE_ERROR &&
9572 		    un->un_state > ST_STATE_OPENING) {
9573 			ST_DO_ERRSTATS(un, st_harderrs);
9574 		}
9575 
9576 		if (ST_RQSENSE->es_add_code == 0x3a) {
9577 			if (st_error_level >= SCSI_ERR_FATAL)
9578 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
9579 				    "Tape not inserted in drive\n");
9580 			un->un_mediastate = MTIO_EJECTED;
9581 			cv_broadcast(&un->un_state_cv);
9582 		}
9583 		if ((un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) &&
9584 		    (rval != QUE_COMMAND))
9585 			un->un_eject_tape_on_failure = st_check_asc_ascq(un);
9586 		break;
9587 
9588 	case KEY_ABORTED_COMMAND:
9589 
9590 		/*
9591 		 * Probably a parity error...
9592 		 * if we retry here then this may cause data to be
9593 		 * written twice or data skipped during reading
9594 		 */
9595 		ST_DO_ERRSTATS(un, st_harderrs);
9596 		severity = SCSI_ERR_FATAL;
9597 		rval = COMMAND_DONE_ERROR;
9598 		goto check_keys;
9599 
9600 	default:
9601 		/*
9602 		 * Undecoded sense key.	 Try retries and hope
9603 		 * that will fix the problem.  Otherwise, we're
9604 		 * dead.
9605 		 */
9606 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9607 		    "Unhandled Sense Key '%s'\n",
9608 		    sense_keys[un->un_status]);
9609 		ST_DO_ERRSTATS(un, st_harderrs);
9610 		severity = SCSI_ERR_FATAL;
9611 		rval = COMMAND_DONE_ERROR;
9612 		goto check_keys;
9613 	}
9614 
9615 	if ((!(pkt->pkt_flags & FLAG_SILENT) &&
9616 	    un->un_state >= ST_STATE_OPEN) && (DEBUGGING ||
9617 		(un->un_laststate > ST_STATE_OPENING) &&
9618 		(severity >= st_error_level))) {
9619 
9620 		scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity,
9621 		    un->un_blkno, un->un_err_blkno, scsi_cmds, sensep);
9622 		if (sensep->es_filmk) {
9623 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
9624 			    "File Mark Detected\n");
9625 		}
9626 		if (sensep->es_eom) {
9627 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
9628 			    "End-of-Media Detected\n");
9629 		}
9630 		if (sensep->es_ili) {
9631 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
9632 			    "Incorrect Length Indicator Set\n");
9633 		}
9634 	}
9635 	get_error = geterror(bp);
9636 	if (((rval == COMMAND_DONE_ERROR) ||
9637 	    (rval == COMMAND_DONE_ERROR_RECOVERED)) &&
9638 	    ((get_error == EIO) || (get_error == 0))) {
9639 		un->un_rqs_state |= (ST_RQS_ERROR | ST_RQS_VALID);
9640 		bcopy(ST_RQSENSE, un->un_uscsi_rqs_buf, SENSE_LENGTH);
9641 		if (un->un_rqs_state & ST_RQS_READ) {
9642 		    un->un_rqs_state &= ~(ST_RQS_READ);
9643 		} else {
9644 		    un->un_rqs_state |= ST_RQS_OVR;
9645 		}
9646 	}
9647 
9648 	return (rval);
9649 }
9650 
9651 
9652 static int
9653 st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp)
9654 {
9655 	int status = TRAN_ACCEPT;
9656 
9657 	mutex_enter(ST_MUTEX);
9658 
9659 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9660 		"st_handle_intr_rtr_lcmd(), un = 0x%p\n", (void *)un);
9661 
9662 	/*
9663 	 * Check to see if we hit the retry timeout. We check to make sure
9664 	 * this is the first one on the runq and make sure we have not
9665 	 * queued up any more, so this one has to be the last on the list
9666 	 * also. If it is not, we have to fail.  If it is not the first, but
9667 	 * is the last we are in trouble anyway, as we are in the interrupt
9668 	 * context here.
9669 	 */
9670 	if (((int)un->un_retry_ct > st_retry_count) ||
9671 	    ((un->un_runqf != bp) && (un->un_runql != bp))) {
9672 	    goto exit;
9673 	}
9674 
9675 	if (un->un_throttle) {
9676 		un->un_last_throttle = un->un_throttle;
9677 		un->un_throttle = 0;
9678 	}
9679 
9680 	/*
9681 	 * Here we know : bp is the first and last one on the runq
9682 	 * it is not necessary to put it back on the head of the
9683 	 * waitq and then move from waitq to runq. Save this queuing
9684 	 * and call scsi_transport.
9685 	 */
9686 
9687 	mutex_exit(ST_MUTEX);
9688 
9689 	status = scsi_transport(BP_PKT(bp));
9690 
9691 	mutex_enter(ST_MUTEX);
9692 
9693 	if (status == TRAN_ACCEPT) {
9694 		un->un_tran_retry_ct = 0;
9695 		if (un->un_last_throttle) {
9696 			un->un_throttle = un->un_last_throttle;
9697 		}
9698 		mutex_exit(ST_MUTEX);
9699 
9700 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9701 		    "restart transport \n");
9702 		return (0);
9703 	}
9704 
9705 	ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
9706 	mutex_exit(ST_MUTEX);
9707 
9708 	if (status == TRAN_BUSY) {
9709 	    if (st_handle_intr_busy(un, bp,
9710 		ST_TRAN_BUSY_TIMEOUT) == 0)
9711 		return (0);
9712 	}
9713 	ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9714 		"restart transport rejected\n");
9715 	mutex_enter(ST_MUTEX);
9716 	ST_DO_ERRSTATS(un, st_transerrs);
9717 	if (un->un_last_throttle) {
9718 		un->un_throttle = un->un_last_throttle;
9719 	}
9720 exit:
9721 	mutex_exit(ST_MUTEX);
9722 	return (-1);
9723 }
9724 
9725 static int
9726 st_wrongtapetype(struct scsi_tape *un)
9727 {
9728 
9729 	ASSERT(mutex_owned(ST_MUTEX));
9730 
9731 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9732 		"st_wrongtapetype()\n");
9733 
9734 	/*
9735 	 * Hack to handle  600A, 600XTD, 6150 && 660 vs. 300XL tapes...
9736 	 */
9737 	if (un->un_dp && (un->un_dp->options & ST_QIC) && un->un_mspl) {
9738 		switch (un->un_dp->type) {
9739 		case ST_TYPE_WANGTEK:
9740 		case ST_TYPE_ARCHIVE:
9741 			/*
9742 			 * If this really worked, we could go off of
9743 			 * the density codes set in the modesense
9744 			 * page. For this drive, 0x10 == QIC-120,
9745 			 * 0xf == QIC-150, and 0x5 should be for
9746 			 * both QIC-24 and, maybe, QIC-11. However,
9747 			 * the h/w doesn't do what the manual says
9748 			 * that it should, so we'll key off of
9749 			 * getting a WRITE PROTECT error AND wp *not*
9750 			 * set in the mode sense information.
9751 			 */
9752 			/*
9753 			 * XXX but we already know that status is
9754 			 * write protect, so don't check it again.
9755 			 */
9756 
9757 			if (un->un_status == KEY_WRITE_PROTECT &&
9758 			    un->un_mspl->wp == 0) {
9759 				return (1);
9760 			}
9761 			break;
9762 		default:
9763 			break;
9764 		}
9765 	}
9766 	return (0);
9767 }
9768 
9769 static int
9770 st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt)
9771 {
9772 	int action;
9773 
9774 	ASSERT(mutex_owned(ST_MUTEX));
9775 
9776 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_error()\n");
9777 
9778 	if (SCBP_C(pkt) == STATUS_RESERVATION_CONFLICT) {
9779 		action = COMMAND_DONE_EACCES;
9780 		un->un_rsvd_status |= ST_RESERVATION_CONFLICT;
9781 	} else if (SCBP(pkt)->sts_busy) {
9782 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, "unit busy\n");
9783 		if ((int)un->un_retry_ct++ < st_retry_count) {
9784 			action = QUE_BUSY_COMMAND;
9785 		} else {
9786 			ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
9787 			    "unit busy too long\n");
9788 			mutex_exit(ST_MUTEX);
9789 			if (scsi_reset(ROUTE, RESET_TARGET) == 0) {
9790 				(void) scsi_reset(ROUTE, RESET_ALL);
9791 			}
9792 			mutex_enter(ST_MUTEX);
9793 			action = COMMAND_DONE_ERROR;
9794 		}
9795 	} else if (SCBP(pkt)->sts_chk) {
9796 		/*
9797 		 * we should only get here if the auto rqsense failed
9798 		 * thru a uscsi cmd without autorequest sense
9799 		 * so we just try again
9800 		 */
9801 		action = QUE_SENSE;
9802 	} else {
9803 		action = COMMAND_DONE;
9804 	}
9805 	return (action);
9806 }
9807 
9808 static void
9809 st_calc_bnum(struct scsi_tape *un, struct buf *bp)
9810 {
9811 	int n;
9812 
9813 	ASSERT(mutex_owned(ST_MUTEX));
9814 
9815 	if (un->un_bsize == 0) {
9816 		n = ((bp->b_bcount - bp->b_resid  == 0) ? 0 : 1);
9817 		un->un_kbytes_xferred += (bp->b_bcount - bp->b_resid)/1000;
9818 	} else {
9819 		n = ((bp->b_bcount - bp->b_resid) / un->un_bsize);
9820 	}
9821 	un->un_blkno += n;
9822 }
9823 
9824 static void
9825 st_set_state(struct scsi_tape *un)
9826 {
9827 	struct buf *bp = un->un_runqf;
9828 	struct scsi_pkt *sp = BP_PKT(bp);
9829 	struct uscsi_cmd *ucmd;
9830 
9831 	ASSERT(mutex_owned(ST_MUTEX));
9832 
9833 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9834 	    "st_set_state(): un_eof=%x	fmneeded=%x  pkt_resid=0x%lx (%ld)\n",
9835 		un->un_eof, un->un_fmneeded, sp->pkt_resid, sp->pkt_resid);
9836 
9837 	if (bp != un->un_sbufp) {
9838 #ifdef STDEBUG
9839 		if (DEBUGGING && sp->pkt_resid) {
9840 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9841 			    "pkt_resid %ld bcount %ld\n",
9842 			    sp->pkt_resid, bp->b_bcount);
9843 		}
9844 #endif
9845 		bp->b_resid = sp->pkt_resid;
9846 		st_calc_bnum(un, bp);
9847 		if (bp->b_flags & B_READ) {
9848 			un->un_lastop = ST_OP_READ;
9849 			un->un_fmneeded = 0;
9850 		} else {
9851 			un->un_lastop = ST_OP_WRITE;
9852 			if (un->un_dp->options & ST_REEL) {
9853 				un->un_fmneeded = 2;
9854 			} else {
9855 				un->un_fmneeded = 1;
9856 			}
9857 		}
9858 		/*
9859 		 * all is honky dory at this point, so let's
9860 		 * readjust the throttle, to increase speed, if we
9861 		 * have not throttled down.
9862 		 */
9863 		if (un->un_throttle)
9864 			un->un_throttle = un->un_max_throttle;
9865 	} else {
9866 		char saved_lastop = un->un_lastop;
9867 		uchar_t cmd = (uchar_t)(intptr_t)bp->b_forw;
9868 
9869 		un->un_lastop = ST_OP_CTL;
9870 
9871 		switch (cmd) {
9872 		case SCMD_WRITE:
9873 			bp->b_resid = sp->pkt_resid;
9874 			un->un_lastop = ST_OP_WRITE;
9875 			st_calc_bnum(un, bp);
9876 			if (un->un_dp->options & ST_REEL) {
9877 				un->un_fmneeded = 2;
9878 			} else {
9879 				un->un_fmneeded = 1;
9880 			}
9881 			break;
9882 		case SCMD_READ:
9883 			bp->b_resid = sp->pkt_resid;
9884 			un->un_lastop = ST_OP_READ;
9885 			st_calc_bnum(un, bp);
9886 			un->un_fmneeded = 0;
9887 			break;
9888 		case SCMD_WRITE_FILE_MARK:
9889 			if (un->un_eof != ST_EOM)
9890 				un->un_eof = ST_NO_EOF;
9891 			un->un_lastop = ST_OP_WEOF;
9892 			un->un_fileno += (bp->b_bcount - bp->b_resid);
9893 			un->un_blkno = 0;
9894 			if (un->un_dp->options & ST_REEL) {
9895 				un->un_fmneeded -=
9896 					(bp->b_bcount - bp->b_resid);
9897 				if (un->un_fmneeded < 0) {
9898 					un->un_fmneeded = 0;
9899 				}
9900 			} else {
9901 				un->un_fmneeded = 0;
9902 			}
9903 
9904 			break;
9905 		case SCMD_REWIND:
9906 			un->un_eof = ST_NO_EOF;
9907 			un->un_fileno = 0;
9908 			un->un_blkno = 0;
9909 			break;
9910 
9911 		case SCMD_SPACE:
9912 		{
9913 			int space_fmk, count;
9914 			long resid;
9915 
9916 			count = (int)space_cnt(bp->b_bcount);
9917 			resid = (long)space_cnt(bp->b_resid);
9918 			space_fmk = ((bp->b_bcount) & (1<<24)) ? 1 : 0;
9919 
9920 
9921 			if (count >= 0) {
9922 				if (space_fmk) {
9923 					if (un->un_eof <= ST_EOF) {
9924 						un->un_eof = ST_NO_EOF;
9925 					}
9926 					un->un_fileno += (count - resid);
9927 					un->un_blkno = 0;
9928 				} else {
9929 					un->un_blkno += count - resid;
9930 				}
9931 			} else if (count < 0) {
9932 				if (space_fmk) {
9933 					un->un_fileno -=
9934 					    ((-count) - resid);
9935 					if (un->un_fileno < 0) {
9936 						un->un_fileno = 0;
9937 						un->un_blkno = 0;
9938 					} else {
9939 						un->un_blkno = INF;
9940 					}
9941 				} else {
9942 					if (un->un_eof >= ST_EOF_PENDING) {
9943 					/*
9944 					 * we stepped back into
9945 					 * a previous file; we are not
9946 					 * making an effort to pretend that
9947 					 * we are still in the current file
9948 					 * ie. logical == physical position
9949 					 * and leave it to st_ioctl to correct
9950 					 */
9951 						if (un->un_fileno > 0) {
9952 							un->un_fileno--;
9953 							un->un_blkno = INF;
9954 						} else {
9955 							un->un_blkno = 0;
9956 						}
9957 					} else {
9958 						un->un_blkno -=
9959 						    (-count) - resid;
9960 					}
9961 				}
9962 			}
9963 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9964 			    "aft_space rs %ld fil %d blk %ld\n",
9965 			    resid, un->un_fileno, un->un_blkno);
9966 			break;
9967 		}
9968 		case SCMD_LOAD:
9969 			if (bp->b_bcount & 0x1) {
9970 				un->un_fileno = 0;
9971 			} else {
9972 				un->un_state = ST_STATE_OFFLINE;
9973 				un->un_fileno = -1;
9974 			}
9975 			un->un_density_known = 0;
9976 			un->un_eof = ST_NO_EOF;
9977 			un->un_blkno = 0;
9978 			break;
9979 		case SCMD_ERASE:
9980 			un->un_eof = ST_NO_EOF;
9981 			un->un_blkno = 0;
9982 			un->un_fileno = 0;
9983 			break;
9984 		case SCMD_RESERVE:
9985 			un->un_rsvd_status |= ST_RESERVE;
9986 			un->un_rsvd_status &=
9987 				~(ST_RELEASE | ST_LOST_RESERVE |
9988 					ST_RESERVATION_CONFLICT);
9989 			un->un_lastop = saved_lastop;
9990 			break;
9991 		case SCMD_RELEASE:
9992 			un->un_rsvd_status |= ST_RELEASE;
9993 			un->un_rsvd_status &=
9994 				~(ST_RESERVE | ST_LOST_RESERVE |
9995 					ST_RESERVATION_CONFLICT);
9996 			un->un_lastop = saved_lastop;
9997 			break;
9998 		case SCMD_TEST_UNIT_READY:
9999 		case SCMD_READ_BLKLIM:
10000 		case SCMD_REQUEST_SENSE:
10001 		case SCMD_INQUIRY:
10002 		case SCMD_RECOVER_BUF:
10003 		case SCMD_MODE_SELECT:
10004 		case SCMD_MODE_SENSE:
10005 		case SCMD_DOORLOCK:
10006 		case SCMD_READ_POSITION:
10007 		case SCMD_READ_BUFFER:
10008 		case SCMD_REPORT_DENSITIES:
10009 		case SCMD_LOG_SELECT_G1:
10010 		case SCMD_LOG_SENSE_G1:
10011 		case SCMD_REPORT_LUNS:
10012 			un->un_lastop = saved_lastop;
10013 			break;
10014 		case SCMD_LOCATE:	/* Locate makes position unknown */
10015 		default:
10016 			/*
10017 			 * Unknown command, If was USCSI and USCSI_SILENT
10018 			 * flag was not set, set position to unknown.
10019 			 */
10020 			if ((((ucmd = BP_UCMD(bp)) != NULL) &&
10021 			    (ucmd->uscsi_flags & USCSI_SILENT) == 0)) {
10022 				ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
10023 				    "unknown cmd 0x%X caused loss of state\n",
10024 				    cmd);
10025 			} else {
10026 				break;
10027 			}
10028 			/* FALLTHROUGH */
10029 		case SCMD_WRITE_BUFFER: /* Writes new firmware to device */
10030 			un->un_fileno = -1;
10031 			break;
10032 		}
10033 	}
10034 
10035 	/*
10036 	 * In the st driver we have a logical and physical file position.
10037 	 * Under BSD behavior, when you get a zero read, the logical position
10038 	 * is before the filemark but after the last record of the file.
10039 	 * The physical position is after the filemark. MTIOCGET should always
10040 	 * return the logical file position.
10041 	 *
10042 	 * The next read gives a silent skip to the next file.
10043 	 * Under SVR4, the logical file position remains before the filemark
10044 	 * until the file is closed or a space operation is performed.
10045 	 * Hence set err_resid and err_file before changing fileno if case
10046 	 * BSD Behaviour.
10047 	 */
10048 	un->un_err_resid = bp->b_resid;
10049 	un->un_err_fileno = un->un_fileno;
10050 	un->un_err_blkno = un->un_blkno;
10051 	un->un_retry_ct = 0;
10052 
10053 
10054 	/*
10055 	 * If we've seen a filemark via the last read operation
10056 	 * advance the file counter, but mark things such that
10057 	 * the next read operation gets a zero count. We have
10058 	 * to put this here to handle the case of sitting right
10059 	 * at the end of a tape file having seen the file mark,
10060 	 * but the tape is closed and then re-opened without
10061 	 * any further i/o. That is, the position information
10062 	 * must be updated before a close.
10063 	 */
10064 
10065 	if (un->un_lastop == ST_OP_READ && un->un_eof == ST_EOF_PENDING) {
10066 		/*
10067 		 * If we're a 1/2" tape, and we get a filemark
10068 		 * right on block 0, *AND* we were not in the
10069 		 * first file on the tape, and we've hit logical EOM.
10070 		 * We'll mark the state so that later we do the
10071 		 * right thing (in st_close(), st_strategy() or
10072 		 * st_ioctl()).
10073 		 *
10074 		 */
10075 		if ((un->un_dp->options & ST_REEL) &&
10076 			!(un->un_dp->options & ST_READ_IGNORE_EOFS) &&
10077 		    un->un_blkno == 0 && un->un_fileno > 0) {
10078 			un->un_eof = ST_EOT_PENDING;
10079 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10080 			    "eot pending\n");
10081 			un->un_fileno++;
10082 			un->un_blkno = 0;
10083 		} else if (BSD_BEHAVIOR) {
10084 			/*
10085 			 * If the read of the filemark was a side effect
10086 			 * of reading some blocks (i.e., data was actually
10087 			 * read), then the EOF mark is pending and the
10088 			 * bump into the next file awaits the next read
10089 			 * operation (which will return a zero count), or
10090 			 * a close or a space operation, else the bump
10091 			 * into the next file occurs now.
10092 			 */
10093 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10094 			    "resid=%lx, bcount=%lx\n",
10095 				bp->b_resid, bp->b_bcount);
10096 			if (bp->b_resid != bp->b_bcount) {
10097 				un->un_eof = ST_EOF;
10098 			} else {
10099 				un->un_silent_skip = 1;
10100 				un->un_eof = ST_NO_EOF;
10101 				un->un_fileno++;
10102 				un->un_save_blkno = un->un_blkno;
10103 				un->un_blkno = 0;
10104 			}
10105 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10106 			    "eof of file %d, un_eof=%d\n",
10107 			    un->un_fileno, un->un_eof);
10108 		} else if (SVR4_BEHAVIOR) {
10109 			/*
10110 			 * If the read of the filemark was a side effect
10111 			 * of reading some blocks (i.e., data was actually
10112 			 * read), then the next read should return 0
10113 			 */
10114 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10115 			    "resid=%lx, bcount=%lx\n",
10116 			    bp->b_resid, bp->b_bcount);
10117 			if (bp->b_resid == bp->b_bcount) {
10118 				un->un_eof = ST_EOF;
10119 			}
10120 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10121 			    "eof of file=%d, un_eof=%d\n",
10122 			    un->un_fileno, un->un_eof);
10123 		}
10124 	}
10125 }
10126 
10127 /*
10128  * set the correct un_errno, to take corner cases into consideration
10129  */
10130 static void
10131 st_set_pe_errno(struct scsi_tape *un)
10132 {
10133 	ASSERT(mutex_owned(ST_MUTEX));
10134 
10135 	/* if errno is already set, don't reset it */
10136 	if (un->un_errno)
10137 		return;
10138 
10139 	/* here un_errno == 0 */
10140 	/*
10141 	 * if the last transfer before flushing all the
10142 	 * waiting I/O's, was 0 (resid = count), then we
10143 	 * want to give the user an error on all the rest,
10144 	 * so here.  If there was a transfer, we set the
10145 	 * resid and counts to 0, and let it drop through,
10146 	 * giving a zero return.  the next I/O will then
10147 	 * give an error.
10148 	 */
10149 	if (un->un_last_resid == un->un_last_count) {
10150 		switch (un->un_eof) {
10151 		case ST_EOM:
10152 			un->un_errno = ENOMEM;
10153 			break;
10154 		case ST_EOT:
10155 		case ST_EOF:
10156 			un->un_errno = EIO;
10157 			break;
10158 		}
10159 	} else {
10160 		/*
10161 		 * we know they did not have a zero, so make
10162 		 * sure they get one
10163 		 */
10164 		un->un_last_resid = un->un_last_count = 0;
10165 	}
10166 }
10167 
10168 
10169 /*
10170  * send in a marker pkt to terminate flushing of commands by BBA (via
10171  * flush-on-errors) property.  The HBA will always return TRAN_ACCEPT
10172  */
10173 static void
10174 st_hba_unflush(struct scsi_tape *un)
10175 {
10176 	ASSERT(mutex_owned(ST_MUTEX));
10177 
10178 	if (!un->un_flush_on_errors)
10179 		return;
10180 
10181 #ifdef FLUSH_ON_ERRORS
10182 
10183 	if (!un->un_mkr_pkt) {
10184 		un->un_mkr_pkt = scsi_init_pkt(ROUTE, NULL, (struct buf *)NULL,
10185 		    NULL, 0, 0, 0, SLEEP_FUNC, NULL);
10186 
10187 		/* we slept, so it must be there */
10188 		pkt->pkt_flags |= FLAG_FLUSH_MARKER;
10189 	}
10190 
10191 	mutex_exit(ST_MUTEX);
10192 	scsi_transport(un->un_mkr_pkt);
10193 	mutex_enter(ST_MUTEX);
10194 #endif
10195 }
10196 
10197 static void
10198 st_clean_print(dev_info_t *dev, char *label, uint_t level,
10199 	char *title, char *data, int len)
10200 {
10201 	int	i;
10202 	char	buf[256];
10203 
10204 	(void) sprintf(buf, "%s: ", title);
10205 	for (i = 0; i < len; i++) {
10206 		(void) sprintf(&buf[(int)strlen(buf)], "0x%x ",
10207 			(data[i] & 0xff));
10208 	}
10209 	(void) sprintf(&buf[(int)strlen(buf)], "\n");
10210 
10211 	scsi_log(dev, label, level, "%s", buf);
10212 }
10213 
10214 /*
10215  * Conditionally enabled debugging
10216  */
10217 #ifdef	STDEBUG
10218 static void
10219 st_debug_cmds(struct scsi_tape *un, int com, int count, int wait)
10220 {
10221 	char tmpbuf[64];
10222 
10223 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10224 	    "cmd=%s count=0x%x (%d)	 %ssync\n",
10225 	    scsi_cmd_name(com, scsi_cmds, tmpbuf),
10226 	    count, count,
10227 	    wait == ASYNC_CMD ? "a" : "");
10228 }
10229 
10230 /*
10231  * Returns pointer to name of minor node name of device 'dev'.
10232  */
10233 static char *
10234 st_dev_name(dev_t dev)
10235 {
10236 	const char density[] = { 'l', 'm', 'h', 'c' };
10237 	static char name[4];
10238 	minor_t minor;
10239 	int nprt = 0;
10240 
10241 	minor = getminor(dev);
10242 	name[nprt] = density[(minor & MT_DENSITY_MASK) >> 3];
10243 
10244 	if (minor & MT_BSD) {
10245 		name[++nprt] = 'b';
10246 	}
10247 
10248 	if (minor & MT_NOREWIND) {
10249 		name[++nprt] = 'n';
10250 	}
10251 
10252 	/* NULL terminator */
10253 	name[++nprt] = 0;
10254 
10255 	return (name);
10256 }
10257 #endif	/* STDEBUG */
10258 
10259 /*
10260  * Soft error reporting, so far unique to each drive
10261  *
10262  * Currently supported: exabyte and DAT soft error reporting
10263  */
10264 static int
10265 st_report_exabyte_soft_errors(dev_t dev, int flag)
10266 {
10267 	uchar_t *sensep;
10268 	int amt;
10269 	int rval = 0;
10270 	char cdb[CDB_GROUP0], *c = cdb;
10271 	struct uscsi_cmd *com;
10272 
10273 	GET_SOFT_STATE(dev);
10274 
10275 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10276 	    "st_report_exabyte_soft_errors(dev = 0x%lx, flag = %d)\n",
10277 	    dev, flag);
10278 
10279 	ASSERT(mutex_owned(ST_MUTEX));
10280 
10281 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
10282 	sensep = kmem_zalloc(TAPE_SENSE_LENGTH, KM_SLEEP);
10283 
10284 	*c++ = SCMD_REQUEST_SENSE;
10285 	*c++ = 0;
10286 	*c++ = 0;
10287 	*c++ = 0;
10288 	*c++ = TAPE_SENSE_LENGTH;
10289 	/*
10290 	 * set CLRCNT (byte 5, bit 7 which clears the error counts)
10291 	 */
10292 	*c   = (char)0x80;
10293 
10294 	com->uscsi_cdb = cdb;
10295 	com->uscsi_cdblen = CDB_GROUP0;
10296 	com->uscsi_bufaddr = (caddr_t)sensep;
10297 	com->uscsi_buflen = TAPE_SENSE_LENGTH;
10298 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT
10299 		| USCSI_READ | USCSI_RQENABLE;
10300 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
10301 
10302 	rval = st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
10303 		UIO_SYSSPACE);
10304 	if (rval || com->uscsi_status) {
10305 		goto done;
10306 	}
10307 
10308 	/*
10309 	 * was there enough data?
10310 	 */
10311 	amt = (int)TAPE_SENSE_LENGTH - com->uscsi_resid;
10312 
10313 	if ((amt >= 19) && un->un_kbytes_xferred) {
10314 		uint_t count, error_rate;
10315 		uint_t rate;
10316 
10317 		if (sensep[21] & CLN) {
10318 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
10319 			    "Periodic head cleaning required");
10320 		}
10321 		if (un->un_kbytes_xferred < (EXABYTE_MIN_TRANSFER/1000))
10322 			goto done;
10323 		/*
10324 		 * check if soft error reporting needs to be done.
10325 		 */
10326 		count = sensep[16] << 16 | sensep[17] << 8 | sensep[18];
10327 		count &= 0xffffff;
10328 		error_rate = (count * 100)/un->un_kbytes_xferred;
10329 
10330 #ifdef	STDEBUG
10331 		if (st_soft_error_report_debug) {
10332 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
10333 			    "Exabyte Soft Error Report:\n");
10334 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
10335 			    "read/write error counter: %d\n", count);
10336 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
10337 			    "number of bytes transferred: %dK\n",
10338 				un->un_kbytes_xferred);
10339 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
10340 			    "error_rate: %d%%\n", error_rate);
10341 
10342 			if (amt >= 22) {
10343 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10344 				    "unit sense: 0x%b 0x%b 0x%b\n",
10345 				    sensep[19], SENSE_19_BITS,
10346 				    sensep[20], SENSE_20_BITS,
10347 				    sensep[21], SENSE_21_BITS);
10348 			}
10349 			if (amt >= 27) {
10350 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10351 				    "tracking retry counter: %d\n",
10352 				    sensep[26]);
10353 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10354 				    "read/write retry counter: %d\n",
10355 				    sensep[27]);
10356 			}
10357 		}
10358 #endif
10359 
10360 		if (flag & FWRITE) {
10361 			rate = EXABYTE_WRITE_ERROR_THRESHOLD;
10362 		} else {
10363 			rate = EXABYTE_READ_ERROR_THRESHOLD;
10364 		}
10365 		if (error_rate >= rate) {
10366 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
10367 			    "Soft error rate (%d%%) during %s was too high",
10368 			    error_rate,
10369 			    ((flag & FWRITE) ? wrg_str : rdg_str));
10370 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
10371 			    "Please, replace tape cartridge\n");
10372 		}
10373 	}
10374 
10375 done:
10376 	kmem_free(com, sizeof (*com));
10377 	kmem_free(sensep, TAPE_SENSE_LENGTH);
10378 
10379 	if (rval != 0) {
10380 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10381 		    "exabyte soft error reporting failed\n");
10382 	}
10383 	return (rval);
10384 }
10385 
10386 /*
10387  * this is very specific to Archive 4mm dat
10388  */
10389 #define	ONEGIG	(1024 * 1024 * 1024)
10390 
10391 static int
10392 st_report_dat_soft_errors(dev_t dev, int flag)
10393 {
10394 	uchar_t *sensep;
10395 	int amt, i;
10396 	int rval = 0;
10397 	char cdb[CDB_GROUP1], *c = cdb;
10398 	struct uscsi_cmd *com;
10399 
10400 	GET_SOFT_STATE(dev);
10401 
10402 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10403 	    "st_report_dat_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag);
10404 
10405 	ASSERT(mutex_owned(ST_MUTEX));
10406 
10407 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
10408 	sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP);
10409 
10410 	*c++ = SCMD_LOG_SENSE_G1;
10411 	*c++ = 0;
10412 	*c++ = (flag & FWRITE) ? 0x42 : 0x43;
10413 	*c++ = 0;
10414 	*c++ = 0;
10415 	*c++ = 0;
10416 	*c++ = 2;
10417 	*c++ = 0;
10418 	*c++ = (char)LOG_SENSE_LENGTH;
10419 	*c   = 0;
10420 	com->uscsi_cdb    = cdb;
10421 	com->uscsi_cdblen  = CDB_GROUP1;
10422 	com->uscsi_bufaddr = (caddr_t)sensep;
10423 	com->uscsi_buflen  = LOG_SENSE_LENGTH;
10424 	com->uscsi_flags   =
10425 	    USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
10426 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
10427 	rval =
10428 	    st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
10429 	if (rval) {
10430 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10431 		    "DAT soft error reporting failed\n");
10432 	}
10433 	if (rval || com->uscsi_status) {
10434 		goto done;
10435 	}
10436 
10437 	/*
10438 	 * was there enough data?
10439 	 */
10440 	amt = (int)LOG_SENSE_LENGTH - com->uscsi_resid;
10441 
10442 	if ((amt >= MIN_LOG_SENSE_LENGTH) && un->un_kbytes_xferred) {
10443 		int total, retries, param_code;
10444 
10445 		total = -1;
10446 		retries = -1;
10447 		amt = sensep[3] + 4;
10448 
10449 
10450 #ifdef STDEBUG
10451 		if (st_soft_error_report_debug) {
10452 			(void) printf("logsense:");
10453 			for (i = 0; i < MIN_LOG_SENSE_LENGTH; i++) {
10454 				if (i % 16 == 0) {
10455 					(void) printf("\t\n");
10456 				}
10457 				(void) printf(" %x", sensep[i]);
10458 			}
10459 			(void) printf("\n");
10460 		}
10461 #endif
10462 
10463 		/*
10464 		 * parse the param_codes
10465 		 */
10466 		if (sensep[0] == 2 || sensep[0] == 3) {
10467 			for (i = 4; i < amt; i++) {
10468 				param_code = (sensep[i++] << 8);
10469 				param_code += sensep[i++];
10470 				i++; /* skip control byte */
10471 				if (param_code == 5) {
10472 					if (sensep[i++] == 4) {
10473 						total = (sensep[i++] << 24);
10474 						total += (sensep[i++] << 16);
10475 						total += (sensep[i++] << 8);
10476 						total += sensep[i];
10477 					}
10478 				} else if (param_code == 0x8007) {
10479 					if (sensep[i++] == 2) {
10480 						retries = sensep[i++] << 8;
10481 						retries += sensep[i];
10482 					}
10483 				} else {
10484 					i += sensep[i];
10485 				}
10486 			}
10487 		}
10488 
10489 		/*
10490 		 * if the log sense returned valid numbers then determine
10491 		 * the read and write error thresholds based on the amount of
10492 		 * data transferred
10493 		 */
10494 
10495 		if (total > 0 && retries > 0) {
10496 			short normal_retries = 0;
10497 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10498 			"total xferred (%s) =%x, retries=%x\n",
10499 				((flag & FWRITE) ? wrg_str : rdg_str),
10500 				total, retries);
10501 
10502 			if (flag & FWRITE) {
10503 				if (total <=
10504 					WRITE_SOFT_ERROR_WARNING_THRESHOLD) {
10505 					normal_retries =
10506 						DAT_SMALL_WRITE_ERROR_THRESHOLD;
10507 				} else {
10508 					normal_retries =
10509 						DAT_LARGE_WRITE_ERROR_THRESHOLD;
10510 				}
10511 			} else {
10512 				if (total <=
10513 					READ_SOFT_ERROR_WARNING_THRESHOLD) {
10514 					normal_retries =
10515 						DAT_SMALL_READ_ERROR_THRESHOLD;
10516 				} else {
10517 					normal_retries =
10518 						DAT_LARGE_READ_ERROR_THRESHOLD;
10519 				}
10520 			}
10521 
10522 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10523 			"normal retries=%d\n", normal_retries);
10524 
10525 			if (retries >= normal_retries) {
10526 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
10527 				    "Soft error rate (retries = %d) during "
10528 				    "%s was too high",  retries,
10529 				    ((flag & FWRITE) ? wrg_str : rdg_str));
10530 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10531 				    "Periodic head cleaning required "
10532 				    "and/or replace tape cartridge\n");
10533 			}
10534 
10535 		} else if (total == -1 || retries == -1) {
10536 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
10537 			    "log sense parameter code does not make sense\n");
10538 		}
10539 	}
10540 
10541 	/*
10542 	 * reset all values
10543 	 */
10544 	c = cdb;
10545 	*c++ = SCMD_LOG_SELECT_G1;
10546 	*c++ = 2;	/* this resets all values */
10547 	*c++ = (char)0xc0;
10548 	*c++ = 0;
10549 	*c++ = 0;
10550 	*c++ = 0;
10551 	*c++ = 0;
10552 	*c++ = 0;
10553 	*c++ = 0;
10554 	*c   = 0;
10555 	com->uscsi_bufaddr = NULL;
10556 	com->uscsi_buflen  = 0;
10557 	com->uscsi_flags   = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_RQENABLE;
10558 	rval =
10559 	    st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
10560 	if (rval) {
10561 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10562 		    "DAT soft error reset failed\n");
10563 	}
10564 done:
10565 	kmem_free(com, sizeof (*com));
10566 	kmem_free(sensep, LOG_SENSE_LENGTH);
10567 	return (rval);
10568 }
10569 
10570 static int
10571 st_report_soft_errors(dev_t dev, int flag)
10572 {
10573 	GET_SOFT_STATE(dev);
10574 
10575 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10576 	    "st_report_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag);
10577 
10578 	ASSERT(mutex_owned(ST_MUTEX));
10579 
10580 	switch (un->un_dp->type) {
10581 	case ST_TYPE_EXB8500:
10582 	case ST_TYPE_EXABYTE:
10583 		return (st_report_exabyte_soft_errors(dev, flag));
10584 		/*NOTREACHED*/
10585 	case ST_TYPE_PYTHON:
10586 		return (st_report_dat_soft_errors(dev, flag));
10587 		/*NOTREACHED*/
10588 	default:
10589 		un->un_dp->options &= ~ST_SOFT_ERROR_REPORTING;
10590 		return (-1);
10591 	}
10592 }
10593 
10594 /*
10595  * persistent error routines
10596  */
10597 
10598 /*
10599  * enable persistent errors, and set the throttle appropriately, checking
10600  * for flush-on-errors capability
10601  */
10602 static void
10603 st_turn_pe_on(struct scsi_tape *un)
10604 {
10605 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_on\n");
10606 	ASSERT(mutex_owned(ST_MUTEX));
10607 
10608 	un->un_persistence = 1;
10609 
10610 	/*
10611 	 * only use flush-on-errors if auto-request-sense and untagged-qing are
10612 	 * enabled.  This will simplify the error handling for request senses
10613 	 */
10614 
10615 	if (un->un_arq_enabled && un->un_untagged_qing) {
10616 		uchar_t f_o_e;
10617 
10618 		mutex_exit(ST_MUTEX);
10619 		f_o_e = (scsi_ifsetcap(ROUTE, "flush-on-errors", 1, 1) == 1) ?
10620 		    1 : 0;
10621 		mutex_enter(ST_MUTEX);
10622 
10623 		un->un_flush_on_errors = f_o_e;
10624 	} else {
10625 		un->un_flush_on_errors = 0;
10626 	}
10627 
10628 	if (un->un_flush_on_errors)
10629 		un->un_max_throttle = (uchar_t)st_max_throttle;
10630 	else
10631 		un->un_max_throttle = 1;
10632 
10633 	if (un->un_dp->options & ST_RETRY_ON_RECOVERED_DEFERRED_ERROR)
10634 		un->un_max_throttle = 1;
10635 
10636 	/* this will send a marker pkt */
10637 	CLEAR_PE(un);
10638 }
10639 
10640 /*
10641  * This turns persistent errors permanently off
10642  */
10643 static void
10644 st_turn_pe_off(struct scsi_tape *un)
10645 {
10646 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_off\n");
10647 	ASSERT(mutex_owned(ST_MUTEX));
10648 
10649 	/* turn it off for good */
10650 	un->un_persistence = 0;
10651 
10652 	/* this will send a marker pkt */
10653 	CLEAR_PE(un);
10654 
10655 	/* turn off flush on error capability, if enabled */
10656 	if (un->un_flush_on_errors) {
10657 		mutex_exit(ST_MUTEX);
10658 		(void) scsi_ifsetcap(ROUTE, "flush-on-errors", 0, 1);
10659 		mutex_enter(ST_MUTEX);
10660 	}
10661 
10662 
10663 	un->un_flush_on_errors = 0;
10664 }
10665 
10666 /*
10667  * This clear persistent errors, allowing more commands through, and also
10668  * sending a marker packet.
10669  */
10670 static void
10671 st_clear_pe(struct scsi_tape *un)
10672 {
10673 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_clear\n");
10674 	ASSERT(mutex_owned(ST_MUTEX));
10675 
10676 	un->un_persist_errors = 0;
10677 	un->un_throttle = un->un_last_throttle = 1;
10678 	un->un_errno = 0;
10679 	st_hba_unflush(un);
10680 }
10681 
10682 /*
10683  * This will flag persistent errors, shutting everything down, if the
10684  * application had enabled persistent errors via MTIOCPERSISTENT
10685  */
10686 static void
10687 st_set_pe_flag(struct scsi_tape *un)
10688 {
10689 	ASSERT(mutex_owned(ST_MUTEX));
10690 
10691 	if (un->un_persistence) {
10692 		ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_flag\n");
10693 		un->un_persist_errors = 1;
10694 		un->un_throttle = un->un_last_throttle = 0;
10695 	}
10696 }
10697 
10698 int
10699 st_reserve_release(dev_t dev, int cmd)
10700 {
10701 	struct uscsi_cmd	uscsi_cmd;
10702 	struct uscsi_cmd	*com = &uscsi_cmd;
10703 	int			rval;
10704 	char			cdb[CDB_GROUP0];
10705 
10706 
10707 	GET_SOFT_STATE(dev);
10708 	ASSERT(mutex_owned(ST_MUTEX));
10709 
10710 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10711 		"st_reserve_release: %s \n", (cmd == ST_RELEASE)?
10712 				"Releasing":"Reserving");
10713 
10714 	bzero(cdb, CDB_GROUP0);
10715 	if (cmd == ST_RELEASE) {
10716 		cdb[0] = SCMD_RELEASE;
10717 	} else {
10718 		cdb[0] = SCMD_RESERVE;
10719 	}
10720 	bzero(com, sizeof (struct uscsi_cmd));
10721 	com->uscsi_flags = USCSI_WRITE;
10722 	com->uscsi_cdb = cdb;
10723 	com->uscsi_cdblen = CDB_GROUP0;
10724 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
10725 
10726 	rval = st_ioctl_cmd(dev, com,
10727 		UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
10728 
10729 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10730 		"st_reserve_release: rval(1)=%d\n", rval);
10731 
10732 	if (rval) {
10733 		if (com->uscsi_status == STATUS_RESERVATION_CONFLICT)
10734 			rval = EACCES;
10735 		/*
10736 		 * dynamically turn off reserve/release support
10737 		 * in case of drives which do not support
10738 		 * reserve/release command(ATAPI drives).
10739 		 */
10740 		if (un->un_status == KEY_ILLEGAL_REQUEST) {
10741 			if (ST_RESERVE_SUPPORTED(un)) {
10742 				un->un_dp->options |= ST_NO_RESERVE_RELEASE;
10743 				ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10744 					"Tape unit does not support "
10745 					"reserve/release \n");
10746 			}
10747 			rval = 0;
10748 		}
10749 	}
10750 	return (rval);
10751 }
10752 
10753 static int
10754 st_take_ownership(dev_t dev)
10755 {
10756 	int rval;
10757 
10758 	GET_SOFT_STATE(dev);
10759 	ASSERT(mutex_owned(ST_MUTEX));
10760 
10761 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10762 		"st_take_ownership: Entering ...\n");
10763 
10764 
10765 	rval = st_reserve_release(dev, ST_RESERVE);
10766 	/*
10767 	 * XXX -> Should reset be done only if we get EACCES.
10768 	 * .
10769 	 */
10770 	if (rval) {
10771 		mutex_exit(ST_MUTEX);
10772 		if (scsi_reset(ROUTE, RESET_TARGET) == 0) {
10773 			if (scsi_reset(ROUTE, RESET_ALL) == 0) {
10774 				mutex_enter(ST_MUTEX);
10775 				return (EIO);
10776 			}
10777 		}
10778 		mutex_enter(ST_MUTEX);
10779 		un->un_rsvd_status &=
10780 			~(ST_LOST_RESERVE | ST_RESERVATION_CONFLICT);
10781 
10782 		mutex_exit(ST_MUTEX);
10783 		delay(drv_usectohz(ST_RESERVATION_DELAY));
10784 		mutex_enter(ST_MUTEX);
10785 		/*
10786 		 * remove the check condition.
10787 		 */
10788 		(void) st_reserve_release(dev, ST_RESERVE);
10789 		if ((rval = st_reserve_release(dev, ST_RESERVE)) != 0) {
10790 			if ((st_reserve_release(dev, ST_RESERVE)) != 0) {
10791 				rval = (un->un_rsvd_status &
10792 					ST_RESERVATION_CONFLICT) ? EACCES : EIO;
10793 				return (rval);
10794 			}
10795 		}
10796 		/*
10797 		 * Set tape state to ST_STATE_OFFLINE , in case if
10798 		 * the user wants to continue and start using
10799 		 * the tape.
10800 		 */
10801 		un->un_state = ST_STATE_OFFLINE;
10802 		un->un_rsvd_status |= ST_INIT_RESERVE;
10803 	}
10804 	return (rval);
10805 }
10806 
10807 static int
10808 st_create_errstats(struct scsi_tape *un, int instance)
10809 {
10810 	char	kstatname[KSTAT_STRLEN];
10811 
10812 	/*
10813 	 * Create device error kstats
10814 	 */
10815 
10816 	if (un->un_errstats == (kstat_t *)0) {
10817 		(void) sprintf(kstatname, "st%d,err", instance);
10818 		un->un_errstats = kstat_create("sterr", instance, kstatname,
10819 			"device_error", KSTAT_TYPE_NAMED,
10820 			sizeof (struct st_errstats) / sizeof (kstat_named_t),
10821 			KSTAT_FLAG_PERSISTENT);
10822 
10823 		if (un->un_errstats) {
10824 			struct st_errstats	*stp;
10825 
10826 			stp = (struct st_errstats *)un->un_errstats->ks_data;
10827 			kstat_named_init(&stp->st_softerrs, "Soft Errors",
10828 				KSTAT_DATA_ULONG);
10829 			kstat_named_init(&stp->st_harderrs, "Hard Errors",
10830 				KSTAT_DATA_ULONG);
10831 			kstat_named_init(&stp->st_transerrs, "Transport Errors",
10832 				KSTAT_DATA_ULONG);
10833 			kstat_named_init(&stp->st_vid, "Vendor",
10834 				KSTAT_DATA_CHAR);
10835 			kstat_named_init(&stp->st_pid, "Product",
10836 				KSTAT_DATA_CHAR);
10837 			kstat_named_init(&stp->st_revision, "Revision",
10838 				KSTAT_DATA_CHAR);
10839 			kstat_named_init(&stp->st_serial, "Serial No",
10840 				KSTAT_DATA_CHAR);
10841 			un->un_errstats->ks_private = un;
10842 			un->un_errstats->ks_update = nulldev;
10843 			kstat_install(un->un_errstats);
10844 			/*
10845 			 * Fill in the static data
10846 			 */
10847 			(void) strncpy(&stp->st_vid.value.c[0],
10848 					ST_INQUIRY->inq_vid, 8);
10849 			/*
10850 			 * XXX:  Emulex MT-02 (and emulators) predates
10851 			 *	 SCSI-1 and has no vid & pid inquiry data.
10852 			 */
10853 			if (ST_INQUIRY->inq_len != 0) {
10854 				(void) strncpy(&stp->st_pid.value.c[0],
10855 					ST_INQUIRY->inq_pid, 16);
10856 				(void) strncpy(&stp->st_revision.value.c[0],
10857 					ST_INQUIRY->inq_revision, 4);
10858 				(void) strncpy(&stp->st_serial.value.c[0],
10859 					ST_INQUIRY->inq_serial, 12);
10860 			}
10861 		}
10862 	}
10863 	return (0);
10864 }
10865 
10866 static int
10867 st_validate_tapemarks(struct scsi_tape *un, int fileno, daddr_t blkno)
10868 {
10869 	dev_t 	dev;
10870 
10871 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
10872 	ASSERT(mutex_owned(ST_MUTEX));
10873 
10874 	dev = un->un_dev;
10875 
10876 	scsi_log(ST_DEVINFO, st_label, CE_NOTE, "Restoring tape"
10877 	" position at fileno=%x, blkno=%lx....", fileno, blkno);
10878 
10879 	/*
10880 	 * Rewind ? Oh yeah, Fidelity has got the STK F/W changed
10881 	 * so as not to rewind tape on RESETS: Gee, Has life ever
10882 	 * been simple in tape land ?
10883 	 */
10884 	if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
10885 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10886 		"Failed to restore the last file and block position: In"
10887 		" this state, Tape will be loaded at BOT during next open");
10888 		un->un_fileno = -1;
10889 		return (1);
10890 	}
10891 
10892 	if (fileno) {
10893 		if (st_cmd(dev, SCMD_SPACE, Fmk(fileno), SYNC_CMD)) {
10894 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
10895 			"Failed to restore the last file position: In this "
10896 			" state, Tape will be loaded at BOT during next open");
10897 			un->un_fileno = -1;
10898 			return (2);
10899 		}
10900 	}
10901 
10902 	if (blkno) {
10903 		if (st_cmd(dev, SCMD_SPACE, Blk(blkno), SYNC_CMD)) {
10904 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
10905 			"Failed to restore the last block position: In this"
10906 			" state, tape will be loaded at BOT during next open");
10907 			un->un_fileno = -1;
10908 			return (3);
10909 		}
10910 	}
10911 
10912 	return (0);
10913 }
10914 
10915 /*
10916  * check sense key, ASC, ASCQ in order to determine if the tape needs
10917  * to be ejected
10918  */
10919 
10920 static int
10921 st_check_asc_ascq(struct scsi_tape *un)
10922 {
10923 	struct scsi_extended_sense *sensep = ST_RQSENSE;
10924 	struct tape_failure_code   *code;
10925 
10926 	for (code = st_tape_failure_code; code->key != 0xff; code++) {
10927 		if ((code->key  == sensep->es_key) &&
10928 		    (code->add_code  == sensep->es_add_code) &&
10929 		    (code->qual_code == sensep->es_qual_code))
10930 			return (1);
10931 	}
10932 	return (0);
10933 }
10934 
10935 /*
10936  * st_logpage_supported() sends a Log Sense command with
10937  * page code = 0 = Supported Log Pages Page to the device,
10938  * to see whether the page 'page' is supported.
10939  * Return values are:
10940  * -1 if the Log Sense command fails
10941  * 0 if page is not supported
10942  * 1 if page is supported
10943  */
10944 
10945 static int
10946 st_logpage_supported(dev_t dev, uchar_t page)
10947 {
10948 	uchar_t *sp, *sensep;
10949 	unsigned length;
10950 	struct uscsi_cmd *com;
10951 	int rval;
10952 	char cdb[CDB_GROUP1] = {
10953 		SCMD_LOG_SENSE_G1,
10954 		0,
10955 		SUPPORTED_LOG_PAGES_PAGE,
10956 		0,
10957 		0,
10958 		0,
10959 		0,
10960 		0,
10961 		(char)LOG_SENSE_LENGTH,
10962 		0
10963 	};
10964 
10965 	GET_SOFT_STATE(dev);
10966 	ASSERT(mutex_owned(ST_MUTEX));
10967 
10968 	com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
10969 	sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP);
10970 
10971 	com->uscsi_cdb = cdb;
10972 	com->uscsi_cdblen = CDB_GROUP1;
10973 	com->uscsi_bufaddr = (caddr_t)sensep;
10974 	com->uscsi_buflen = LOG_SENSE_LENGTH;
10975 	com->uscsi_flags =
10976 		USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
10977 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
10978 	rval = st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
10979 	if (rval || com->uscsi_status) {
10980 		/* uscsi-command failed */
10981 		rval = -1;
10982 	} else {
10983 
10984 		sp = sensep + 3;
10985 
10986 		for (length = *sp++; length > 0; length--, sp++) {
10987 
10988 			if (*sp == page) {
10989 				rval = 1;
10990 				break;
10991 			}
10992 		}
10993 	}
10994 	kmem_free(com, sizeof (struct uscsi_cmd));
10995 	kmem_free(sensep, LOG_SENSE_LENGTH);
10996 	return (rval);
10997 }
10998 
10999 
11000 /*
11001  * st_check_clean_bit() gets the status of the tape's cleaning bit.
11002  *
11003  * If the device does support the TapeAlert log page, then the cleaning bit
11004  * information will be read from this page. Otherwise we will see if one of
11005  * ST_CLN_TYPE_1, ST_CLN_TYPE_2 or ST_CLN_TYPE_3 is set in the properties of
11006  * the device, which means, that we can get the cleaning bit information via
11007  * a RequestSense command.
11008  * If both methods of getting cleaning bit information are not supported
11009  * st_check_clean_bit() will return with 0. Otherwise st_check_clean_bit()
11010  * returns with
11011  * - MTF_TAPE_CLN_SUPPORTED if cleaning bit is not set or
11012  * - MTF_TAPE_CLN_SUPPORTED | MTF_TAPE_HEAD_DIRTY if cleaning bit is set.
11013  * If the call to st_ioctl_cmd() to do the Log Sense or the Request Sense
11014  * command fails, or if the amount of Request Sense data is not enough, then
11015  *  st_check_clean_bit() returns with -1.
11016  */
11017 
11018 static int
11019 st_check_clean_bit(dev_t dev)
11020 {
11021 	int rval = 0;
11022 
11023 	GET_SOFT_STATE(dev);
11024 
11025 	ASSERT(mutex_owned(ST_MUTEX));
11026 
11027 	if (un->un_HeadClean & TAPE_ALERT_NOT_SUPPORTED) {
11028 		return (rval);
11029 	}
11030 
11031 	if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) {
11032 
11033 		rval = st_logpage_supported(dev, TAPE_SEQUENTIAL_PAGE);
11034 		if (rval == 1) {
11035 
11036 			un->un_HeadClean |= TAPE_SEQUENTIAL_SUPPORTED;
11037 		}
11038 
11039 		rval = st_logpage_supported(dev, TAPE_ALERT_PAGE);
11040 		if (rval == 1) {
11041 
11042 			un->un_HeadClean |= TAPE_ALERT_SUPPORTED;
11043 		}
11044 
11045 		if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) {
11046 
11047 			un->un_HeadClean = TAPE_ALERT_NOT_SUPPORTED;
11048 		}
11049 	}
11050 
11051 	rval = 0;
11052 
11053 	if (un->un_HeadClean & TAPE_SEQUENTIAL_SUPPORTED) {
11054 
11055 		rval = st_check_sequential_clean_bit(dev);
11056 	}
11057 
11058 	if ((rval <= 0) && (un->un_HeadClean & TAPE_ALERT_SUPPORTED)) {
11059 
11060 		rval = st_check_alert_clean_bit(dev);
11061 	}
11062 
11063 	if ((rval <= 0) && (un->un_dp->options & ST_CLN_MASK)) {
11064 
11065 		rval = st_check_sense_clean_bit(dev);
11066 	}
11067 
11068 	if (rval < 0) {
11069 		return (rval);
11070 	}
11071 
11072 	/*
11073 	 * If found a supported means to check need to clean.
11074 	 */
11075 	if (rval & MTF_TAPE_CLN_SUPPORTED) {
11076 
11077 		/*
11078 		 * head needs to be cleaned.
11079 		 */
11080 		if (rval & MTF_TAPE_HEAD_DIRTY) {
11081 
11082 			/*
11083 			 * Print log message only first time
11084 			 * found needing cleaned.
11085 			 */
11086 			if ((un->un_HeadClean & TAPE_PREVIOUSLY_DIRTY) == 0) {
11087 
11088 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
11089 				    "Periodic head cleaning required");
11090 
11091 				un->un_HeadClean |= TAPE_PREVIOUSLY_DIRTY;
11092 			}
11093 
11094 		} else {
11095 
11096 			un->un_HeadClean &= ~TAPE_PREVIOUSLY_DIRTY;
11097 		}
11098 	}
11099 
11100 	return (rval);
11101 }
11102 
11103 
11104 static int
11105 st_check_sequential_clean_bit(dev_t dev)
11106 {
11107 	int rval;
11108 	int ix;
11109 	ushort_t parameter;
11110 	struct uscsi_cmd *cmd;
11111 	struct log_sequential_page *sp;
11112 	struct log_sequential_page_parameter *prm;
11113 	char cdb[CDB_GROUP1] = {
11114 		SCMD_LOG_SENSE_G1,
11115 		0,
11116 		TAPE_SEQUENTIAL_PAGE | CURRENT_CUMULATIVE_VALUES,
11117 		0,
11118 		0,
11119 		0,
11120 		0,
11121 		(char)(sizeof (struct log_sequential_page) >> 8),
11122 		(char)(sizeof (struct log_sequential_page)),
11123 		0
11124 	};
11125 
11126 	GET_SOFT_STATE(dev);
11127 
11128 	cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
11129 	sp  = kmem_zalloc(sizeof (struct log_sequential_page), KM_SLEEP);
11130 
11131 	cmd->uscsi_flags   =
11132 		USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
11133 	cmd->uscsi_timeout = un->un_dp->non_motion_timeout;
11134 	cmd->uscsi_cdb	   = cdb;
11135 	cmd->uscsi_cdblen  = CDB_GROUP1;
11136 	cmd->uscsi_bufaddr = (caddr_t)sp;
11137 	cmd->uscsi_buflen  = sizeof (struct log_sequential_page);
11138 
11139 	rval = st_ioctl_cmd(dev, cmd, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
11140 
11141 	if (rval || cmd->uscsi_status || cmd->uscsi_resid) {
11142 
11143 		rval = -1;
11144 
11145 	} else if (sp->log_page.code != TAPE_SEQUENTIAL_PAGE) {
11146 
11147 		rval = -1;
11148 	}
11149 
11150 	prm = &sp->param[0];
11151 
11152 	for (ix = 0; rval == 0 && ix < TAPE_SEQUENTIAL_PAGE_PARA; ix++) {
11153 
11154 		if (prm->log_param.length == 0) {
11155 			break;
11156 		}
11157 
11158 		parameter = (((prm->log_param.pc_hi << 8) & 0xff00) +
11159 			(prm->log_param.pc_lo & 0xff));
11160 
11161 		if (parameter == SEQUENTIAL_NEED_CLN) {
11162 
11163 			rval = MTF_TAPE_CLN_SUPPORTED;
11164 			if (prm->param_value[prm->log_param.length - 1]) {
11165 
11166 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11167 					    "sequential log says head dirty\n");
11168 				rval |= MTF_TAPE_HEAD_DIRTY;
11169 			}
11170 		}
11171 		prm = (struct log_sequential_page_parameter *)
11172 			&prm->param_value[prm->log_param.length];
11173 	}
11174 
11175 	kmem_free(cmd, sizeof (struct uscsi_cmd));
11176 	kmem_free(sp,  sizeof (struct log_sequential_page));
11177 
11178 	return (rval);
11179 }
11180 
11181 
11182 static int
11183 st_check_alert_clean_bit(dev_t dev)
11184 {
11185 	struct st_tape_alert *ta;
11186 	struct uscsi_cmd *com;
11187 	unsigned ix, length;
11188 	int rval;
11189 	ushort_t parameter;
11190 	char cdb[CDB_GROUP1] = {
11191 		SCMD_LOG_SENSE_G1,
11192 		0,
11193 		TAPE_ALERT_PAGE | CURRENT_THRESHOLD_VALUES,
11194 		0,
11195 		0,
11196 		0,
11197 		0,
11198 		(char)(sizeof (struct st_tape_alert) >> 8),
11199 		(char)(sizeof (struct st_tape_alert)),
11200 		0
11201 	};
11202 
11203 	GET_SOFT_STATE(dev);
11204 
11205 	com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
11206 	ta  = kmem_zalloc(sizeof (struct st_tape_alert), KM_SLEEP);
11207 
11208 	com->uscsi_cdb = cdb;
11209 	com->uscsi_cdblen = CDB_GROUP1;
11210 	com->uscsi_bufaddr = (caddr_t)ta;
11211 	com->uscsi_buflen = sizeof (struct st_tape_alert);
11212 	com->uscsi_flags =
11213 		USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
11214 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
11215 
11216 	rval = st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
11217 
11218 	if (rval || com->uscsi_status || com->uscsi_resid) {
11219 
11220 		rval = -1; /* uscsi-command failed */
11221 
11222 	} else if (ta->log_page.code != TAPE_ALERT_PAGE) {
11223 
11224 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11225 		"Not Alert Log Page returned 0x%X\n", ta->log_page.code);
11226 		rval = -1;
11227 	}
11228 
11229 	length = (ta->log_page.length_hi << 8) + ta->log_page.length_lo;
11230 
11231 
11232 	if (length != TAPE_ALERT_PARAMETER_LENGTH) {
11233 
11234 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11235 		    "TapeAlert length %d\n", length);
11236 	}
11237 
11238 
11239 	for (ix = 0; ix < TAPE_ALERT_MAX_PARA; ix++) {
11240 
11241 		/*
11242 		 * if rval is bad before the first pass don't bother
11243 		 */
11244 		if (ix == 0 && rval != 0) {
11245 
11246 			break;
11247 		}
11248 
11249 		parameter = ((ta->param[ix].log_param.pc_hi << 8) +
11250 			ta->param[ix].log_param.pc_lo);
11251 
11252 		/*
11253 		 * check to see if current parameter is of interest.
11254 		 * CLEAN_FOR_ERRORS is vendor specific to 9840 9940 stk's.
11255 		 */
11256 		if ((parameter == CLEAN_NOW) ||
11257 		    (parameter == CLEAN_PERIODIC) ||
11258 		    ((parameter == CLEAN_FOR_ERRORS) &&
11259 		    (un->un_dp->type == ST_TYPE_STK9840))) {
11260 
11261 			rval = MTF_TAPE_CLN_SUPPORTED;
11262 
11263 			if (ta->param[ix].param_value & 1) {
11264 
11265 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11266 					    "alert_page drive needs clean %d\n",
11267 					    parameter);
11268 				un->un_HeadClean |= TAPE_ALERT_STILL_DIRTY;
11269 				rval |= MTF_TAPE_HEAD_DIRTY;
11270 			}
11271 
11272 		} else if (parameter == CLEANING_MEDIA) {
11273 
11274 			if (ta->param[ix].param_value & 1) {
11275 
11276 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11277 					    "alert_page drive was cleaned\n");
11278 				un->un_HeadClean &= ~TAPE_ALERT_STILL_DIRTY;
11279 			}
11280 		}
11281 
11282 	}
11283 
11284 	/*
11285 	 * Report it as dirty till we see it cleaned
11286 	 */
11287 	if (un->un_HeadClean & TAPE_ALERT_STILL_DIRTY) {
11288 
11289 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11290 			    "alert_page still dirty\n");
11291 		rval |= MTF_TAPE_HEAD_DIRTY;
11292 	}
11293 
11294 	kmem_free(com, sizeof (struct uscsi_cmd));
11295 	kmem_free(ta,  sizeof (struct st_tape_alert));
11296 
11297 	return (rval);
11298 }
11299 
11300 
11301 static int
11302 st_check_sense_clean_bit(dev_t dev)
11303 {
11304 	uchar_t *sensep;
11305 	char cdb[CDB_GROUP0];
11306 	struct uscsi_cmd *com;
11307 	ushort_t byte_pos;
11308 	uchar_t bit_mask;
11309 	unsigned length;
11310 	int index;
11311 	int rval;
11312 
11313 	GET_SOFT_STATE(dev);
11314 
11315 	/*
11316 	 * Since this tape does not support Tape Alert,
11317 	 * we now try to get the cleanbit status via
11318 	 * Request Sense.
11319 	 */
11320 
11321 	if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_1) {
11322 
11323 		index = 0;
11324 
11325 	} else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_2) {
11326 
11327 		index = 1;
11328 
11329 	} else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_3) {
11330 
11331 		index = 2;
11332 
11333 	} else {
11334 
11335 		return (-1);
11336 	}
11337 
11338 	byte_pos  = st_cln_bit_position[index].cln_bit_byte;
11339 	bit_mask  = st_cln_bit_position[index].cln_bit_mask;
11340 	length = byte_pos + 1;
11341 
11342 	com    = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
11343 	sensep = kmem_zalloc(length, KM_SLEEP);
11344 
11345 	cdb[0] = SCMD_REQUEST_SENSE;
11346 	cdb[1] = 0;
11347 	cdb[2] = 0;
11348 	cdb[3] = 0;
11349 	cdb[4] = (char)length;
11350 	cdb[5] = 0;
11351 
11352 	com->uscsi_cdb = cdb;
11353 	com->uscsi_cdblen = CDB_GROUP0;
11354 	com->uscsi_bufaddr = (caddr_t)sensep;
11355 	com->uscsi_buflen = length;
11356 	com->uscsi_flags =
11357 		USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
11358 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
11359 
11360 	rval = st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
11361 			UIO_SYSSPACE);
11362 
11363 	if (rval || com->uscsi_status || com->uscsi_resid) {
11364 
11365 		rval = -1;
11366 
11367 	} else {
11368 
11369 		rval = MTF_TAPE_CLN_SUPPORTED;
11370 		if ((sensep[byte_pos] & bit_mask) == bit_mask) {
11371 
11372 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11373 				    "sense data says head dirty\n");
11374 			rval |= MTF_TAPE_HEAD_DIRTY;
11375 		}
11376 	}
11377 
11378 	kmem_free(com, sizeof (struct uscsi_cmd));
11379 	kmem_free(sensep, length);
11380 	return (rval);
11381 }
11382 
11383 /*
11384  * st_clear_unit_attention
11385  *
11386  *  	run test unit ready's to clear out outstanding
11387  * 	unit attentions.
11388  * 	returns zero for SUCCESS or the errno from st_cmd call
11389  */
11390 static int
11391 st_clear_unit_attentions(dev_t dev_instance, int max_trys)
11392 {
11393 	int	i    = 0;
11394 	int	rval;
11395 
11396 	do {
11397 		rval = st_cmd(dev_instance, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
11398 	} while ((rval != 0) && (rval != ENXIO) && (++i < max_trys));
11399 	return (rval);
11400 }
11401 
11402 static void
11403 st_calculate_timeouts(struct scsi_tape *un)
11404 {
11405 	if (un->un_dp->non_motion_timeout == 0) {
11406 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11407 			un->un_dp->non_motion_timeout =
11408 				st_io_time * st_long_timeout_x;
11409 		} else {
11410 			un->un_dp->non_motion_timeout = (ushort_t)st_io_time;
11411 		}
11412 	}
11413 
11414 	if (un->un_dp->io_timeout == 0) {
11415 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11416 			un->un_dp->io_timeout = st_io_time * st_long_timeout_x;
11417 		} else {
11418 			un->un_dp->io_timeout = (ushort_t)st_io_time;
11419 		}
11420 	}
11421 
11422 	if (un->un_dp->rewind_timeout == 0) {
11423 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11424 			un->un_dp->rewind_timeout =
11425 				st_space_time * st_long_timeout_x;
11426 		} else {
11427 			un->un_dp->rewind_timeout = (ushort_t)st_space_time;
11428 		}
11429 	}
11430 
11431 	if (un->un_dp->space_timeout == 0) {
11432 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11433 			un->un_dp->space_timeout =
11434 				st_space_time * st_long_timeout_x;
11435 		} else {
11436 			un->un_dp->space_timeout = (ushort_t)st_space_time;
11437 		}
11438 	}
11439 
11440 	if (un->un_dp->load_timeout == 0) {
11441 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11442 			un->un_dp->load_timeout =
11443 				st_space_time * st_long_timeout_x;
11444 		} else {
11445 			un->un_dp->load_timeout = (ushort_t)st_space_time;
11446 		}
11447 	}
11448 
11449 	if (un->un_dp->unload_timeout == 0) {
11450 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11451 			un->un_dp->unload_timeout =
11452 				st_space_time * st_long_timeout_x;
11453 		} else {
11454 			un->un_dp->unload_timeout = (ushort_t)st_space_time;
11455 		}
11456 	}
11457 
11458 	if (un->un_dp->erase_timeout == 0) {
11459 		if (un->un_dp->options & ST_LONG_ERASE) {
11460 			un->un_dp->erase_timeout =
11461 				st_space_time * st_long_space_time_x;
11462 		} else {
11463 			un->un_dp->erase_timeout = (ushort_t)st_space_time;
11464 		}
11465 	}
11466 }
11467 
11468 #if defined(__i386) || defined(__amd64)
11469 
11470 /*
11471  * release contig_mem and wake up waiting thread, if any
11472  */
11473 static void
11474 st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp)
11475 {
11476 	mutex_enter(ST_MUTEX);
11477 
11478 	cp->cm_next = un->un_contig_mem;
11479 	un->un_contig_mem = cp;
11480 	un->un_contig_mem_available_num++;
11481 	cv_broadcast(&un->un_contig_mem_cv);
11482 
11483 	mutex_exit(ST_MUTEX);
11484 }
11485 
11486 /*
11487  * St_get_contig_mem will return a contig_mem if there is one available
11488  * in current system. Otherwise, it will try to alloc one, if the total
11489  * number of contig_mem is within st_max_contig_mem_num.
11490  * It will sleep, if allowed by caller or return NULL, if no contig_mem
11491  * is available for now.
11492  */
11493 static struct contig_mem *
11494 st_get_contig_mem(struct scsi_tape *un, size_t len, int alloc_flags)
11495 {
11496 	size_t rlen;
11497 	struct contig_mem *cp = NULL;
11498 	ddi_acc_handle_t acc_hdl;
11499 	caddr_t addr;
11500 	int (*dma_alloc_cb)() = (alloc_flags == KM_SLEEP) ?
11501 		DDI_DMA_SLEEP : DDI_DMA_DONTWAIT;
11502 
11503 	/* Try to get one available contig_mem */
11504 	mutex_enter(ST_MUTEX);
11505 	if (un->un_contig_mem_available_num > 0) {
11506 		cp = un->un_contig_mem;
11507 		un->un_contig_mem = cp->cm_next;
11508 		cp->cm_next = NULL;
11509 		un->un_contig_mem_available_num--;
11510 	} else if (un->un_contig_mem_total_num < st_max_contig_mem_num) {
11511 		/*
11512 		 * we failed to get one. we're going to
11513 		 * alloc one more contig_mem for this I/O
11514 		 */
11515 		mutex_exit(ST_MUTEX);
11516 		cp = (struct contig_mem *)
11517 		    kmem_zalloc(sizeof (struct contig_mem), alloc_flags);
11518 		if (cp == NULL) {
11519 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11520 			    "alloc contig_mem failure\n");
11521 			return (NULL); /* cannot get one */
11522 		}
11523 		mutex_enter(ST_MUTEX);
11524 		un->un_contig_mem_total_num++; /* one more available */
11525 	} else {
11526 		/*
11527 		 * we failed to get one and we're NOT allowed to
11528 		 * alloc more contig_mem
11529 		 */
11530 		if (alloc_flags == KM_SLEEP) {
11531 			while (un->un_contig_mem_available_num <= 0) {
11532 				cv_wait(&un->un_contig_mem_cv,
11533 				    ST_MUTEX);
11534 			}
11535 			cp = un->un_contig_mem;
11536 			un->un_contig_mem = cp->cm_next;
11537 			cp->cm_next = NULL;
11538 			un->un_contig_mem_available_num--;
11539 		} else {
11540 			mutex_exit(ST_MUTEX);
11541 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11542 			    "alloc contig_mem failure\n");
11543 			return (NULL); /* cannot get one */
11544 		}
11545 	}
11546 	mutex_exit(ST_MUTEX);
11547 
11548 	/* We need to check if this block of mem is big enough for this I/O */
11549 	if (cp->cm_len < len) {
11550 		/* not big enough, need to alloc a new one */
11551 		if (ddi_dma_mem_alloc(un->un_contig_mem_hdl, len, &st_acc_attr,
11552 			DDI_DMA_RDWR, dma_alloc_cb, NULL,
11553 			&addr, &rlen, &acc_hdl) != DDI_SUCCESS) {
11554 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11555 			    "alloc contig_mem failure: not enough mem\n");
11556 			st_release_contig_mem(un, cp);
11557 			return (NULL);
11558 		}
11559 		if (cp->cm_addr) {
11560 			/* release previous one before we attach new one */
11561 			ddi_dma_mem_free(&cp->cm_acc_hdl);
11562 		}
11563 		/* attach new mem to this cp */
11564 		cp->cm_addr = addr;
11565 		cp->cm_acc_hdl = acc_hdl;
11566 		cp->cm_len = len;
11567 
11568 		if (cp->cm_bp == NULL) {
11569 			cp->cm_bp = getrbuf(alloc_flags);
11570 			if (cp->cm_bp == NULL) {
11571 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11572 				    "alloc contig_mem failure:"
11573 				    "no enough mem for bp\n");
11574 				st_release_contig_mem(un, cp);
11575 				return (NULL);
11576 			}
11577 		}
11578 	}
11579 
11580 	/* init bp attached to this cp */
11581 	bioinit(cp->cm_bp);
11582 	cp->cm_bp->b_un.b_addr = cp->cm_addr;
11583 	cp->cm_bp->b_private = (void *)cp;
11584 	return (cp);
11585 }
11586 
11587 /*
11588  * this is the biodone func for the bp used in big block I/O
11589  */
11590 static int
11591 st_bigblk_xfer_done(struct buf *bp)
11592 {
11593 	struct contig_mem *cp;
11594 	struct buf *orig_bp;
11595 	int remapped = 0;
11596 	int ioerr;
11597 	struct scsi_tape *un;
11598 
11599 	/* sanity check */
11600 	if (bp == NULL) {
11601 		return (DDI_FAILURE);
11602 	}
11603 
11604 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
11605 	if (un == NULL) {
11606 		return (DDI_FAILURE);
11607 	}
11608 
11609 	cp = (struct contig_mem *)bp->b_private;
11610 	orig_bp = cp->cm_bp; /* get back the bp we have replaced */
11611 	cp->cm_bp = bp;
11612 
11613 	/* special handling for special I/O */
11614 	if (cp->cm_use_sbuf) {
11615 		ASSERT(un->un_sbuf_busy);
11616 		un->un_sbufp = orig_bp;
11617 		cp->cm_use_sbuf = 0;
11618 	}
11619 
11620 	orig_bp->b_resid = bp->b_resid;
11621 	ioerr = geterror(bp);
11622 	if (ioerr != 0) {
11623 		bioerror(orig_bp, ioerr);
11624 	} else if (orig_bp->b_flags & B_READ) {
11625 		/* copy data back to original bp */
11626 		if (orig_bp->b_flags & (B_PHYS | B_PAGEIO)) {
11627 			bp_mapin(orig_bp);
11628 			remapped = 1;
11629 		}
11630 		bcopy(bp->b_un.b_addr, orig_bp->b_un.b_addr,
11631 			bp->b_bcount - bp->b_resid);
11632 		if (remapped)
11633 			bp_mapout(orig_bp);
11634 	}
11635 
11636 	st_release_contig_mem(un, cp);
11637 
11638 	biodone(orig_bp);
11639 
11640 	return (DDI_SUCCESS);
11641 }
11642 
11643 /*
11644  * We use this func to replace original bp that may not be able to do I/O
11645  * in big block size with one that can
11646  */
11647 static struct buf *
11648 st_get_bigblk_bp(struct buf *bp)
11649 {
11650 	struct contig_mem *cp;
11651 	struct scsi_tape *un;
11652 	struct buf *cont_bp;
11653 	int remapped = 0;
11654 
11655 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
11656 	if (un == NULL) {
11657 		return (bp);
11658 	}
11659 
11660 	/* try to get one contig_mem */
11661 	cp = st_get_contig_mem(un, bp->b_bcount, KM_SLEEP);
11662 	if (!cp) {
11663 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
11664 			"Cannot alloc contig buf for I/O for %lu blk size",
11665 			bp->b_bcount);
11666 		return (bp);
11667 	}
11668 	cont_bp = cp->cm_bp;
11669 	cp->cm_bp = bp;
11670 
11671 	/* make sure that we "are" using un_sbufp for special I/O */
11672 	if (bp == un->un_sbufp) {
11673 		ASSERT(un->un_sbuf_busy);
11674 		un->un_sbufp = cont_bp;
11675 		cp->cm_use_sbuf = 1;
11676 	}
11677 
11678 	/* clone bp */
11679 	cont_bp->b_bcount = bp->b_bcount;
11680 	cont_bp->b_resid = bp->b_resid;
11681 	cont_bp->b_iodone = st_bigblk_xfer_done;
11682 	cont_bp->b_file = bp->b_file;
11683 	cont_bp->b_offset = bp->b_offset;
11684 	cont_bp->b_dip = bp->b_dip;
11685 	cont_bp->b_error = 0;
11686 	cont_bp->b_proc = NULL;
11687 	cont_bp->b_flags = bp->b_flags & ~(B_PAGEIO | B_PHYS | B_SHADOW);
11688 	cont_bp->b_shadow = NULL;
11689 	cont_bp->b_pages = NULL;
11690 	cont_bp->b_edev = bp->b_edev;
11691 	cont_bp->b_dev = bp->b_dev;
11692 	cont_bp->b_lblkno = bp->b_lblkno;
11693 	cont_bp->b_forw = bp->b_forw;
11694 	cont_bp->b_back = bp->b_back;
11695 	cont_bp->av_forw = bp->av_forw;
11696 	cont_bp->av_back = bp->av_back;
11697 	cont_bp->b_bufsize = bp->b_bufsize;
11698 
11699 	/* get data in original bp */
11700 	if (bp->b_flags & B_WRITE) {
11701 		if (bp->b_flags & (B_PHYS | B_PAGEIO)) {
11702 			bp_mapin(bp);
11703 			remapped = 1;
11704 		}
11705 		bcopy(bp->b_un.b_addr, cont_bp->b_un.b_addr, bp->b_bcount);
11706 		if (remapped)
11707 			bp_mapout(bp);
11708 	}
11709 
11710 	return (cont_bp);
11711 }
11712 #endif
11713