| blob | ea3283c93cd06577334741a0a8be053245cd9d85 |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
22 /*
23 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
25 */
27 /*
28 * SCSI SCSA-compliant and not-so-DDI-compliant Tape Driver
29 */
31 #if defined(lint) && !defined(DEBUG)
32 #define DEBUG 1
33 #endif
35 #include <sys/modctl.h>
36 #include <sys/scsi/scsi.h>
37 #include <sys/mtio.h>
38 #include <sys/scsi/targets/stdef.h>
39 #include <sys/file.h>
40 #include <sys/kstat.h>
41 #include <sys/ddidmareq.h>
42 #include <sys/ddi.h>
43 #include <sys/sunddi.h>
44 #include <sys/byteorder.h>
46 #define IOSP KSTAT_IO_PTR(un->un_stats)
47 /*
48 * stats maintained only for reads/writes as commands
49 * like rewind etc skew the wait/busy times
50 */
51 #define IS_RW(bp) ((bp)->b_bcount > 0)
52 #define ST_DO_KSTATS(bp, kstat_function) \
53 if ((bp != un->un_sbufp) && un->un_stats && IS_RW(bp)) { \
54 kstat_function(IOSP); \
55 }
57 #define ST_DO_ERRSTATS(un, x) \
58 if (un->un_errstats) { \
59 struct st_errstats *stp; \
60 stp = (struct st_errstats *)un->un_errstats->ks_data; \
61 stp->x.value.ul++; \
62 }
64 #define FILL_SCSI1_LUN(devp, pkt) \
65 if ((devp)->sd_inq->inq_ansi == 0x1) { \
66 int _lun; \
67 _lun = ddi_prop_get_int(DDI_DEV_T_ANY, (devp)->sd_dev, \
68 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0); \
69 if (_lun > 0) { \
70 ((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun = \
71 _lun; \
72 } \
73 }
75 /*
76 * get an available contig mem header, cp.
77 * when big_enough is true, we will return NULL, if no big enough
78 * contig mem is found.
79 * when big_enough is false, we will try to find cp containing big
80 * enough contig mem. if not found, we will ruturn the last cp available.
81 *
82 * used by st_get_contig_mem()
83 */
84 #define ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough) { \
85 struct contig_mem *tmp_cp = NULL; \
86 for ((cp) = (un)->un_contig_mem; \
87 (cp) != NULL; \
88 tmp_cp = (cp), (cp) = (cp)->cm_next) { \
89 if (((cp)->cm_len >= (len)) || \
90 (!(big_enough) && ((cp)->cm_next == NULL))) { \
91 if (tmp_cp == NULL) { \
92 (un)->un_contig_mem = (cp)->cm_next; \
93 } else { \
94 tmp_cp->cm_next = (cp)->cm_next; \
95 } \
96 (cp)->cm_next = NULL; \
97 (un)->un_contig_mem_available_num--; \
98 break; \
99 } \
100 } \
101 }
103 #define ST_NUM_MEMBERS(array) (sizeof (array) / sizeof (array[0]))
104 #define COPY_POS(dest, source) bcopy(source, dest, sizeof (tapepos_t))
105 #define ISALNUM(byte) \
110 #define ONE_K 1024
112 #define MAX_SPACE_CNT(cnt) if (cnt >= 0) { \
113 if (cnt > MIN(SP_CNT_MASK, INT32_MAX)) \
114 return (EINVAL); \
115 } else { \
116 if (-(cnt) > MIN(SP_CNT_MASK, INT32_MAX)) \
117 return (EINVAL); \
118 } \
120 /*
121 * Global External Data Definitions
122 */
126 /*
127 * Local Static Data
128 */
133 "St Tape is misconfigured, MPxIO enabled and "
135 };
137 #ifdef __x86
138 /*
139 * We need to use below DMA attr to alloc physically contiguous
140 * memory to do I/O in big block size
141 */
155 };
158 DDI_DEVICE_ATTR_V0,
159 DDI_NEVERSWAP_ACC,
160 DDI_STRICTORDER_ACC
161 };
163 /* set limitation for the number of contig_mem */
165 #endif
167 /*
168 * Tunable parameters
169 *
170 * DISCLAIMER
171 * ----------
172 * These parameters are intended for use only in system testing; if you use
173 * them in production systems, you do so at your own risk. Altering any
174 * variable not listed below may cause unpredictable system behavior.
175 *
176 * st_check_media_time
177 *
178 * Three second state check
179 *
180 * st_allow_large_xfer
181 *
182 * Gated with ST_NO_RECSIZE_LIMIT
183 *
184 * 0 - Transfers larger than 64KB will not be allowed
185 * regardless of the setting of ST_NO_RECSIZE_LIMIT
186 * 1 - Transfers larger than 64KB will be allowed
187 * if ST_NO_RECSIZE_LIMIT is TRUE for the drive
188 *
189 * st_report_soft_errors_on_close
190 *
191 * Gated with ST_SOFT_ERROR_REPORTING
192 *
193 * 0 - Errors will not be reported on close regardless
194 * of the setting of ST_SOFT_ERROR_REPORTING
195 *
196 * 1 - Errors will be reported on close if
197 * ST_SOFT_ERROR_REPORTING is TRUE for the drive
198 */
218 /*
219 * End of tunable parameters list
220 */
224 /*
225 * Asynchronous I/O and persistent errors, refer to PSARC/1995/228
226 *
227 * Asynchronous I/O's main offering is that it is a non-blocking way to do
228 * reads and writes. The driver will queue up all the requests it gets and
229 * have them ready to transport to the HBA. Unfortunately, we cannot always
230 * just ship the I/O requests to the HBA, as there errors and exceptions
231 * that may happen when we don't want the HBA to continue. Therein comes
232 * the flush-on-errors capability. If the HBA supports it, then st will
233 * send in st_max_throttle I/O requests at the same time.
234 *
235 * Persistent errors : This was also reasonably simple. In the interrupt
236 * routines, if there was an error or exception (FM, LEOT, media error,
237 * transport error), the persistent error bits are set and shuts everything
238 * down, but setting the throttle to zero. If we hit and exception in the
239 * HBA, and flush-on-errors were set, we wait for all outstanding I/O's to
240 * come back (with CMD_ABORTED), then flush all bp's in the wait queue with
241 * the appropriate error, and this will preserve order. Of course, depending
242 * on the exception we have to show a zero read or write before we show
243 * errors back to the application.
244 */
250 #ifdef STDEBUG
255 #endif
267 };
273 /*
274 * The top 4 entries are for the default densities,
275 * don't alter their position.
276 */
301 };
303 /* strings used in many debug and warning messages */
316 "Reserved"
317 };
329 };
345 "ATTEMPT_RETRY"
346 };
350 /* default density offsets in the table above */
351 #define DEF_BLANK 0
352 #define DEF_NOREWIND 1
353 #define DEF_BSD 2
354 #define DEF_BSD_NR 3
356 /* Sense Key, ASC/ASCQ for which tape ejection is needed */
359 uchar_t key;
360 uchar_t add_code;
361 uchar_t qual_code;
369 };
371 /* clean bit position and mask */
374 ushort_t cln_bit_byte;
375 uchar_t cln_bit_mask;
380 };
382 /*
383 * architecture dependent allocation restrictions. For x86, we'll set
384 * dma_attr_addr_hi to st_max_phys_addr and dma_attr_sgllen to
385 * st_sgl_size during _init().
386 */
387 #if defined(__sparc)
401 };
402 #elif defined(__x86)
416 };
420 #endif
422 /*
423 * Configuration Data:
424 *
425 * Device driver ops vector
426 */
458 st_awrite /* async I/O write entry point */
460 };
481 };
483 /*
484 * Local Function Declarations
485 */
504 ushort_t);
547 tapepos_t *);
549 tapepos_t *);
624 errstate onentry);
651 ubufunc_t ubf);
653 #ifdef __x86
654 /*
655 * routines for I/O in big block size
656 */
662 #endif
666 /*
667 * error statistics create/update functions
668 */
673 #ifdef STDEBUG
678 #if !defined(lint)
680 scsi_pkt buf uio scsi_cdb uscsi_cmd))
685 #endif
687 /*
688 * autoconfiguration routines.
689 */
695 };
699 };
701 /*
702 * Notes on Post Reset Behavior in the tape driver:
703 *
704 * When the tape drive is opened, the driver attempts to make sure that
705 * the tape head is positioned exactly where it was left when it was last
706 * closed provided the medium is not changed. If the tape drive is
707 * opened in O_NDELAY mode, the repositioning (if necessary for any loss
708 * of position due to reset) will happen when the first tape operation or
709 * I/O occurs. The repositioning (if required) may not be possible under
710 * certain situations such as when the device firmware not able to report
711 * the medium change in the REQUEST SENSE data because of a reset or a
712 * misbehaving bus not allowing the reposition to happen. In such
713 * extraordinary situations, where the driver fails to position the head
714 * at its original position, it will fail the open the first time, to
715 * save the applications from overwriting the data. All further attempts
716 * to open the tape device will result in the driver attempting to load
717 * the tape at BOT (beginning of tape). Also a warning message to
718 * indicate that further attempts to open the tape device may result in
719 * the tape being loaded at BOT will be printed on the console. If the
720 * tape device is opened in O_NDELAY mode, failure to restore the
721 * original tape head position, will result in the failure of the first
722 * tape operation or I/O, Further, the driver will invalidate its
723 * internal tape position which will necessitate the applications to
724 * validate the position by using either a tape positioning ioctl (such
725 * as MTREW) or closing and reopening the tape device.
726 *
727 */
729 int
731 {
737 }
742 #ifdef STDEBUG
744 #endif
746 #if defined(__x86)
747 /* set the max physical address for iob allocs on x86 */
750 /*
751 * set the sgllen for iob allocs on x86. If this is set less
752 * than the number of pages the buffer will take
753 * (taking into account alignment), it would force the
754 * allocator to try and allocate contiguous pages.
755 */
757 #endif
758 }
761 }
763 int
765 {
770 }
772 #ifdef STDEBUG
774 #endif
779 }
781 int
783 {
785 }
788 static int
790 {
795 #if !defined(__sparc)
798 #endif
802 /* If self identifying device */
805 }
807 #if !defined(__sparc)
808 /*
809 * Since some x86 HBAs have devnodes that look like SCSI as
810 * far as we can tell but aren't really SCSI (DADK, like mlx)
811 * we check for the presence of the "tape" property.
812 */
817 }
821 }
823 #endif
830 }
833 /*
834 * Turn around and call probe routine to see whether
835 * we actually have a tape at this SCSI nexus.
836 */
839 /*
840 * In checking the whole inq_dtype byte we are looking at both
841 * the Peripheral Qualifier and the Peripheral Device Type.
842 * For this driver we are only interested in sequential devices
843 * that are connected or capable if connecting to this logical
844 * unit.
845 */
853 }
858 }
861 }
863 static int
865 {
884 }
887 }
890 /*
891 * Suspend/Resume
892 *
893 * When the driver suspended, there might be
894 * outstanding cmds and therefore we need to
895 * reset the suspended flag and resume the scsi
896 * watch thread and restart commands and timeouts
897 */
901 }
913 }
915 /*
916 * Restart timeouts
917 */
923 MEDIA_ACCESS_DELAY));
925 }
930 ST_STATUS_BUSY_TIMEOUT);
932 }
936 /*
937 * now check if we need to restore the tape position
938 */
944 /*
945 * tape didn't get good TUR
946 * just print out error messages
947 */
949 "st_attach-RESUME: tape failure "
952 /* this prints errors */
955 }
956 /*
957 * there are no retries, if there is an error
958 * we don't know if the tape has changed
959 */
961 }
963 /* now we are ready to start up any queued I/Os */
966 }
974 }
981 /*
982 * Add a zero-length attribute to tell the world we support
983 * kernel ioctls (for layered drivers)
984 */
990 /*
991 * If it's a SCSI-2 tape drive which supports wide,
992 * tell the host adapter to use wide.
993 */
1000 }
1002 /*
1003 * enable autorequest sense; keep the rq packet around in case
1004 * the autorequest sense fails because of a busy condition
1005 * do a getcap first in case the capability is not variable
1006 */
1012 }
1020 /*
1021 * XXX - This is just for 2.6. to tell users that write buffering
1022 * has gone away.
1023 */
1028 "Write Data Buffering has been depricated. Your "
1030 " But, they should ported to use Asynchronous "
1032 " For more information, read about "
1033 " tape-driver-buffering "
1035 }
1036 }
1046 /* initialize persistent errors to nil */
1050 /*
1051 * Get dma-max from HBA driver. If it is not defined, use 64k
1052 */
1058 }
1060 #ifdef __x86
1061 /*
1062 * for x86, the device may be able to DMA more than the system will
1063 * allow under some circumstances. We need account for both the HBA's
1064 * and system's contraints.
1065 *
1066 * Get the maximum DMA under worse case conditions. e.g. looking at the
1067 * device constraints, the max copy buffer size, and the worse case
1068 * fragmentation. NOTE: this may differ from dma-max since dma-max
1069 * doesn't take the worse case framentation into account.
1070 *
1071 * e.g. a device may be able to DMA 16MBytes, but can only DMA 1MByte
1072 * if none of the pages are contiguous. Keeping track of both of these
1073 * values allows us to support larger tape block sizes on some devices.
1074 */
1078 /*
1079 * If the dma-max-arch capability is not implemented, or the value
1080 * comes back higher than what was reported in dma-max, use dma-max.
1081 */
1085 }
1086 #endif
1088 /*
1089 * Get the max allowable cdb size
1090 */
1097 }
1103 }
1110 /*
1111 * initialize kstats
1112 */
1118 }
1121 /*
1122 * find the drive type for this target
1123 */
1137 /*
1138 * For default devices set the density to the
1139 * preferred default density for this device.
1140 */
1143 }
1149 }
1159 #ifdef __x86
1161 #endif
1167 }
1170 }
1173 }
1176 }
1179 }
1182 }
1185 }
1188 }
1198 }
1201 }
1203 /*
1204 * st_detach:
1205 *
1206 * we allow a detach if and only if:
1207 * - no tape is currently inserted
1208 * - tape position is at BOT or unknown
1209 * (if it is not at BOT then a no rewind
1210 * device was opened and we have to preserve state)
1211 * - it must be in a closed state : no timeouts or scsi_watch requests
1212 * will exist if it is closed, so we don't need to check for
1213 * them here.
1214 */
1215 /*ARGSUSED*/
1216 static int
1218 {
1231 }
1235 /*
1236 * Clear error entry stack
1237 */
1245 /*
1246 * Undo what we did in st_attach & st_doattach,
1247 * freeing resources and removing things we installed.
1248 * The system framework guarantees we are not active
1249 * with this devinfo node in any other entry points at
1250 * this time.
1251 */
1261 /*
1262 * we cannot unload some targets because the
1263 * inquiry returns junk unless immediately
1264 * after a reset
1265 */
1270 }
1272 /*
1273 * if the tape has been removed then we may unload;
1274 * do a test unit ready and if it returns NOT READY
1275 * then we assume that it is safe to unload.
1276 * as a side effect, pmode may be set to invalid if the
1277 * the test unit ready fails;
1278 * also un_state may be set to non-closed, so reset it
1279 */
1287 /*
1288 * Send Test Unit Ready in the hopes that if
1289 * the drive is not in the state we think it is.
1290 * And the state will be changed so it can be detached.
1291 * If the command fails to reach the device and
1292 * the drive was not rewound or unloaded we want
1293 * to fail the detach till a user command fails
1294 * where after the detach will succead.
1295 */
1297 /*
1298 * After TUR un_state may be set to non-closed,
1299 * so reset it back.
1300 */
1303 }
1308 /*
1309 * check again:
1310 * if we are not at BOT then it is not safe to unload
1311 */
1323 "cannot detach: pmode=%d fileno=0x%x, blkno=0x%x"
1329 }
1331 /*
1332 * Just To make sure that we have released the
1333 * tape unit .
1334 */
1340 }
1342 /*
1343 * now remove other data structures allocated in st_doattach()
1344 */
1359 }
1364 }
1369 }
1372 #ifdef __x86
1377 }
1378 #endif
1381 }
1384 }
1387 }
1390 }
1394 }
1397 }
1400 }
1403 }
1407 }
1411 }
1414 }
1427 /*
1428 * Suspend/Resume
1429 *
1430 * To process DDI_SUSPEND, we must do the following:
1431 *
1432 * - check ddi_removing_power to see if power will be turned
1433 * off. if so, return DDI_FAILURE
1434 * - check if we are already suspended,
1435 * if so, return DDI_FAILURE
1436 * - check if device state is CLOSED,
1437 * if not, return DDI_FAILURE.
1438 * - wait until outstanding operations complete
1439 * - save tape state
1440 * - block new operations
1441 * - cancel pending timeouts
1442 *
1443 */
1447 }
1454 /*
1455 * Shouldn't already be suspended, if so return failure
1456 */
1460 }
1464 }
1466 /*
1467 * Wait for all outstanding I/O's to complete
1468 *
1469 * we wait on both ncmds and the wait queue for times
1470 * when we are flushing after persistent errors are
1471 * flagged, which is when ncmds can be 0, and the
1472 * queue can still have I/O's. This way we preserve
1473 * order of biodone's.
1474 */
1476 wait_cmds_complete +=
1483 /*
1484 * Time expired then cancel the command
1485 */
1490 }
1495 }
1496 }
1497 }
1499 /*
1500 * DDI_SUSPEND says that the system "may" power down, we
1501 * remember the file and block number before rewinding.
1502 * we also need to save state before issuing
1503 * any WRITE_FILE_MARK command.
1504 */
1509 /*
1510 * Issue a zero write file fmk command to tell the drive to
1511 * flush any buffered tape marks
1512 */
1515 /*
1516 * Because not all tape drives correctly implement buffer
1517 * flushing with the zero write file fmk command, issue a
1518 * synchronous rewind command to force data flushing.
1519 * st_validate_tapemarks() will do a rewind during DDI_RESUME
1520 * anyway.
1521 */
1524 /* stop any new operations */
1528 /*
1529 * cancel any outstanding timeouts
1530 */
1538 }
1547 }
1549 /*
1550 * Suspend the scsi_watch_thread
1551 */
1558 }
1565 }
1566 }
1569 /* ARGSUSED */
1570 static int
1572 {
1573 dev_t dev;
1596 }
1598 }
1600 static int
1602 {
1610 /*
1611 * Call the routine scsi_probe to do some of the dirty work.
1612 * If the INQUIRY command succeeds, the field sd_inq in the
1613 * device structure will be filled in.
1614 */
1620 /*
1621 * In checking the whole inq_dtype byte we are looking at both
1622 * the Peripheral Qualifier and the Peripheral Device Type.
1623 * For this driver we are only interested in sequential devices
1624 * that are connected or capable if connecting to this logical
1625 * unit.
1626 */
1632 /* Something there but not a tape device */
1635 }
1637 /* Nothing there */
1642 }
1645 /*
1646 * The actual unit is present.
1647 * Now is the time to fill in the rest of our info..
1648 */
1653 }
1662 }
1667 }
1684 }
1691 /*
1692 * use i_ddi_mem_alloc() for now until we have an interface to allocate
1693 * memory for DMA which doesn't require a DMA handle.
1694 */
1707 }
1715 #ifdef __x86
1717 #endif
1719 /* Initialize power managemnet condition variable */
1735 /*
1736 * setting long a initial as it contains logical file info.
1737 * support for long format is mandatory but many drive don't do it.
1738 */
1745 #ifdef __x86
1752 }
1753 #endif
1755 /*
1756 * Since this driver manages devices with "remote" hardware,
1757 * i.e. the devices themselves have no "reg" properties,
1758 * the SUSPEND/RESUME commands in detach/attach will not be
1759 * called by the power management framework unless we request
1760 * it by creating a "pm-hardware-state" property and setting it
1761 * to value "needs-suspend-resume".
1762 */
1765 DDI_PROP_SUCCESS) {
1770 }
1779 }
1787 error:
1794 }
1797 }
1800 }
1803 }
1806 }
1807 #ifdef __x86
1810 }
1811 #endif
1814 }
1818 }
1822 }
1826 }
1828 }
1834 st_get_conf_from_st_dot_conf,
1835 st_get_conf_from_st_conf_dot_c,
1836 st_get_conf_from_tape_drive,
1837 st_get_default_conf
1838 };
1841 /*
1842 * determine tape type, using tape-config-list or built-in table or
1843 * use a generic tape config entry
1844 */
1845 static void
1847 {
1850 uchar_t reserved;
1857 /*
1858 * XXX: Emulex MT-02 (and emulators) predates SCSI-1 and has
1859 * no vid & pid inquiry data. So, we provide one.
1860 */
1864 }
1872 }
1875 /*
1876 * Loop through the configuration methods till one works.
1877 */
1881 }
1882 }
1884 /*
1885 * If we didn't just make up this configuration and
1886 * all the density codes are the same..
1887 * Set Auto Density over ride.
1888 */
1890 /*
1891 * If this device is one that is configured and all
1892 * densities are the same, This saves doing gets and set
1893 * that yield nothing.
1894 */
1900 }
1901 }
1904 /*
1905 * Store tape drive characteristics.
1906 */
1911 /* setup operation time-outs based on options */
1914 /* TLR support */
1918 /* try and enable TLR */
1922 /*
1923 * From attach command failed.
1924 * Set dp type so is run again on open.
1925 */
1935 }
1938 }
1939 }
1941 /* make sure if we are supposed to be variable, make it variable */
1944 }
1949 }
1955 }
1981 };
1983 static int
1986 {
2021 }
2023 /* If not the number of densities continue */
2026 }
2028 /* If number of densities is not in range can't use config */
2031 }
2036 "%s conf version 1 with %d densities has %d items"
2041 "%s conf version 2 with %d densities has %d items"
2044 }
2046 limit++;
2048 count--;
2049 list++;
2053 "%s density[%d] value too low: value ="
2058 "%s density[%d] value too high: value ="
2065 }
2066 }
2067 }
2070 }
2072 static int
2075 {
2087 /*
2088 * Determine type of tape controller. Type is determined by
2089 * checking the vendor ids of the earlier inquiry command and
2090 * comparing those with vids in tape-config-list defined in st.conf
2091 */
2096 }
2101 /*
2102 * Compare vids in each triplet - if it matches, get value for
2103 * data_name and contruct a st_drivetype struct
2104 * tripletlen is not set yet!
2105 */
2119 }
2121 /*
2122 * If inquiry vid dosen't match this triplets vid,
2123 * try the next.
2124 */
2127 }
2129 /*
2130 * if prettylen is zero then use the vid string
2131 */
2135 }
2141 /*
2142 * get the data list
2143 */
2147 /*
2148 * Error in getting property value
2149 * print warning!
2150 */
2153 datanameptr);
2155 }
2157 /*
2158 * now initialize the st_drivetype struct
2159 */
2164 /*
2165 * check if data is enough for version, type,
2166 * bsize, options, # of densities, density1,
2167 * density2, ..., default_density
2168 */
2172 /*
2173 * print warning and skip to next triplet.
2174 */
2177 datanameptr);
2180 }
2187 datanameptr);
2189 }
2191 /*
2192 * check version
2193 */
2196 /* print warning but accept it */
2198 "Version # for data property (%s) "
2200 }
2210 }
2211 }
2215 data_ptr++;
2223 }
2230 }
2232 /*
2233 * free up the memory allocated by ddi_getlongprop
2234 */
2237 }
2239 }
2241 static int
2244 {
2248 /*
2249 * Determine type of tape controller. Type is determined by
2250 * checking the result of the earlier inquiry command and
2251 * comparing vendor ids with strings in a table declared in st_conf.c.
2252 */
2259 }
2263 }
2266 }
2268 }
2270 static int
2273 {
2275 ulong_t maxbsize;
2276 caddr_t buf;
2284 /*
2285 * Determine the type of tape controller. Type is determined by
2286 * sending SCSI commands to tape drive and deriving the type from
2287 * the returned data.
2288 */
2294 /*
2295 * Make up a name
2296 */
2301 /*
2302 * 'clean' vendor and product strings of non-printing chars
2303 */
2307 }
2308 }
2310 /*
2311 * MODE SENSE to determine block size.
2312 */
2322 }
2326 }
2328 /* Can mode sense page 0x10 or 0xf */
2346 "st_get_conf_from_tape_drive(): "
2347 "Fixed record size is too large and"
2349 }
2351 }
2364 }
2365 }
2367 /*
2368 * If READ BLOCk LIMITS works and upper block size limit is
2369 * more than 64K, ST_NO_RECSIZE_LIMIT is supported.
2370 */
2375 "st_get_conf_from_tape_drive(): "
2380 }
2385 }
2388 /*
2389 * Inquiry VPD page 0xb0 to see if the tape drive supports WORM
2390 */
2395 "st_get_conf_from_tape_drive(): "
2400 }
2403 }
2406 /* Assume BSD BSR KNOWS_EOD */
2411 /*
2412 * Decide the densities supported by tape drive by sending
2413 * REPORT DENSITY SUPPORT command.
2414 */
2417 }
2419 /*
2420 * Decide the timeout values for several commands by sending
2421 * REPORT SUPPORTED OPERATION CODES command.
2422 */
2426 }
2431 exit:
2435 }
2437 static int
2440 {
2443 ushort_t des_len;
2445 uchar_t num_den;
2452 /*
2453 * Since we have no idea how many densitiy support entries
2454 * will be returned, we send the command firstly assuming
2455 * there is only one. Then we can decide the number of
2456 * entries by available density support length. If multiple
2457 * entries exist, we will resend the command with enough
2458 * buffer size.
2459 */
2468 }
2469 des_len =
2480 "st_get_conf_from_tape_drive(): "
2484 }
2485 }
2490 /*
2491 * Decide the drive type by assigning organization
2492 */
2498 }
2499 }
2502 "st_get_conf_from_tape_drive(): "
2506 }
2508 /*
2509 * The tape drive may support many tape formats, but the st driver
2510 * supports only the four highest densities. Since density code
2511 * values are returned by ascending sequence, we start from the
2512 * last entry of density support data block descriptor.
2513 */
2521 }
2522 }
2525 p ++;
2526 }
2527 }
2551 }
2565 }
2571 }
2580 }
2582 }
2588 }
2590 static int
2593 {
2594 ushort_t timeout;
2605 }
2607 }
2616 }
2618 }
2627 }
2629 }
2638 }
2640 }
2649 }
2651 }
2661 }
2663 }
2672 }
2674 }
2678 }
2680 static int
2683 {
2686 uchar_t support;
2687 uchar_t cdbsize;
2688 uchar_t ctdp;
2698 service_action);
2702 "st_get_timeouts_value(): "
2706 }
2712 "st_get_timeouts_value(): "
2716 }
2721 "st_get_timeouts_value(): "
2725 }
2730 /*
2731 * Timeout value in seconds is 4 bytes, but we only support the lower 2
2732 * bytes. If the higher 2 bytes are not zero, the timeout value is set
2733 * to 0xFFFF.
2734 */
2740 }
2744 }
2746 static int
2748 {
2756 /*
2757 * Make up a name
2758 */
2767 /*
2768 * 'clean' vendor and product strings of non-printing chars
2769 */
2773 }
2774 }
2779 }
2781 /*
2782 * Regular Unix Entry points
2783 */
2787 /* ARGSUSED */
2788 static int
2790 {
2798 /*
2799 * validate that we are addressing a sensible unit
2800 */
2807 /*
2808 * All device accesss go thru st_strategy() where we check
2809 * suspend status
2810 */
2817 }
2819 }
2821 /*
2822 * Check for the case of the tape in the middle of closing.
2823 * This isn't simply a check of the current state, because
2824 * we could be in state of sensing with the previous state
2825 * that of closing.
2826 *
2827 * And don't allow multiple opens.
2828 */
2838 }
2839 }
2843 }
2845 /*
2846 * record current dev
2847 */
2854 /*
2855 * If we are opening O_NDELAY, or O_NONBLOCK, we don't check for
2856 * anything, leave internal states alone, if fileno >= 0
2857 */
2866 /*
2867 * If position is anything other than rewound.
2868 */
2870 /*
2871 * set un_read_only/write-protect status.
2872 *
2873 * If the tape is not bot we can assume
2874 * that mspl->wp_status is set properly.
2875 * else
2876 * we need to do a mode sense/Tur once
2877 * again to get the actual tape status.(since
2878 * user might have replaced the tape)
2879 * Hence make the st state OFFLINE so that
2880 * we re-intialize the tape once again.
2881 */
2887 }
2896 }
2898 }
2901 /*
2902 * Not opening O_NDELAY.
2903 */
2906 /*
2907 * Clear error entry stack
2908 */
2916 /*
2917 * Release the tape unit, if reserved and not
2918 * preserve reserve.
2919 */
2923 st_uscsi_cmd);
2924 }
2927 }
2928 }
2930 exit:
2931 /*
2932 * we don't want any uninvited guests scrogging our data when we're
2933 * busy with something, so for successful opens or failed opens
2934 * (except for EBUSY), reset these counters and state appropriately.
2935 */
2939 }
2942 }
2943 busy:
2949 }
2951 static int
2953 {
2964 /*
2965 * Clean up after any errors left by 'last' close.
2966 * This also handles the case of the initial open.
2967 */
2971 }
2975 /*
2976 * do a throw away TUR to clear check condition
2977 */
2980 /*
2981 * If test unit ready fails because the drive is reserved
2982 * by another host fail the open for no access.
2983 */
2999 }
3000 }
3001 }
3003 /*
3004 * Tape self identification could fail if the tape drive is used by
3005 * another host during attach time. We try to get the tape type
3006 * again. This is also applied to any posponed configuration methods.
3007 */
3011 }
3013 /*
3014 * If the tape type is still invalid, try to determine the generic
3015 * configuration.
3016 */
3022 }
3028 }
3029 /*
3030 * If this is a Unknown Type drive,
3031 * Use the READ BLOCK LIMITS to determine if
3032 * allow large xfer is approprate if not globally
3033 * disabled with st_allow_large_xfer.
3034 */
3038 /*
3039 * If we allow_large_xfer (ie >64k) and have not yet found out
3040 * the max block size supported by the drive,
3041 * find it by issueing a READ_BLKLIM command.
3042 * if READ_BLKLIM cmd fails, assume drive doesn't
3043 * allow_large_xfer and min/max block sizes as 1 byte and 63k.
3044 */
3047 }
3048 /*
3049 * if maxbsize is unknown, set the maximum block size.
3050 */
3053 /*
3054 * Get the Block limits of the tape drive.
3055 * if un->un_allow_large_xfer = 0 , then make sure
3056 * that maxbsize is <= ST_MAXRECSIZE_FIXED.
3057 */
3062 /* Retry */
3064 }
3067 /*
3068 * if cmd successful, use limit returned
3069 */
3082 /*
3083 * Drive is not one that is configured, But the
3084 * READ BLOCK LIMITS tells us it can do large
3085 * xfers.
3086 */
3089 ST_NO_RECSIZE_LIMIT;
3090 }
3091 /*
3092 * If max and mimimum block limits are the
3093 * same this is a fixed block size device.
3094 */
3097 }
3098 }
3102 }
3107 "!st_tape_init: Error on READ BLOCK LIMITS,"
3111 /*
3112 * since read block limits cmd failed,
3113 * do not allow large xfers.
3114 * use old values in st_minphys
3115 */
3123 /*
3124 * we guess maxbsize and minbsize
3125 */
3132 }
3133 /*
3134 * Data Mod must be set,
3135 * Even if read block limits fails.
3136 * Prevents Divide By Zero in st_rw().
3137 */
3139 }
3140 }
3144 }
3148 }
3149 }
3164 }
3165 /*
3166 * Make sure the tape is ready
3167 */
3170 /*
3171 * allow open no media. Subsequent MTIOCSTATE
3172 * with media present will complete the open
3173 * logic.
3174 */
3184 "st_tape_init EIO no media, not opened "
3188 }
3189 }
3190 }
3192 /*
3193 * On each open, initialize block size from drivetype struct,
3194 * as it could have been changed by MTSRSZ ioctl.
3195 * Now, ST_VARIABLE simply means drive is capable of variable
3196 * mode. All drives are assumed to support fixed records.
3197 * Hence, un_bsize tells what mode the drive is in.
3198 * un_bsize = 0 - variable record length
3199 * = x - fixed record length is x
3200 */
3203 /*
3204 * If saved position is valid go there
3205 */
3214 }
3218 }
3219 }
3226 }
3233 }
3234 }
3236 /*
3237 * do a mode sense to pick up state of current write-protect,
3238 * Could cause reserve and fail due to conflict.
3239 */
3244 }
3245 }
3247 /*
3248 * If we are opening the tape for writing, check
3249 * to make sure that the tape can be written.
3250 */
3258 /*
3259 * STK sets the wp bit if volsafe tape is loaded.
3260 */
3266 }
3269 }
3272 }
3286 }
3287 }
3289 /*
3290 * If we're opening the tape write-only, we need to
3291 * write 2 filemarks on the HP 1/2 inch drive, to
3292 * create a null file.
3293 */
3300 }
3303 }
3308 /*
3309 * Make sure the density can be selected correctly.
3310 * If WORM can only write at the append point which in most cases
3311 * isn't BOP. st_determine_density() with a B_WRITE only attempts
3312 * to set and try densities if a BOP.
3313 */
3323 }
3325 /*
3326 * Destroy the knowledge that we have 'determined'
3327 * density so that a later read at BOT comes along
3328 * does the right density determination.
3329 */
3334 /*
3335 * Okay, the tape is loaded and either at BOT or somewhere past.
3336 * Mark the state such that any I/O or tape space operations
3337 * will get/set the right density, etc..
3338 */
3344 /*
3345 * Set test append flag if writing.
3346 * First write must check that tape is positioned correctly.
3347 */
3350 /*
3351 * if there are pending unit attention flags.
3352 * Check that the media has not changed.
3353 */
3358 }
3360 }
3362 exit:
3371 }
3375 /* ARGSUSED */
3376 static int
3378 {
3382 #ifdef __x86
3384 #endif
3390 /*
3391 * wait till all cmds in the pipeline have been completed
3392 */
3400 /* turn off persistent errors on close, as we want close to succeed */
3403 /*
3404 * set state to indicate that we are in process of closing
3405 */
3411 /*
3412 * BSD behavior:
3413 * a close always causes a silent span to the next file if we've hit
3414 * an EOF (but not yet read across it).
3415 */
3420 }
3422 }
3424 /*
3425 * SVR4 behavior for skipping to next file:
3426 *
3427 * If we have not seen a filemark, space to the next file
3428 *
3429 * If we have already seen the filemark we are physically in the next
3430 * file and we only increment the filenumber
3431 */
3441 /*
3442 * if we were reading and did not read the complete file
3443 * skip to the next file, leaving the tape correctly
3444 * positioned to read the first record of the next file
3445 * Check first for REEL if we are at EOT by trying to
3446 * read a block
3447 */
3453 SCSI_DEBUG,
3457 }
3463 }
3464 }
3476 }
3490 /* nothing to do */
3496 }
3497 }
3500 /*
3501 * For performance reasons (HP 88780), the driver should
3502 * postpone writing the second tape mark until just before a file
3503 * positioning ioctl is issued (e.g., rewind). This means that
3504 * the user must not manually rewind the tape because the tape will
3505 * be missing the second tape mark which marks EOM.
3506 * However, this small performance improvement is not worth the risk.
3507 */
3509 /*
3510 * We need to back up over the filemark we inadvertently popped
3511 * over doing a read in between the two filemarks that constitute
3512 * logical eot for 1/2" tapes. Note that ST_EOT_PENDING is only
3513 * set while reading.
3514 *
3515 * If we happen to be at physical eot (ST_EOM) (writing case),
3516 * the writing of filemark(s) will clear the ST_EOM state, which
3517 * we don't want, so we save this state and restore it later.
3518 */
3534 }
3537 }
3539 /*
3540 * Do we need to write a file mark?
3541 *
3542 * only write filemarks if there are fmks to be written and
3543 * - open for write (possibly read/write)
3544 * - the last operation was a write
3545 * or:
3546 * - opened for wronly
3547 * - no data was written
3548 */
3555 /* save ST_EOM state */
3558 /*
3559 * Note that we will write a filemark if we had opened
3560 * the tape write only and no data was written, thus
3561 * creating a null file.
3562 *
3563 * If the user already wrote one, we only have to write 1 more.
3564 * If they wrote two, we don't have to write any.
3565 */
3574 }
3579 SCSI_DEBUG,
3583 }
3585 /* fix up block number */
3587 }
3588 }
3590 /*
3591 * If we aren't going to be rewinding, and we were at
3592 * physical eot, restore the state that indicates we
3593 * are at physical eot. Once you have reached physical
3594 * eot, and you close the tape, the only thing you can
3595 * do on the next open is to rewind. Access to trailer
3596 * records is only allowed without closing the device.
3597 */
3600 }
3601 }
3603 /*
3604 * report soft errors if enabled and available, if we never accessed
3605 * the drive, don't get errors. This will prevent some DAT error
3606 * messages upon LOG SENSE.
3607 */
3614 }
3615 }
3618 /*
3619 * Do we need to rewind? Can we rewind?
3620 */
3623 /*
3624 * We'd like to rewind with the
3625 * 'immediate' bit set, but this
3626 * causes problems on some drives
3627 * where subsequent opens get a
3628 * 'NOT READY' error condition
3629 * back while the tape is rewinding,
3630 * which is impossible to distinguish
3631 * from the condition of 'no tape loaded'.
3632 *
3633 * Also, for some targets, if you disconnect
3634 * with the 'immediate' bit set, you don't
3635 * actually return right away, i.e., the
3636 * target ignores your request for immediate
3637 * return.
3638 *
3639 * Instead, we'll fire off an async rewind
3640 * command. We'll mark the device as closed,
3641 * and any subsequent open will stall on
3642 * the first TEST_UNIT_READY until the rewind
3643 * completes.
3644 */
3646 /*
3647 * Used to be if reserve was not supported we'd send an
3648 * asynchronious rewind. Comments above may be slightly invalid
3649 * as the immediate bit was never set. Doing an immedate rewind
3650 * makes sense, I think fixes to not ready status might handle
3651 * the problems described above.
3652 */
3656 }
3658 /* flush data for older drives per scsi spec. */
3662 /* release the drive before rewind immediate */
3665 ST_RESERVE) {
3667 st_uscsi_cmd)) {
3669 }
3670 }
3672 /* send rewind with immediate bit set */
3675 }
3676 }
3677 }
3678 /*
3679 * Setting positions invalid in case the rewind doesn't
3680 * happen. Drives don't like to rewind if resets happen
3681 * they will tend to move back to where the rewind was
3682 * issued if a reset or something happens so that if a
3683 * write happens the data doesn't get clobbered.
3684 *
3685 * Not a big deal if the position is invalid when the
3686 * open occures it will do a read position.
3687 */
3693 }
3694 }
3696 /*
3697 * eject tape if necessary
3698 */
3711 }
3712 }
3713 /*
3714 * Release the tape unit, if default reserve/release
3715 * behaviour.
3716 */
3721 }
3722 error_out:
3723 /*
3724 * clear up state
3725 */
3735 /* Restore the options to the init time settings */
3740 }
3746 }
3752 }
3756 /*
3757 * Signal anyone awaiting a close operation to complete.
3758 */
3761 /*
3762 * any kind of error on closing causes all state to be tossed
3763 */
3765 /*
3766 * note that st_intr has already set
3767 * un_pos.pmode to invalid.
3768 */
3770 }
3772 #ifdef __x86
3773 /*
3774 * free any contiguous mem alloc'ed for big block I/O
3775 */
3780 }
3785 }
3790 #endif
3798 }
3800 /*
3801 * These routines perform raw i/o operations.
3802 */
3804 /* ARGSUSED2 */
3805 static int
3807 {
3808 #ifdef STDEBUG
3811 #endif
3813 }
3816 /* ARGSUSED2 */
3817 static int
3819 {
3820 #ifdef STDEBUG
3823 #endif
3825 }
3829 /* ARGSUSED */
3830 static int
3832 {
3833 #ifdef STDEBUG
3836 #endif
3838 }
3840 /* ARGSUSED */
3841 static int
3843 {
3844 #ifdef STDEBUG
3847 #endif
3849 }
3851 /*
3852 * Due to historical reasons, old limits are: For variable-length devices:
3853 * if greater than 64KB - 1 (ST_MAXRECSIZE_VARIABLE), block into 64 KB - 2
3854 * ST_MAXRECSIZE_VARIABLE_LIMIT) requests; otherwise,
3855 * (let it through unmodified. For fixed-length record devices:
3856 * 63K (ST_MAXRECSIZE_FIXED) is max (default minphys).
3857 *
3858 * The new limits used are un_maxdma (retrieved using scsi_ifgetcap()
3859 * from the HBA) and un_maxbsize (retrieved by sending SCMD_READ_BLKLIM
3860 * command to the drive).
3861 *
3862 */
3863 static void
3865 {
3878 /*
3879 * check un_maxbsize for variable length devices only
3880 */
3883 }
3884 /*
3885 * can't go more that HBA maxdma limit in either fixed-length
3886 * or variable-length tape drives.
3887 */
3890 }
3893 /*
3894 * use old fixed limits
3895 */
3899 }
3903 }
3904 }
3905 }
3907 /*
3908 * For regular raw I/O and Fixed Block length devices, make sure
3909 * the adjusted block count is a whole multiple of the device
3910 * block size.
3911 */
3914 }
3915 }
3917 static int
3919 {
3931 /* get local copy of transfer length */
3936 /*
3937 * Clear error entry stack
3938 */
3941 /*
3942 * If in fixed block size mode and requested read or write
3943 * is not an even multiple of that block size.
3944 */
3950 }
3952 /* If device has set granularity in the READ_BLKLIM we honor it. */
3958 }
3963 }
3969 }
3971 /*
3972 * Reset this so it can be set if Berkeley and read over a filemark.
3973 */
3981 /*
3982 * if we have hit logical EOT during this xfer and there is not a
3983 * full residue, then set eof back to ST_EOM to make sure that
3984 * the user will see at least one zero write
3985 * after this short write
3986 */
3991 }
3997 }
3998 }
4004 }
4011 }
4013 static int
4015 {
4028 /* get local copy of transfer length */
4033 /*
4034 * If in fixed block size mode and requested read or write
4035 * is not an even multiple of that block size.
4036 */
4042 }
4044 /* If device has set granularity in the READ_BLKLIM we honor it. */
4050 }
4055 }
4061 }
4067 rval =
4070 /*
4071 * if we have hit logical EOT during this xfer and there is not a
4072 * full residue, then set eof back to ST_EOM to make sure that
4073 * the user will see at least one zero write
4074 * after this short write
4075 *
4076 * we keep this here just in case the application is not using
4077 * persistent errors
4078 */
4083 }
4090 }
4091 }
4096 }
4100 static int
4102 {
4107 /*
4108 * validate arguments
4109 */
4118 }
4126 }
4132 /*
4133 * If persistent errors have been flagged, just nix this one. We wait
4134 * for any outstanding I/O's below, so we will be in order.
4135 */
4138 }
4140 /*
4141 * If last command was non queued, wait till it finishes.
4142 */
4145 /* woke up because of an error */
4148 }
4149 }
4151 /*
4152 * s_buf and recovery commands shouldn't come here.
4153 */
4157 /*
4158 * If we haven't done/checked reservation on the tape unit
4159 * do it now.
4160 */
4167 }
4169 /*
4170 * Enter here to restore position for possible
4171 * resets when the device was closed and opened
4172 * in O_NDELAY mode subsequently
4173 */
4178 }
4180 }
4182 /*
4183 * If we are offline, we have to initialize everything first.
4184 * This is to handle either when opened with O_NDELAY, or
4185 * we just got a new tape in the drive, after an offline.
4186 * We don't observe O_NDELAY past the open,
4187 * as it will not make sense for tapes.
4188 */
4190 /*
4191 * reset state to avoid recursion
4192 */
4201 }
4202 /* un_restore_pos make invalid */
4205 }
4206 /*
4207 * Check for legal operations
4208 */
4213 }
4218 /*
4219 * Process this first. If we were reading, and we're pending
4220 * logical eot, that means we've bumped one file mark too far.
4221 */
4223 /*
4224 * Recursion warning: st_cmd will route back through here.
4225 * Not anymore st_cmd will go through st_strategy()!
4226 */
4232 }
4235 }
4237 /*
4238 * If we are in the process of opening, we may have to
4239 * determine/set the correct density. We also may have
4240 * to do a test_append (if QIC) to see whether we are
4241 * in a position to append to the end of the tape.
4242 *
4243 * If we're already at logical eot, we transition
4244 * to ST_NO_EOF. If we're at physical eot, we punt
4245 * to the switch statement below to handle.
4246 */
4253 }
4254 }
4267 /*
4268 * st_test_append() will do it all
4269 */
4273 }
4274 }
4277 }
4280 }
4283 /*
4284 * Process rest of END OF FILE and END OF TAPE conditions
4285 */
4293 /*
4294 * This allows writes to proceed past physical
4295 * eot. We'll *really* be in trouble if the
4296 * user continues blindly writing data too
4297 * much past this point (unwind the tape).
4298 * Physical eot really means 'early warning
4299 * eot' in this context.
4300 *
4301 * Every other write from now on will succeed
4302 * (if sufficient tape left).
4303 * This write will return with resid == count
4304 * but the next one should be successful
4305 *
4306 * Note that we only transition to logical EOT
4307 * if the last state wasn't the OPENING state.
4308 * We explicitly prohibit running up to physical
4309 * eot, closing the device, and then re-opening
4310 * to proceed. Trailer records may only be gotten
4311 * at by keeping the tape open after hitting eot.
4312 *
4313 * Also note that ST_EOM cannot be set by reading-
4314 * this can only be set during writing. Reading
4315 * up to the end of the tape gets a blank check
4316 * or a double-filemark indication (ST_EOT_PENDING),
4317 * and we prohibit reading after that point.
4318 *
4319 */
4322 /*
4323 * this allows st_rw() to reset it back to
4324 * will see a zero write
4325 */
4327 }
4337 }
4341 }
4352 }
4353 /* FALLTHROUGH */
4359 }
4365 }
4372 }
4379 }
4389 "st_queued_strategy: cmd=0x%p count=%ld resid=%ld flags=0x%x"
4394 #ifdef __x86
4395 /*
4396 * We will replace bp with a new bp that can do big blk xfer
4397 * if the requested xfer size is bigger than un->un_maxdma_arch
4398 *
4399 * Also, we need to make sure that we're handling real I/O
4400 * by checking group 0/1 SCSI I/O commands, if needed
4401 */
4410 }
4411 #endif
4413 /* put on wait queue */
4427 b_done_err:
4432 b_done:
4436 exit:
4437 /*
4438 * make sure no commands are outstanding or waiting before closing,
4439 * so we can guarantee order
4440 */
4444 /* override errno here, if persistent errors were flagged */
4453 }
4456 static int
4458 {
4461 /*
4462 * validate arguments
4463 */
4474 }
4482 }
4498 "st_strategy: cmd=0x%x count=%ld resid=%ld flags=0x%x"
4508 }
4510 /*
4511 * this routine spaces forward over filemarks
4512 */
4513 static int
4515 {
4526 /*
4527 * the risk with doing only one space operation is that we
4528 * may accidentily jump in old data
4529 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
4530 * because the 8200 does not append a marker; in order not to
4531 * sacrifice the fast file skip, we do a slow skip if the low
4532 * density device has been opened
4533 */
4542 }
4550 }
4552 /*
4553 * read a block to see if we have reached
4554 * end of medium (double filemark for reel or
4555 * medium error for others)
4556 */
4560 SCSI_DEBUG,
4561 "space_fmks : EIO can't do "
4565 }
4570 SCSI_DEBUG,
4578 count--;
4581 SCSI_DEBUG,
4585 }
4587 }
4588 }
4591 }
4594 }
4596 /*
4597 * this routine spaces to EOD
4598 *
4599 * it keeps track of the current filenumber and returns the filenumber after
4600 * the last successful space operation, we keep the number high because as
4601 * tapes are getting larger, the possibility of more and more files exist,
4602 * 0x100000 (1 Meg of files) probably will never have to be changed any time
4603 * soon
4604 */
4607 static int
4609 {
4610 tapepos_t savepos;
4616 }
4628 /*
4629 * see if the drive is smart enough to do the skips in
4630 * one operation; 1/2" use two filemarks
4631 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
4632 * because the 8200 does not append a marker; in order not to
4633 * sacrifice the fast file skip, we do a slow skip if the low
4634 * density device has been opened
4635 */
4644 }
4647 }
4654 }
4660 }
4665 /*
4666 * What we return will become the current file position.
4667 * After completing the space command with the position
4668 * mode that is not invalid a read position command will
4669 * be automaticly issued. If the drive support the long
4670 * read position format a valid file position can be
4671 * returned.
4672 */
4674 }
4678 }
4684 /*
4685 * If we're not EOM smart, space a record
4686 * to see whether we're now in the slot between
4687 * the two sequential filemarks that logical
4688 * EOM consists of (REEL) or hit nowhere land
4689 * (8mm).
4690 */
4692 /*
4693 * no fast skipping, check a record
4694 */
4697 }
4704 }
4709 }
4712 }
4716 }
4717 }
4718 }
4722 }
4729 }
4732 /*
4733 * this routine is frequently used in ioctls below;
4734 * it determines whether we know the density and if not will
4735 * determine it
4736 * if we have written the tape before, one or more filemarks are written
4737 *
4738 * depending on the stepflag, the head is repositioned to where it was before
4739 * the filemarks were written in order not to confuse step counts
4740 */
4741 #define STEPBACK 0
4742 #define NO_STEPBACK 1
4744 static int
4746 {
4753 "st_check_density_or_wfm(dev= 0x%lx, wfm= %d, mode= %d, stpflg= %d)"
4758 /*
4759 * If we don't yet know the density of the tape we have inserted,
4760 * we have to either unconditionally set it (if we're 'writing'),
4761 * or we have to determine it. As side effects, check for any
4762 * write-protect errors, and for the need to put out any file-marks
4763 * before positioning a tape.
4764 *
4765 * If we are going to be spacing forward, and we haven't determined
4766 * the tape density yet, we have to do so now...
4767 */
4771 "check_density_or_wfm : EIO can't determine "
4775 }
4776 /*
4777 * Presumably we are at BOT. If we attempt to write, it will
4778 * either work okay, or bomb. We don't do a st_test_append
4779 * unless we're past BOT.
4780 */
4788 tapepos_t spos;
4792 /*
4793 * We need to write one or two filemarks.
4794 * In the case of the HP, we need to
4795 * position the head between the two
4796 * marks.
4797 */
4801 }
4810 }
4815 "check_density_or_wfm : EIO can't space "
4819 }
4821 }
4822 }
4824 /*
4825 * Whatever we do at this point clears the state of the eof flag.
4826 */
4830 /*
4831 * If writing, let's check that we're positioned correctly
4832 * at the end of tape before issuing the next write.
4833 */
4836 }
4840 }
4843 /*
4844 * Wait for all outstaning I/O's to complete
4845 *
4846 * we wait on both ncmds and the wait queue for times when we are flushing
4847 * after persistent errors are flagged, which is when ncmds can be 0, and the
4848 * queue can still have I/O's. This way we preserve order of biodone's.
4849 */
4850 static void
4852 {
4857 }
4858 }
4860 /*
4861 * This routine implements the ioctl calls. It is called
4862 * from the device switch at normal priority.
4863 */
4864 /*ARGSUSED*/
4865 static int
4868 {
4880 "st_ioctl(): fileno=%x, blkno=%x, eof=%x, state = %d, "
4885 /*
4886 * We don't want to block on these, so let them through
4887 * and we don't care about setting driver states here.
4888 */
4893 }
4895 /*
4896 * We clear error entry stack except command
4897 * MTIOCGETERROR and MTIOCGET
4898 */
4902 }
4904 /*
4905 * wait for all outstanding commands to complete, or be dequeued.
4906 * And because ioctl's are synchronous commands, any return value
4907 * after this, will be in order
4908 */
4911 /*
4912 * allow only a through clear errors and persistent status, and
4913 * status
4914 */
4923 }
4924 }
4930 /*
4931 * first and foremost, handle any ST_EOT_PENDING cases.
4932 * That is, if a logical eot is pending notice, notice it.
4933 */
4944 }
4950 }
4952 /* fix up block number */
4954 /* now we're at logical eot */
4956 }
4958 /*
4959 * now, handle the rest of the situations
4960 */
4961 check_commands:
4964 {
4965 #ifdef _MULTI_DATAMODEL
4966 /*
4967 * For use when a 32 bit app makes a call into a
4968 * 64 bit ioctl
4969 */
4974 /* Get tape status */
4988 }
4989 /*
4990 * If the value is positive fine.
4991 * If its negative we need to return a value based on the
4992 * old way if counting backwards from INF (1,000,000,000).
4993 */
4998 }
5003 }
5009 /* Emulex cartridge tape */
5016 }
5017 }
5019 /*
5020 * If large transfers are allowed and drive options
5021 * has no record size limit set. Calculate blocking
5022 * factor from the lesser of maxbsize and maxdma.
5023 */
5028 }
5033 }
5035 /*
5036 * In persistent error mode sending a non-queued can hang
5037 * because this ioctl gets to be run without turning off
5038 * persistense. Fake the answer based on previous info.
5039 */
5044 }
5046 /*
5047 * If zero is returned or in persistent mode,
5048 * use the old data.
5049 */
5054 }
5056 TAPE_ALERT_STILL_DIRTY)) {
5058 }
5062 }
5068 #ifdef _MULTI_DATAMODEL
5072 /*
5073 * Convert 64 bit back to 32 bit before doing
5074 * copyout. This is what the ILP32 app expects.
5075 */
5088 }
5094 }
5096 }
5100 }
5104 }
5106 /*
5107 * get error entry from error stack
5108 */
5117 {
5118 /*
5119 * return when media presence matches state
5120 */
5137 }
5144 }
5147 {
5148 #ifdef _MULTI_DATAMODEL
5149 /*
5150 * For use when a 32 bit app makes a call into a
5151 * 64 bit ioctl
5152 */
5156 /*
5157 * return mtdrivetype
5158 */
5167 #ifdef _MULTI_DATAMODEL
5170 {
5175 }
5182 }
5188 }
5190 }
5197 }
5200 /*
5201 * if requested size is < 0 then return
5202 * error.
5203 */
5207 }
5218 }
5220 /*
5221 * Speed hasn't been used since the hayday of reel tape.
5222 * For all drives not setting the option ST_KNOWS_MEDIA
5223 * the speed member renamed to mediatype are zeros.
5224 * Those drives that have ST_KNOWS_MEDIA set use the
5225 * new mediatype member which is used to figure the
5226 * type of media loaded.
5227 *
5228 * So as to not break applications speed in the
5229 * mtdrivetype structure is not renamed.
5230 */
5233 }
5242 /*
5243 * Limit the maximum length of the result to
5244 * sizeof (struct mtdrivetype).
5245 */
5251 }
5253 }
5259 }
5265 }
5278 }
5286 {
5287 /* clear persistent errors */
5295 }
5298 {
5299 /*
5300 * this is just a holder to make a valid ioctl and
5301 * it won't be in any earlier release
5302 */
5307 }
5310 {
5314 /*
5315 * Check if Reserve/Release is supported.
5316 */
5320 }
5326 }
5328 }
5331 {
5335 /*
5336 * Check if Reserve/Release is supported.
5337 */
5341 }
5343 /*
5344 * Used to just clear ST_PRESERVE_RESERVE which
5345 * made the reservation release at next close.
5346 * As the user may have opened and then done a
5347 * persistant reservation we now need to drop
5348 * the reservation without closing if the user
5349 * attempts to do this.
5350 */
5356 }
5359 {
5363 /*
5364 * Check if Reserve/Release is supported.
5365 */
5369 }
5370 /*
5371 * allow only super user to run this.
5372 */
5376 }
5377 /*
5378 * Throw away reserve,
5379 * not using test-unit-ready
5380 * since reserve can succeed without tape being
5381 * present in the drive.
5382 */
5388 }
5391 {
5402 }
5404 }
5418 {
5425 }
5430 }
5444 }
5446 }
5449 {
5456 }
5461 }
5475 }
5477 }
5480 {
5487 }
5498 }
5504 }
5506 }
5516 }
5517 }
5521 {
5522 tapepos_t dest;
5530 }
5534 }
5536 }
5541 }
5543 exit:
5546 }
5551 }
5554 /*
5555 * do some MTIOCTOP tape operations
5556 */
5557 static int
5559 {
5560 #ifdef _MULTI_DATAMODEL
5561 /*
5562 * For use when a 32 bit app makes a call into a
5563 * 64 bit ioctl
5564 */
5575 #ifdef _MULTI_DATAMODEL
5581 }
5589 }
5591 /* prevent sign extention */
5594 }
5599 }
5601 /* prevent sign extention */
5607 #ifdef _MULTI_DATAMODEL
5613 }
5614 /*
5615 * Convert 64 bit back to 32 bit before doing
5616 * copyout. This is what the ILP32 app expects.
5617 */
5624 }
5632 }
5634 }
5643 }
5644 }
5654 }
5658 }
5660 static int
5662 {
5669 }
5675 }
5677 }
5680 static int
5682 {
5697 /*
5698 * if we are going to mess with a tape, we have to make sure we have
5699 * one and are not offline (i.e. no tape is initialized). We let
5700 * commands pass here that don't actually touch the tape, except for
5701 * loading and initialization (rewinding).
5702 */
5707 /*
5708 * We don't want strategy calling st_tape_init here,
5709 * so, change state
5710 */
5717 /*
5718 * reinitialize by normal means
5719 */
5729 }
5731 }
5734 }
5735 }
5737 /*
5738 * If the file position is invalid, allow only those
5739 * commands that properly position the tape and fail
5740 * the rest with EIO
5741 */
5759 /* NOTREACHED */
5771 /* NOTREACHED */
5772 }
5773 }
5777 /*
5778 * MTERASE rewinds the tape, erase it completely, and returns
5779 * to the beginning of the tape
5780 */
5786 }
5791 }
5798 "st_do_mtioctop : EIO space or erase or "
5802 /* QIC and helical scan rewind after erase */
5805 }
5806 }
5810 /*
5811 * write an end-of-file record
5812 */
5818 }
5820 /*
5821 * zero count means just flush buffers
5822 * negative count is not permitted
5823 */
5826 }
5828 /* Not on worm */
5831 }
5836 "st_do_mtioctop : EIO : MTWEOF can't "
5839 }
5840 }
5844 /*
5845 * Failure due to something other than illegal
5846 * request results in loss of state (st_intr).
5847 */
5849 "st_do_mtioctop : EIO : MTWEOF can't write "
5852 }
5856 /*
5857 * retension the tape
5858 */
5865 }
5869 /*
5870 * rewind the tape
5871 */
5874 "st_do_mtioctop : EIO:MTREW check "
5877 }
5882 }
5886 /*
5887 * rewinds, and, if appropriate, takes the device offline by
5888 * unloading the tape
5889 */
5892 "st_do_mtioctop :EIO:MTOFFL check "
5895 }
5901 }
5909 /*
5910 * This is to load a tape into the drive
5911 * Note that if the tape is not loaded, the device will have
5912 * to be opened via O_NDELAY or O_NONBLOCK.
5913 */
5914 /*
5915 * Let's try and clean things up, if we are not
5916 * initializing, and then send in the load command, no
5917 * matter what.
5918 *
5919 * load after a media change by the user.
5920 */
5924 }
5926 /* Load command to a drive that doesn't support load */
5929 /* Medium not present */
5933 /* CSL not present */
5939 }
5944 /*
5945 * If load tape fails, who knows what happened...
5946 */
5949 }
5951 /*
5952 * reset all counters appropriately using rewind, as if LOAD
5953 * succeeds, we are at BOT
5954 */
5961 }
5965 "st_do_mtioctop : EIO : MTLOAD calls "
5969 }
5980 /*
5981 * positions the tape at a location just after the last file
5982 * written on the tape. For cartridge and 8 mm, this after
5983 * the last file mark; for reel, this is inbetween the two
5984 * last 2 file marks
5985 */
5989 /*
5990 * If the command wants to move to logical end
5991 * of media, and we're already there, we're done.
5992 * If we were at logical eot, we reset the state
5993 * to be *not* at logical eot.
5994 *
5995 * If we're at physical or logical eot, we prohibit
5996 * forward space operations (unconditionally).
5997 *
5998 * Also if the last operation was a write of any
5999 * kind the tape is at EOD.
6000 */
6002 }
6003 /*
6004 * physical tape position may not be what we've been
6005 * telling the user; adjust the request accordingly
6006 */
6010 }
6014 "st_do_mtioctop : EIO:MTEOM check density/wfm "
6017 }
6019 /*
6020 * st_find_eod() returns the last fileno we knew about;
6021 */
6031 /*
6032 * For 1/2" reel tapes assume logical EOT marked
6033 * by two file marks or we don't care that we may
6034 * be extending the last file on the tape.
6035 */
6040 SCSI_DEBUG,
6041 "st_do_mtioctop : EIO : MTEOM space"
6045 }
6046 /*
6047 * Fix up the block number.
6048 */
6051 }
6055 }
6096 /*
6097 * Set record-size to that sent by user
6098 * Check to see if there is reason that the requested
6099 * block size should not be set.
6100 */
6102 /* If requesting variable block size is it ok? */
6106 }
6108 /*
6109 * If requested block size is not variable "0",
6110 * is it less then minimum.
6111 */
6115 }
6117 /* Is the requested block size more then maximum */
6121 }
6123 /* Is requested block size a modulus the device likes */
6126 }
6132 }
6137 /*
6138 * Get record-size to the user
6139 */
6152 /*
6153 * This bit of magic make mt print the actual position if
6154 * the resulting position was not what was asked for.
6155 */
6161 }
6162 }
6170 }
6178 }
6183 }
6186 }
6189 /*
6190 * Run a command for uscsi ioctl.
6191 */
6192 static int
6194 {
6209 /*
6210 * We really don't know what commands are coming in here and
6211 * we don't want to limit the commands coming in.
6212 *
6213 * If st_tape_init() gets called from st_strategy(), then we
6214 * will hang the process waiting for un->un_sbuf_busy to be cleared,
6215 * which it never will, as we set it below. To prevent
6216 * st_tape_init() from getting called, we have to set state to other
6217 * than ST_STATE_OFFLINE, so we choose ST_STATE_INITIALIZING, which
6218 * achieves this purpose already.
6219 *
6220 * We use offline_state to preserve the OFFLINE state, if it exists,
6221 * so other entry points to the driver might have the chance to call
6222 * st_tape_init().
6223 */
6228 }
6237 }
6241 /* check to see if this command requires the drive to be reserved */
6247 }
6248 /*
6249 * If this is a space command we need to save the starting
6250 * point so we can retry from there if the command fails.
6251 */
6255 }
6256 }
6258 /*
6259 * Forground should not be doing anything while recovery is active.
6260 */
6263 /*
6264 * Get buffer resources...
6265 */
6270 #ifdef STDEBUG
6282 }
6283 }
6286 /*
6287 * Although st_uscsi_cmd() never makes use of these
6288 * now, we are just being safe and consistent.
6289 */
6298 }
6305 /*
6306 * If scsi reset successful, don't write any filemarks.
6307 */
6311 }
6313 exit_free:
6314 /*
6315 * Free resources
6316 */
6320 /*
6321 * If was a space command need to update logical block position.
6322 * If the command failed such that positioning is invalid, Don't
6323 * update the position as the user must do this to validate the
6324 * position for data protection.
6325 */
6332 /*
6333 * Set running position to invalid so it updates on the
6334 * next command.
6335 */
6337 }
6345 exit:
6346 /* don't lose offline state */
6349 }
6353 }
6355 static int
6357 {
6370 /*
6371 * write one filemark at the time after EOT
6372 */
6378 }
6383 }
6384 }
6389 }
6394 }
6395 }
6399 }
6401 #ifdef STDEBUG
6402 static void
6404 {
6421 }
6422 #endif
6425 /*
6426 * Command start && done functions
6427 */
6429 /*
6430 * st_start()
6431 *
6432 * Called from:
6433 * st_strategy() to start a command.
6434 * st_runout() to retry when scsi_pkt allocation fails on previous attempt(s).
6435 * st_attach() when resuming from power down state.
6436 * st_start_restart() to retry transport when device was previously busy.
6437 * st_done_and_mutex_exit() to start the next command when previous is done.
6438 *
6439 * On entry:
6440 * scsi_pkt may or may not be allocated.
6441 *
6442 */
6443 static void
6445 {
6457 /* recovery commands can happen anytime */
6461 /* sbuf commands should only happen with an empty queue. */
6469 }
6476 }
6480 /*
6481 * Don't send more than un_throttle commands to the HBA
6482 */
6484 /*
6485 * if doing recovery we know there is outstanding commands.
6486 */
6500 }
6502 }
6503 }
6505 /*
6506 * If the buf has no scsi_pkt call st_make_cmd() to get one and
6507 * build the command.
6508 */
6515 /*
6516 * Some HBA's don't call bioerror() to set an error.
6517 * And geterror() returns zero if B_ERROR is not set.
6518 * So if we get zero we must check b_error.
6519 */
6523 }
6525 /*
6526 * Some HBA's convert DDI_DMA_NORESOURCES into ENOMEM.
6527 * In tape ENOMEM has special meaning so we'll change it.
6528 */
6532 }
6534 /*
6535 * Did it fail and is it retryable?
6536 * If so return and wait for the callback through st_runout.
6537 * Also looks like scsi_init_pkt() will setup a callback even
6538 * if it isn't retryable.
6539 */
6542 /*
6543 * If first attempt save state.
6544 */
6548 }
6556 }
6558 /*
6559 * Unlikely that it would be retryable then not.
6560 */
6563 }
6566 status);
6567 }
6569 }
6570 /*
6571 * Worked this time set the state back.
6572 */
6575 }
6576 }
6579 /*
6580 * move from waitq to runq
6581 */
6584 }
6587 #ifdef STDEBUG
6589 #endif
6591 /* could not get here if throttle was zero */
6602 }
6612 /*
6613 * If command recovery is enabled and this isn't
6614 * a recovery command try command recovery.
6615 */
6623 }
6630 }
6631 /*
6632 * if too many retries, fail the transport
6633 */
6635 }
6636 }
6648 }
6651 }
6654 }
6656 /*
6657 * if the transport is busy, then put this bp back on the waitq
6658 */
6659 static int
6662 {
6673 /*
6674 * Check to see if we hit the retry timeout and one last check for
6675 * making sure this is the last on the runq, if it is not, we have
6676 * to fail
6677 */
6682 }
6685 /* put the bp back on the waitq */
6687 }
6689 /*
6690 * Decrement un_ncmds so that this
6691 * gets thru' st_start() again.
6692 */
6696 /*
6697 * since this is an error case, we won't have to do this list
6698 * walking much. We've already made sure this bp was the
6699 * last on the runq
6700 */
6703 /*
6704 * send a marker pkt, if appropriate
6705 */
6708 }
6709 /*
6710 * all queues are aligned, we are just waiting to
6711 * transport, don't alloc any more buf p's, when
6712 * st_start is reentered.
6713 */
6718 }
6721 /*
6722 * st_runout a callback that is called what a resource allocatation failed
6723 */
6724 static int
6726 {
6743 /* sbuf commands should only happen with an empty queue. */
6755 }
6761 }
6763 /*
6764 * failed scsi_init_pkt(). If errno is zero its retryable.
6765 */
6775 bp);
6776 }
6781 /*
6782 * Set resid, Error already set, then unblock calling thread.
6783 */
6787 /*
6788 * Try Again
6789 */
6792 }
6794 /*
6795 * Comments courtesy of sd.c
6796 * The scsi_init_pkt routine allows for the callback function to
6797 * return a 0 indicating the callback should be rescheduled or a 1
6798 * indicating not to reschedule. This routine always returns 1
6799 * because the driver always provides a callback function to
6800 * scsi_init_pkt. This results in a callback always being scheduled
6801 * (via the scsi_init_pkt callback implementation) if a resource
6802 * failure occurs.
6803 */
6806 }
6808 /*
6809 * st_done_and_mutex_exit()
6810 * - remove bp from runq
6811 * - start up the next request
6812 * - if this was an asynch bp, clean up
6813 * - exit with released mutex
6814 */
6815 static void
6817 {
6823 #if !defined(lint)
6825 #endif
6837 "st_done_and_mutex_exit(): cmd=0x%x count=%ld resid=%ld flags="
6842 /*
6843 * update kstats with transfer count info
6844 */
6853 }
6854 }
6856 /*
6857 * Start the next one before releasing resources on this one, if
6858 * there is something on the queue and persistent errors has not been
6859 * flagged
6860 */
6865 }
6872 }
6877 /*
6878 * Since we marked this ourselves as ASYNC,
6879 * there isn't anybody around waiting for
6880 * completion any more.
6881 */
6885 }
6892 }
6897 }
6900 /*
6901 * Copy status from scsi_pkt to uscsi_cmd
6902 * since st_uscsi_cmd needs it
6903 */
6905 }
6908 #ifdef STDEBUG
6914 "st_d_a_m_exit(): ncmds = %d, thr = %d, "
6918 }
6920 #endif
6928 }
6932 /*
6933 * now that we biodoned that command, if persistent errors have been
6934 * flagged, flush the waitq
6935 */
6938 }
6941 /*
6942 * Tape error, flush tape driver queue.
6943 */
6944 static void
6946 {
6957 /*
6958 * if we still have commands outstanding, wait for them to come in
6959 * before flushing the queue, and make sure there is a queue
6960 */
6964 /*
6965 * we have no more commands outstanding, so let's deal with special
6966 * cases in the queue for EOM and FM. If we are here, and un_errno
6967 * is 0, then we know there was no error and we return a 0 read or
6968 * write before showing errors
6969 */
6971 /* Flush the wait queue. */
6986 /* it should have one, but check anyway */
6989 }
6992 }
6994 /*
6995 * It's not a bad practice to reset the
6996 * waitq tail pointer to NULL.
6997 */
7000 exit:
7001 /* we mucked with the queue, so let others know about it */
7004 }
7007 /*
7008 * Utility functions
7009 */
7010 static int
7012 {
7026 }
7037 /*
7038 * record size of this device too big.
7039 * try and convert it to variable record length.
7040 *
7041 */
7050 }
7052 /*
7053 * If the drive was set to a non zero block size,
7054 * See if it can be set to a zero block size.
7055 * If it works, ST_VARIABLE so user can set it as they want.
7056 */
7063 }
7069 /*
7070 * default density, cannot determine any other
7071 * information.
7072 */
7081 /*
7082 * 1/2" reel
7083 */
7097 /*
7098 * Quarter inch.
7099 */
7114 /*
7115 * QIC-120, QIC-150, QIC-320, QIC-600
7116 */
7130 /*
7131 * 1/2" cartridge tapes. Include HI-TC.
7132 */
7144 /* DDS-2/DDS-3 scsi spec densities */
7154 /*
7155 * Helical Scan (Exabyte) devices
7156 */
7161 }
7163 /*
7164 * Assume LONG ERASE, BSF and BSR
7165 */
7170 /*
7171 * Only if mode sense data says no buffered write, set NOBUF
7172 */
7176 /*
7177 * set up large read and write retry counts
7178 */
7182 /*
7183 * If this is a 0.50 inch reel tape, and
7184 * it is *not* variable mode, try and
7185 * set it to variable record length
7186 * mode.
7187 */
7194 }
7195 }
7197 /*
7198 * Write to console about type of device found
7199 */
7202 sizestr);
7210 }
7213 }
7215 static int
7217 {
7228 /*
7229 * If we're past BOT, density is determined already.
7230 */
7234 }
7237 /*
7238 * XXX: put in a bitch message about attempting to
7239 * XXX: change density past BOT.
7240 */
7242 }
7245 }
7249 }
7252 /*
7253 * If we're going to be writing, we set the density
7254 */
7256 /* un_curdens is used as an index into densities table */
7260 }
7262 }
7264 /*
7265 * If density is known already,
7266 * we don't have to get it again.(?)
7267 */
7271 }
7272 }
7274 exit:
7277 }
7280 /*
7281 * Try to determine density. We do this by attempting to read the
7282 * first record off the tape, cycling through the available density
7283 * codes as we go.
7284 */
7286 static int
7288 {
7290 uint_t size;
7300 /*
7301 * If Auto Density override is enabled The drive has
7302 * only one density and there is no point in attempting
7303 * find the correct one.
7304 *
7305 * Since most modern drives auto detect the density
7306 * and format of the recorded media before they come
7307 * ready. What this function does is a legacy behavior
7308 * and modern drives not only don't need it, The backup
7309 * utilities that do positioning via uscsi find the un-
7310 * expected rewinds problematic.
7311 *
7312 * The drives that need this are old reel to reel devices.
7313 * I took a swag and said they must be scsi-1 or older.
7314 * I don't beleave there will any of the newer devices
7315 * that need this. There will be some scsi-1 devices that
7316 * don't need this but I don't think they will be using the
7317 * BIG aftermarket backup and restore utilitys.
7318 */
7324 }
7326 /*
7327 * This will only work on variable record length tapes
7328 * if and only if all variable record length tapes autodensity
7329 * select.
7330 */
7334 /*
7335 * Start at the specified density
7336 */
7342 /*
7343 * If we've done this density before,
7344 * don't bother to do it again.
7345 */
7354 }
7356 /*
7357 * XXX - the creates lots of headaches and slowdowns - must
7358 * fix.
7359 */
7363 }
7369 }
7370 }
7374 exit:
7377 }
7379 static int
7381 {
7395 /*
7396 * If auto density override is not set, Use mode select
7397 * to set density and compression.
7398 */
7401 }
7403 /*
7404 * If auto density and mode select compression are set,
7405 * This is a drive with one density code but compression
7406 * can be enabled or disabled.
7407 * Set compression but no need to set density.
7408 */
7414 }
7415 }
7417 /* If sucessful set density and/or compression, mark density known */
7420 }
7424 }
7426 static int
7428 {
7441 }
7443 /*
7444 * 'LOAD' the tape to BOT by rewinding
7445 */
7450 }
7454 }
7457 /*
7458 * Note: QIC devices aren't so smart. If you try to append
7459 * after EOM, the write can fail because the device doesn't know
7460 * it's at EOM. In that case, issue a read. The read should fail
7461 * because there's no data, but the device knows it's at EOM,
7462 * so a subsequent write should succeed. To further confuse matters,
7463 * the target returns the same error if the tape is positioned
7464 * such that a write would overwrite existing data. That's why
7465 * we have to do the append test. A read in the middle of
7466 * recorded data would succeed, thus indicating we're attempting
7467 * something illegal.
7468 */
7471 static void
7473 {
7476 uchar_t status;
7492 /*
7493 * first, map in the buffer, because we're doing a double write --
7494 * first into the kernel, then onto the tape.
7495 */
7498 /*
7499 * get a copy of the data....
7500 */
7504 /*
7505 * attempt the write..
7506 */
7509 success:
7522 }
7524 /*
7525 * The append failed. Do a short read. If that fails, we are at EOM
7526 * so we can retry the write command. If that succeeds, than we're
7527 * all screwed up (the controller reported a real error).
7528 *
7529 * XXX: should the dummy read be > SECSIZE? should it be the device's
7530 * XXX: block size?
7531 *
7532 */
7539 /*
7540 * Okay- the read failed. We should actually have confused
7541 * the controller enough to allow writing. In any case, the
7542 * i/o is on its own from here on out.
7543 */
7550 }
7551 }
7561 /*
7562 * backspace one record to get back to where we were
7563 */
7566 }
7571 /*
7572 * Note: biodone will do a bp_mapout()
7573 */
7582 }
7584 /*
7585 * Special command handler
7586 */
7588 /*
7589 * common st_cmd code. The fourth parameter states
7590 * whether the caller wishes to await the results
7591 * Note the release of the mutex during most of the function
7592 */
7593 static int
7595 {
7598 uint_t last_err_resid;
7609 #ifdef STDEBUG
7612 }
7613 #endif
7617 /* check to see if this command requires the drive to be reserved */
7622 }
7624 /*
7625 * A space command is not recoverable if we don't know were we
7626 * were when it was issued.
7627 */
7630 }
7632 /*
7633 * Forground should not be doing anything while recovery is active.
7634 */
7650 /*
7651 * If was a space command need to update logical block position.
7652 * Only do this if the command was sucessful or it will mask the fact
7653 * that the space command failed by promoting the pmode to logical.
7654 */
7660 /*
7661 * Set running position to invalid so it updates on the
7662 * next command.
7663 */
7666 }
7671 }
7673 static int
7675 {
7680 /*
7681 * Set count to the actual size of the data tranfer.
7682 * For commands with no data transfer, set bp->b_bcount
7683 * to the value to be used when constructing the
7684 * cdb in st_make_cmd().
7685 */
7715 /*
7716 * If the user could have entered a number that will
7717 * not fit in the 12 bit count field of space(8),
7718 * use space(16).
7719 */
7723 }
7803 "Unknown read position type 0x%x in "
7805 }
7814 }
7820 /*
7821 * We're going to do actual I/O.
7822 * Set things up for physio.
7823 */
7838 /*
7839 * Let physio do the rest...
7840 */
7847 /*
7848 * Mimic physio
7849 */
7858 /*
7859 * This is an async command- the caller won't wait
7860 * and doesn't care about errors.
7861 */
7864 }
7866 /*
7867 * BugTraq #4260046
7868 * ----------------
7869 * Restore Solaris 2.5.1 behavior, namely call biowait
7870 * unconditionally. The old comment said...
7871 *
7872 * "if strategy was flagged with persistent errors, we would
7873 * have an error here, and the bp would never be sent, so we
7874 * don't want to wait on a bp that was never sent...or hang"
7875 *
7876 * The new rationale, courtesy of Chitrank...
7877 *
7878 * "we should unconditionally biowait() here because
7879 * st_strategy() will do a biodone() in the persistent error
7880 * case and the following biowait() will return immediately.
7881 * If not, in the case of "errors after pkt alloc" in
7882 * st_start(), we will not biowait here which will cause the
7883 * next biowait() to return immediately which will cause
7884 * us to send out the next command. In the case where both of
7885 * these use the sbuf, when the first command completes we'll
7886 * free the packet attached to sbuf and the same pkt will
7887 * get freed again when we complete the second command.
7888 * see esc 518987. BTW, it is necessary to do biodone() in
7889 * st_start() for the pkt alloc failure case because physio()
7890 * does biowait() and will hang if we don't do biodone()"
7891 */
7896 }
7901 }
7903 static int
7905 {
7908 minor_t minor;
7912 /*
7913 * Drive either dosn't have compression or it is controlled with
7914 * special density codes. Return ENOTTY so caller
7915 * knows nothing was done.
7916 */
7920 }
7922 /* set compression based on minor node opened */
7925 /*
7926 * If this the compression density or
7927 * the drive has two densities and uses mode select for
7928 * control of compression turn on compression for MT_DENSITY2
7929 * as well.
7930 */
7940 }
7946 /*
7947 * Need to determine which page does the device use for compression.
7948 * First try the data compression page. If this fails try the device
7949 * configuration page
7950 */
7956 }
7959 /*
7960 * This device does not support data
7961 * compression page
7962 */
7969 }
7972 }
7973 }
7979 }
7982 /*
7983 * This device does not support
7984 * compression at all advice the
7985 * user and unset ST_MODE_SEL_COMP
7986 */
7996 }
7997 }
7998 }
8001 }
8003 /*
8004 * set or unset compression thru device configuration page.
8005 */
8006 static int
8008 {
8017 /*
8018 * if the mode sense page is not the correct one, load the correct one.
8019 */
8025 }
8027 /*
8028 * Figure what to set compression flag to.
8029 */
8031 /* They have selected a compression node */
8036 }
8039 }
8041 /*
8042 * If compression is already set the way it was requested.
8043 * And if this not the first time we has tried.
8044 */
8048 }
8051 /*
8052 * need to send mode select even if correct compression is
8053 * already set since need to set density code
8054 */
8056 #ifdef STDEBUG
8061 }
8062 #endif
8067 }
8069 /*
8070 * set/reset compression bit thru data compression page
8071 */
8072 static int
8074 {
8083 /*
8084 * if the mode sense page is not the correct one, load the correct one.
8085 */
8091 }
8093 /*
8094 * If drive is not capable of compression (at this time)
8095 * return EALREADY so caller doesn't think that this page
8096 * is not supported. This check is for drives that can
8097 * disable compression from the front panel or configuration.
8098 * I doubt that a drive that supports this page is not really
8099 * capable of compression.
8100 */
8103 }
8105 /* See if compression currently turned on */
8110 }
8112 /*
8113 * If compression is already set the way it was requested.
8114 * And if this not the first time we has tried.
8115 */
8119 }
8121 /*
8122 * if we are already set to the appropriate compression
8123 * mode, don't set it again
8124 */
8126 /* compression selected */
8130 }
8133 #ifdef STDEBUG
8138 }
8139 #endif
8144 }
8146 static int
8148 {
8150 uchar_t page;
8171 }
8178 }
8183 }
8184 /* FALLTHROUGH */
8188 }
8190 }
8192 static int
8194 {
8206 /*
8207 * The parameter list should be the same for all of the
8208 * cases that follow so set them here
8209 *
8210 * Try mode select first if if fails set fields manually
8211 */
8220 }
8226 /*
8227 * If configured to use a specific density code for a media type.
8228 * curdens is previously set by the minor node opened.
8229 * If the media type doesn't match the minor node we change it so it
8230 * looks like the correct one was opened.
8231 */
8233 uchar_t best;
8239 /*
8240 * It matches but it might not be the only one.
8241 * Use the highest matching media type but not
8242 * to exceed the density selected by the open.
8243 */
8246 }
8249 }
8250 }
8251 /* If a match was found best will not be 0xff any more */
8259 /* Otherwise set density based on minor node opened */
8262 }
8265 }
8271 }
8275 /*
8276 * If st_set_compression returned invalid or already it
8277 * found no need to do the mode select.
8278 * So do it here.
8279 */
8282 /* Zero non-writeable fields */
8287 /* need to set the density code */
8297 }
8298 }
8299 }
8301 /*
8302 * The spec recommends to send a mode sense after a mode select
8303 */
8309 }
8311 /*
8312 * st_gen_mode_sense
8313 *
8314 * generic mode sense.. it allows for any page
8315 */
8316 static int
8319 {
8347 }
8349 /*
8350 * st_gen_mode_select
8351 *
8352 * generic mode select.. it allows for any page
8353 */
8354 static int
8357 {
8366 /* Zero non-writeable fields */
8371 /*
8372 * If mode select has any page data, zero the ps (Page Savable) bit.
8373 */
8376 }
8381 /*
8382 * then, do a mode select to set what ever info
8383 */
8402 }
8404 static int
8406 {
8431 }
8435 }
8437 static int
8440 {
8467 }
8471 }
8473 static int
8476 {
8499 }
8518 }
8522 }
8524 /*
8525 * Changes devices blocksize and bsize to requested blocksize nblksz.
8526 * Returns returned value from first failed call or zero on success.
8527 */
8528 static int
8530 {
8539 /*
8540 * If we haven't got the compression page yet, do that first.
8541 */
8544 }
8546 /* Read current settings */
8552 }
8554 /* Figure the current block size */
8555 oldblksz =
8560 /* If current block size is the same as requested were done */
8565 }
8567 /* Change to requested block size */
8572 /* Attempt to change block size */
8578 }
8580 /* Read back and verify setting */
8590 "Blocksize set does not equal requested blocksize"
8593 }
8594 }
8595 finish:
8598 }
8601 static void
8603 {
8622 }
8623 }
8624 }
8627 static void
8629 {
8640 uchar_t com;
8655 /*
8656 * fixbit is for setting the Fixed Mode and Suppress Incorrect
8657 * Length Indicator bits on read/write commands, for setting
8658 * the Long bit on erase commands, and for setting the Code
8659 * Field bits on space commands.
8660 */
8662 /* regular raw I/O */
8671 }
8673 #ifdef STDEBUG
8676 #endif
8685 }
8692 }
8696 }
8699 /*
8700 * For really large xfers, increase timeout
8701 */
8710 /*
8711 * uscsi - build command, allocate scsi resources
8712 */
8730 }
8744 }
8756 /*
8757 * If ST_SHORT_FILEMARKS bit is ON for EXABYTE
8758 * device, set the Vendor Unique bit to
8759 * write Short File Mark.
8760 */
8764 /*
8765 * Now the Vendor Unique bit 7 in Byte 5 of CDB
8766 * is set to to write Short File Mark
8767 */
8769 }
8773 /*
8774 * In the case of rewind we're gona do the rewind with
8775 * the immediate bit set so status will be retured when
8776 * the command is accepted by the device. We clear the
8777 * B_ASYNC flag so we wait for that acceptance.
8778 */
8785 }
8786 }
8831 /* Loading or Unloading */
8836 }
8837 /* Is Retension requested */
8840 }
8849 /*
8850 * do long erase
8851 */
8854 /* Drive might not honor immidiate bit */
8857 /* Short Erase */
8860 }
8944 "Unknown read position type 0x%x in "
8946 }
8952 com);
8953 }
8961 }
8964 #ifdef STDEBUG
8967 #endif
8972 }
8974 }
8980 /*
8981 * Initialize the SILI/Fixed bits of the byte 1 of cdb.
8982 */
8993 }
8997 /*
8998 * If we just write data to tape and did a command that doesn't
8999 * change position, we still need to write a filemark.
9000 */
9009 }
9012 }
9013 }
9015 exit:
9017 }
9020 /*
9021 * Build a command based on a uscsi command;
9022 */
9023 static void
9026 {
9029 caddr_t cdb;
9048 }
9049 }
9050 }
9067 }
9070 #ifdef STDEBUG
9073 #endif
9079 #ifdef STDEBUG
9083 }
9084 #endif
9088 }
9097 }
9100 exit:
9102 }
9105 /*
9106 * restart cmd currently at the head of the runq
9107 *
9108 * If scsi_transport() succeeds or the retries
9109 * count exhausted, restore the throttle that was
9110 * zeroed out in st_handle_intr_busy().
9111 *
9112 */
9113 static void
9115 {
9142 }
9144 /*
9145 * Here we know :
9146 * throttle = 0, via st_handle_intr_busy
9147 */
9150 /*
9151 * move from waitq to runq, if there is anything on the waitq
9152 */
9156 /*
9157 * not good, we don't want to requeue something after
9158 * another.
9159 */
9164 }
9165 }
9190 }
9191 }
9197 }
9199 done_error:
9206 }
9209 }
9219 }
9221 }
9222 }
9224 /*
9225 * st_check_media():
9226 * Periodically check the media state using scsi_watch service;
9227 * this service calls back after TUR and possibly request sense
9228 * the callback handler (st_media_watch_cb()) decodes the request sense
9229 * data (if any)
9230 */
9232 static int
9234 {
9251 /*
9252 * is there anything to do?
9253 */
9254 retry:
9256 /*
9257 * submit the request to the scsi_watch service;
9258 * scsi_media_watch_cb() does the real work
9259 */
9267 }
9273 /*
9274 * now wait for media change
9275 * we will not be signalled unless mediastate == state but it
9276 * still better to test for this condition, since there
9277 * is a 5 sec cv_broadcast delay when
9278 * mediastate == MTIO_INSERTED
9279 */
9286 "st_check_media:waiting for media state "
9290 }
9294 }
9295 }
9297 /*
9298 * if we transitioned to MTIO_INSERTED, media has really been
9299 * inserted. If TUR fails, it is probably a exabyte slow spin up.
9300 * Reset and retry the state change. If everything is ok, replay
9301 * the open() logic.
9302 */
9308 /*
9309 * set this early so that TUR will make it through strategy
9310 * without triggering a st_tape_init(). We needed it set
9311 * before calling st_tape_init() ourselves anyway. If TUR
9312 * fails, set it back
9313 */
9316 /*
9317 * If not reserved fail as getting reservation conflict
9318 * will make this hang forever.
9319 */
9325 }
9332 }
9339 }
9343 /* this also rewinds the tape */
9352 }
9355 /*
9356 * supported devices must be rewound before ejection
9357 * rewind resets fileno & blkno
9358 */
9361 }
9363 done:
9366 SCSI_WATCH_TERMINATE_WAIT);
9370 }
9375 }
9377 /*
9378 * st_media_watch_cb() is called by scsi_watch_thread for
9379 * verifying the request sense data (if any)
9380 */
9381 static int
9383 {
9395 }
9402 actual_sense_length);
9405 /*
9406 * if there was a check condition then sensep points to valid
9407 * sense data
9408 * if status was not a check condition but a reservation or busy
9409 * status then the new state is MTIO_NONE
9410 */
9419 "st_media_watch_cb: unknown drive type %d, "
9421 /* FALLTHROUGH */
9432 }
9435 /* not ready to ready transition */
9436 /* hp/es_qual_code == 80 on>off>on */
9437 /* hp/es_qual_code == 0 on>off>unld>ld>on */
9440 }
9443 /* in process, rewinding or loading */
9447 }
9449 }
9457 /* operator medium removal request */
9461 /* not ready to ready transition */
9465 }
9468 /* medium not present */
9471 }
9473 }
9482 /* volume not mounted? */
9486 }
9491 }
9499 }
9503 /* in transition but could be either */
9508 }
9510 }
9512 }
9515 }
9521 /*
9522 * now signal the waiting thread if this is *not* the specified state;
9523 * delay the signal if the state is MTIO_INSERTED
9524 * to allow the target to recover
9525 */
9529 /*
9530 * delay the signal to give the drive a chance
9531 * to do what it apparently needs to do
9532 */
9541 }
9542 }
9545 }
9547 /*
9548 * delayed cv_broadcast to allow for target to recover
9549 * from media insertion
9550 */
9551 static void
9553 {
9564 }
9566 /*
9567 * restart cmd currently at the start of the waitq
9568 */
9569 static void
9571 {
9585 }
9588 /*
9589 * Command completion processing
9590 *
9591 */
9592 static void
9594 {
9621 /* If device has gone away not much else to do */
9634 }
9635 /*
9636 * At this point we know that the command was successfully
9637 * completed. Now what?
9638 */
9640 /*
9641 * okay. We were running a REQUEST SENSE. Find
9642 * out what to do next.
9643 */
9648 /*
9649 * Make rqs isn't going to be retied.
9650 */
9652 /*
9653 * set pkt back to original packet in case we will have
9654 * to requeue it
9655 */
9658 /*
9659 * some actions are based on un_state, hence
9660 * restore the state st was in before ST_STATE_SENSING.
9661 */
9663 }
9666 /*
9667 * the transport layer successfully completed an autorqsense
9668 */
9674 /*
9675 * Okay, we weren't running a REQUEST SENSE. Call a routine
9676 * to see if the status bits we're okay. If a request sense
9677 * is to be run, that will happen.
9678 */
9680 }
9685 /*
9686 * return cmd to head to the queue
9687 * since we are suspending so that
9688 * it gets restarted during resume
9689 */
9702 }
9703 }
9705 /*
9706 * check for undetected path failover.
9707 */
9714 /*
9715 * Also copies path instance to the uscsi structure.
9716 */
9719 /*
9720 * scsi_uscsi_pktfini() zeros pkt_path_instance.
9721 */
9725 }
9727 /*
9728 * If the scsi_pkt was not allocated correctly the
9729 * pkt_path_instance is not even there.
9730 */
9733 /*
9734 * Don't recover the path change if it was done
9735 * intentionally or if the device has not completely
9736 * opened yet.
9737 */
9745 }
9746 }
9748 }
9749 }
9751 /*
9752 * Restore old state if we were sensing.
9753 */
9756 }
9762 again:
9765 /* this is to report a reservation conflict */
9771 /*FALLTHROUGH*/
9775 /*
9776 * all errors set state of the tape to 'unknown'
9777 * unless we're at EOT or are doing append testing.
9778 * If sense key was illegal request, preserve state.
9779 */
9782 }
9783 }
9786 /*
9787 * since we have an error (COMMAND_DONE_ERROR), we want to
9788 * make sure an error ocurrs, so make sure at least EIO is
9789 * returned
9790 */
9798 }
9807 }
9812 }
9813 /*FALLTHROUGH*/
9825 }
9827 /*
9828 * zero the sense data.
9829 */
9832 /*
9833 * If this is not a retry on QUE_SENSE point to the original
9834 * bp of the command that got us here.
9835 */
9838 }
9843 }
9848 /*
9849 * never retry this, some other command will have nuked the
9850 * sense, anyway
9851 */
9856 }
9861 }
9864 sense_error:
9871 /* longish timeout */
9876 /* short timeout */
9878 que_it_up:
9879 /*
9880 * let st_handle_intr_busy put this bp back on waitq and make
9881 * checks to see if it is ok to requeue the command.
9882 */
9885 /*
9886 * Save the throttle before setting up the timeout
9887 */
9890 }
9908 }
9913 last_command_error:
9933 /* FALLTHRU */
9938 }
9942 }
9944 static errstate
9946 {
9963 /* prevent infinite number of retries */
9966 "Recovery stopped for incomplete %s command, "
9970 }
9974 /*
9975 * this occurs when accessing a powered down drive, no
9976 * need to complain; just fail the open
9977 */
9980 /*
9981 * if we have commands outstanding in HBA, and a command
9982 * comes back incomplete, we're hosed, so reset target
9983 * If we have the bus, but cmd_incomplete, we probably just
9984 * have a failed selection, so don't reset the target, just
9985 * requeue the command and try again
9986 */
9989 }
9991 /*
9992 * Retry selection a couple more times if we're
9993 * open. If opening, we only try just once to
9994 * reduce probe time for nonexistant devices.
9995 */
9998 /* XXX check retriable? */
10000 }
10005 /*
10006 * most likely this is caused by flush-on-error support. If
10007 * it was not there, the we're in trouble.
10008 */
10012 }
10018 else
10030 ST_RESERVE) {
10034 }
10037 }
10041 }
10042 /*FALLTHROUGH*/
10047 reset_target:
10057 /*
10058 * If we haven't reserved the drive don't reset it.
10059 */
10063 }
10065 /*
10066 * if we aren't lost yet we will be soon.
10067 */
10073 /* no hope left to recover */
10077 }
10078 }
10079 }
10087 /*
10088 * These commands can be rerun
10089 * with impunity
10090 */
10092 }
10098 }
10099 }
10100 }
10107 }
10109 }
10111 /*
10112 * if the device is busy, then put this bp back on the waitq, on the
10113 * interrupt thread, where we want the head of the queue and not the
10114 * end
10115 *
10116 * The callers of this routine should take measures to save the
10117 * un_throttle in un_last_throttle which will be restored in
10118 * st_intr_restart(). The only exception should be st_intr_restart()
10119 * calling this routine for which the saving is already done.
10120 */
10121 static int
10124 {
10141 }
10143 /*
10144 * Check to see if we hit the retry timeout. We check to make sure
10145 * this is the first one on the runq and make sure we have not
10146 * queued up any more, so this one has to be the last on the list
10147 * also. If it is not, we have to fail. If it is not the first, but
10148 * is the last we are in trouble anyway, as we are in the interrupt
10149 * context here.
10150 */
10155 }
10157 /* put the bp back on the waitq */
10161 }
10163 /*
10164 * We don't want any other commands being started in the mean time.
10165 * If start had just released mutex after putting something on the
10166 * runq, we won't even get here.
10167 */
10170 /*
10171 * send a marker pkt, if appropriate
10172 */
10175 /*
10176 * all queues are aligned, we are just waiting to
10177 * transport
10178 */
10181 exit:
10184 }
10186 /*
10187 * To get one error entry from error stack
10188 */
10189 static int
10191 {
10192 #ifdef _MULTI_DATAMODEL
10193 /*
10194 * For use when a 32 bit app makes a call into a
10195 * 64 bit ioctl
10196 */
10212 /*
10213 * if error record stack empty, return ENXIO
10214 */
10220 }
10222 /*
10223 * get the top entry from stack
10224 */
10226 arq_status_len_kr =
10229 #ifdef _MULTI_DATAMODEL
10236 }
10238 arq_status_len_in =
10255 }
10264 }
10271 }
10279 }
10287 arq_status_len_kr;
10296 }
10305 }
10312 }
10314 }
10320 }
10328 arq_status_len_kr;
10337 }
10346 }
10353 }
10356 /*
10357 * update stack
10358 */
10366 SECMDS_STATUS_SIZE);
10371 ret:
10373 }
10375 /*
10376 * MTIOCGETERROR ioctl needs to retrieve the current sense data along with
10377 * the scsi CDB command which causes the error and generates sense data and
10378 * the scsi status.
10379 *
10380 * error-record stack
10381 *
10382 *
10383 * TOP BOTTOM
10384 * ------------------------------------------
10385 * | 0 | 1 | 2 | ... | n |
10386 * ------------------------------------------
10387 * ^
10388 * |
10389 * pointer to error entry
10390 *
10391 * when st driver generates one sense data record, it creates a error-entry
10392 * and pushes it onto the stack.
10393 *
10394 */
10396 static void
10400 {
10418 }
10431 /*
10432 * copy cdb command & length to current error entry
10433 */
10437 /*
10438 * copy scsi status length to current error entry
10439 */
10441 SECMDS_STATUS_SIZE;
10443 /*
10444 * copy sense data and scsi status to current error entry
10445 */
10447 SECMDS_STATUS_SIZE);
10452 }
10454 /*
10455 * Empty all the error entry in stack
10456 */
10457 static void
10459 {
10484 }
10485 }
10487 static errstate
10489 {
10514 }
10520 }
10522 /*
10523 * Make sure there is sense data to look at.
10524 */
10529 }
10531 /* was there enough data? */
10538 }
10550 /*
10551 * copy one arqstat entry in the sense data buffer
10552 */
10555 }
10557 static errstate
10559 {
10576 /*
10577 * we return QUE_SENSE so st_intr will setup the SENSE cmd.
10578 * the disadvantage is that we do not have any delay for the
10579 * second retry of rqsense and we have to keep a packet around
10580 */
10592 }
10593 }
10600 }
10603 /* was there enough data? */
10611 }
10612 }
10618 }
10624 }
10626 /*
10627 * copy one arqstat entry in the sense data buffer
10628 */
10632 }
10634 static errstate
10637 {
10653 /*
10654 * For uscsi commands, squirrel away a copy of the
10655 * results of the Request Sense.
10656 */
10667 }
10668 }
10674 }
10676 /*
10677 * If the drive is an MT-02, reposition the
10678 * secondary error code into the proper place.
10679 *
10680 * XXX MT-02 is non-CCS tape, so secondary error code
10681 * is in byte 8. However, in SCSI-2, tape has CCS definition
10682 * so it's in byte 12.
10683 */
10686 }
10694 /* for normal I/O check extract the resid values. */
10697 resid =
10702 /* If fixed block */
10705 }
10710 }
10712 "st_decode_sense (rw): xferred bit = %d, resid=%ld (%d), "
10714 resid,
10720 /*
10721 * The problem is, what should we believe?
10722 */
10725 }
10727 /*
10728 * If the command is SCMD_SPACE, we need to get the
10729 * residual as returned in the sense data, to adjust
10730 * our idea of current tape position correctly
10731 */
10738 resid =
10747 /*
10748 * If the special command is SCMD_READ,
10749 * the correct resid will be set later.
10750 */
10755 }
10758 resid);
10759 }
10760 }
10771 }
10777 /*
10778 * Erase, locate or rewind operation in progress, retry
10779 * ASC ASCQ
10780 * 00 18 Erase operation in progress
10781 * 00 19 Locate operation in progress
10782 * 00 1A Rewind operation in progress
10783 */
10790 }
10799 ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) {
10804 sensep);
10814 sensep);
10815 }
10817 }
10818 common:
10819 /*
10820 * XXX only want reads to be stopped by filemarks.
10821 * Don't want them to be stopped by EOT. EOT matters
10822 * only on write.
10823 */
10829 /*
10830 * Fun with variable length record devices:
10831 * for specifying larger blocks sizes than the
10832 * actual physical record size.
10833 */
10835 /*
10836 * XXX! Ugly.
10837 * The requested blocksize is > tape blocksize,
10838 * so this is ok, so we just return the
10839 * actual size xferred.
10840 */
10844 /*
10845 * The requested blocksize is < tape blocksize,
10846 * so this is not ok, so we err with ENOMEM
10847 */
10856 }
10858 /*
10859 * we hope and pray for this just being
10860 * something we can ignore (ie. a
10861 * truly recoverable soft error)
10862 */
10864 }
10871 }
10873 /*
10874 * ignore eom when reading, a fmk should terminate reading
10875 */
10894 }
10896 }
10907 }
10915 check_keys:
10916 /*
10917 * attempt to process the keys in the presence of
10918 * other errors
10919 */
10921 /*
10922 * Fun with variable length record devices:
10923 * for specifying larger blocks sizes than the
10924 * actual physical record size.
10925 */
10927 /*
10928 * XXX! Ugly
10929 */
10937 }
10938 }
10945 }
10947 /*
10948 * ignore eom when reading, a fmk should terminate reading
10949 */
10956 }
10979 /*
10980 * if not a special request and some data was xferred then it
10981 * it is not an error yet
10982 */
10984 /*
10985 * no error for read with or without data xferred
10986 */
10998 }
11004 }
11009 /*
11010 * we were doing a fast forward by skipping
11011 * multiple fmk at the time
11012 */
11016 }
11024 "wrong tape for writing- use DC6150 tape "
11029 }
11040 /*
11041 * If we have detected a Bus Reset and the tape
11042 * drive has been reserved.
11043 */
11048 ST_RESERVE) {
11052 }
11053 }
11055 /*
11056 * If this is a recovery command and retrable, retry.
11057 */
11065 }
11067 }
11069 /*
11070 * If ST_APPLICATION_RESERVATIONS is set,
11071 * If the asc/ascq indicates that the reservation
11072 * has been cleared just allow the write to continue
11073 * which would force a scsi 2 reserve.
11074 * If preempted that persistent reservation
11075 * the scsi 2 reserve would get a reservation conflict.
11076 */
11079 /*
11080 * RESERVATIONS PREEMPTED
11081 * With MPxIO this could be a fail over? XXX
11082 */
11089 /*
11090 * RESERVATIONS RELEASED
11091 */
11097 }
11098 }
11101 /*
11102 * Look, the tape isn't open yet, now determine
11103 * if the cause is a BUS RESET, Save the file
11104 * and Block positions for the callers to
11105 * recover from the loss of position.
11106 */
11114 }
11123 }
11124 /*
11125 * Means it thinks the mode parameters have changed.
11126 * This is the result of a reset clearing settings or
11127 * another initiator changing what we set.
11128 */
11129 }
11132 /* Error recovery will modeselect and retry. */
11136 }
11146 }
11150 /*
11151 * Not Ready to Ready change, Media may have changed.
11152 */
11159 /*
11160 * Returning DEVICE_RESET will call
11161 * error recovery.
11162 */
11165 }
11166 /*
11167 * Check if it is an Unexpected Unit Attention.
11168 * If state is >= ST_STATE_OPEN, we have
11169 * already done the initialization .
11170 * In this case it is Fatal Error
11171 * since no further reading/writing
11172 * can be done with fileno set to < 0.
11173 */
11179 }
11180 }
11187 /*
11188 * If in process of getting ready retry.
11189 */
11193 /*
11194 * We get here when the tape is rewinding.
11195 * QUE_BUSY_COMMAND retries every 10 seconds.
11196 */
11202 /* give up */
11205 }
11212 }
11213 /* FALLTHROUGH */
11215 /* give up */
11218 }
11220 /* give up */
11223 }
11225 /*
11226 * If this was an error and after device opened
11227 * do error stats.
11228 */
11232 }
11240 }
11247 /* XXX Do drives return this when they see a lost light? */
11248 /* Testing would say yes */
11254 }
11255 /*
11256 * Probably a parity error...
11257 * if we retry here then this may cause data to be
11258 * written twice or data skipped during reading
11259 */
11266 /*
11267 * Undecoded sense key. Try retries and hope
11268 * that will fix the problem. Otherwise, we're
11269 * dead.
11270 */
11278 }
11291 }
11295 }
11299 }
11300 }
11311 }
11312 }
11315 }
11318 static int
11320 {
11331 /*
11332 * Check to see if we hit the retry timeout. We check to make sure
11333 * this is the first one on the runq and make sure we have not
11334 * queued up any more, so this one has to be the last on the list
11335 * also. If it is not, we have to fail. If it is not the first, but
11336 * is the last we are in trouble anyway, as we are in the interrupt
11337 * context here.
11338 */
11342 }
11347 }
11349 /*
11350 * Here we know : bp is the first and last one on the runq
11351 * it is not necessary to put it back on the head of the
11352 * waitq and then move from waitq to runq. Save this queuing
11353 * and call scsi_transport.
11354 */
11362 }
11368 }
11376 }
11377 }
11384 }
11385 exit:
11388 }
11390 static int
11392 {
11400 /*
11401 * Hack to handle 600A, 600XTD, 6150 && 660 vs. 300XL tapes...
11402 */
11407 /*
11408 * If this really worked, we could go off of
11409 * the density codes set in the modesense
11410 * page. For this drive, 0x10 == QIC-120,
11411 * 0xf == QIC-150, and 0x5 should be for
11412 * both QIC-24 and, maybe, QIC-11. However,
11413 * the h/w doesn't do what the manual says
11414 * that it should, so we'll key off of
11415 * getting a WRITE PROTECT error AND wp *not*
11416 * set in the mode sense information.
11417 */
11418 /*
11419 * XXX but we already know that status is
11420 * write protect, so don't check it again.
11421 */
11426 }
11430 }
11431 }
11433 }
11435 static errstate
11437 {
11438 errstate action;
11451 /*
11452 * Command recovery is enabled, not just opening,
11453 * we had the drive reserved and we thing its ours.
11454 * Call recovery to attempt to take it back.
11455 */
11466 }
11474 /*
11475 * Status returned by scsi_vhci indicating path
11476 * has failed over.
11477 */
11480 }
11481 /* FALLTHRU */
11484 /*
11485 * If recovery is inabled use it instead of
11486 * blind reties.
11487 */
11493 /*
11494 * If this is a command done before reserve is done
11495 * don't reset.
11496 */
11503 }
11508 /*
11509 * we should only get here if the auto rqsense failed
11510 * thru a uscsi cmd without autorequest sense
11511 * so we just try again
11512 */
11518 STATE_GOT_STATUS)) {
11528 }
11532 /*
11533 * This is an aborted task. This can be a reset on the other
11534 * port of a multiport drive. Lets try and recover it.
11535 */
11543 }
11545 }
11547 static void
11549 {
11567 }
11571 /* Command reads or writes data */
11582 }
11584 /*
11585 * If variable block mode.
11586 * Fixed bit in CBD should be zero.
11587 */
11593 /*
11594 * If fixed block mode.
11595 * Fixed bit in CBD should be one.
11596 */
11601 }
11602 /*
11603 * So its possable to read some blocks and hit a filemark.
11604 * Example reading in fixed block mode where more then one
11605 * block at a time is requested. In this case because the
11606 * filemark is hit something less then the requesed number
11607 * of blocks is read.
11608 */
11611 }
11615 }
11617 /*
11618 * If some command failed after this one started and it seems
11619 * to have finshed without error count the position.
11620 */
11623 }
11635 }
11637 /* recovery disabled */
11641 }
11643 /*
11644 * If we didn't just read a filemark.
11645 */
11648 /*
11649 * If Previously calulated expected position does not match
11650 * debug the expected position.
11651 */
11655 #ifdef STDEBUG
11660 #endif
11662 }
11666 /*
11667 * blkno and lgclblkno already counted in
11668 * st_add_recovery_info_to_pkt(). Since a block was not
11669 * read and a filemark was.
11670 */
11677 }
11678 }
11679 }
11680 }
11682 static void
11684 {
11698 #ifdef STDEBUG
11703 }
11704 #endif
11708 }
11718 }
11719 }
11720 /*
11721 * all is honky dory at this point, so let's
11722 * readjust the throttle, to increase speed, if we
11723 * have not throttled down.
11724 */
11727 }
11739 }
11745 }
11754 }
11760 {
11765 }
11776 }
11781 }
11783 }
11797 {
11807 attrib =
11809 }
11818 }
11823 }
11840 /* Space file forward */
11844 }
11848 }
11849 /* Space file backward */
11857 }
11860 /* Space block forward */
11864 }
11865 /* Space block backward */
11867 /*
11868 * we stepped back into
11869 * a previous file; we are not
11870 * making an effort to pretend that
11871 * we are still in the current file
11872 * ie. logical == physical position
11873 * and leave it to st_ioctl to correct
11874 */
11881 }
11884 }
11903 }
11910 }
11920 }
11921 /*
11922 * If we are loading or unloading we expect the media id
11923 * to change. Lets make it unknown.
11924 */
11929 }
11972 ST_INITIATED_RESET);
11974 "PGR Reserve and set: entering"
11984 /* FALLTHROUGH */
11989 ST_INITIATED_RESET);
11992 "PGR Release and reset: exiting"
11995 }
12020 /*
12021 * Only if the buf used was un_sbufp.
12022 * Among other things the prevents read positions used
12023 * as part of error recovery from messing up our
12024 * current position as they will use un_recov_buf.
12025 */
12028 }
12032 /* Locate makes position mode no longer legacy */
12041 }
12044 }
12045 /* FALLTHROUGH */
12047 /*
12048 * Unknown command, If was USCSI and USCSI_SILENT
12049 * flag was not set, set position to unknown.
12050 */
12055 cmd);
12057 /*
12058 * keep the old agreement to allow unknown
12059 * commands with the USCSI_SILENT set.
12060 * This prevents ASSERT below.
12061 */
12064 }
12065 /* FALLTHROUGH */
12070 }
12072 /* new_lastop should have been changed */
12075 /* If un_lastop should copy new_lastop */
12080 }
12081 }
12083 /*
12084 * In the st driver we have a logical and physical file position.
12085 * Under BSD behavior, when you get a zero read, the logical position
12086 * is before the filemark but after the last record of the file.
12087 * The physical position is after the filemark. MTIOCGET should always
12088 * return the logical file position.
12089 *
12090 * The next read gives a silent skip to the next file.
12091 * Under SVR4, the logical file position remains before the filemark
12092 * until the file is closed or a space operation is performed.
12093 * Hence set err_resid and err_file before changing fileno if case
12094 * BSD Behaviour.
12095 */
12100 /*
12101 * If we've seen a filemark via the last read operation
12102 * advance the file counter, but mark things such that
12103 * the next read operation gets a zero count. We have
12104 * to put this here to handle the case of sitting right
12105 * at the end of a tape file having seen the file mark,
12106 * but the tape is closed and then re-opened without
12107 * any further i/o. That is, the position information
12108 * must be updated before a close.
12109 */
12112 /*
12113 * If we're a 1/2" tape, and we get a filemark
12114 * right on block 0, *AND* we were not in the
12115 * first file on the tape, and we've hit logical EOM.
12116 * We'll mark the state so that later we do the
12117 * right thing (in st_close(), st_strategy() or
12118 * st_ioctl()).
12119 *
12120 */
12130 /*
12131 * Uscsi reads have no concept of Berkley ver System IV.
12132 * Counts here must match raw device.
12133 * A non-full resid implies fix block mode where an
12134 * attempt to read X blocks resulted in less then X.
12135 */
12139 /* Read over a file mark */
12141 /* logical block is counted up elsewhere */
12142 /* we're before the first block in next file */
12144 /* EOF is no longer pending */
12146 }
12148 /*
12149 * If the read of the filemark was a side effect
12150 * of reading some blocks (i.e., data was actually
12151 * read), then the EOF mark is pending and the
12152 * bump into the next file awaits the next read
12153 * operation (which will return a zero count), or
12154 * a close or a space operation, else the bump
12155 * into the next file occurs now.
12156 */
12170 }
12175 /*
12176 * If the read of the filemark was a side effect
12177 * of reading some blocks (i.e., data was actually
12178 * read), then the next read should return 0
12179 */
12185 }
12189 }
12190 }
12191 }
12193 /*
12194 * set the correct un_errno, to take corner cases into consideration
12195 */
12196 static void
12198 {
12203 /* if errno is already set, don't reset it */
12207 /* here un_errno == 0 */
12208 /*
12209 * if the last transfer before flushing all the
12210 * waiting I/O's, was 0 (resid = count), then we
12211 * want to give the user an error on all the rest,
12212 * so here. If there was a transfer, we set the
12213 * resid and counts to 0, and let it drop through,
12214 * giving a zero return. the next I/O will then
12215 * give an error.
12216 */
12226 }
12228 /*
12229 * we know they did not have a zero, so make
12230 * sure they get one
12231 */
12233 }
12234 }
12237 /*
12238 * send in a marker pkt to terminate flushing of commands by BBA (via
12239 * flush-on-errors) property. The HBA will always return TRAN_ACCEPT
12240 */
12241 static void
12243 {
12251 #ifdef FLUSH_ON_ERRORS
12257 /* we slept, so it must be there */
12259 }
12262 #endif
12263 }
12267 {
12272 /* tmp goes out of scope on return and caller sees garbage */
12275 }
12277 }
12279 static void
12282 {
12292 /* force one line output so repeated commands are printed once */
12297 }
12299 /* force one line output so repeated CDB's are printed once */
12306 }
12307 }
12309 static void
12312 {
12317 uchar_t byte;
12326 }
12334 else
12337 }
12342 }
12343 }
12345 /*
12346 * Conditionally enabled debugging
12347 */
12348 #ifdef STDEBUG
12349 static void
12351 {
12361 }
12364 /*
12365 * Returns pointer to name of minor node name of device 'dev'.
12366 */
12369 {
12373 minor_t minor;
12382 }
12388 }
12392 }
12394 /* NULL terminator */
12398 }
12400 /*
12401 * Soft error reporting, so far unique to each drive
12402 *
12403 * Currently supported: exabyte and DAT soft error reporting
12404 */
12405 static int
12407 {
12432 /*
12433 * set CLRCNT (byte 5, bit 7 which clears the error counts)
12434 */
12447 }
12449 /*
12450 * was there enough data?
12451 */
12456 uint_t rate;
12461 }
12464 }
12465 /*
12466 * check if soft error reporting needs to be done.
12467 */
12472 #ifdef STDEBUG
12490 }
12498 }
12499 }
12500 #endif
12506 }
12510 error_rate,
12514 }
12515 }
12517 done:
12524 }
12526 }
12528 /*
12529 * this is very specific to Archive 4mm dat
12530 */
12531 #define ONE_GIG (ONE_K * ONE_K * ONE_K)
12533 static int
12535 {
12577 }
12580 }
12582 /*
12583 * was there enough data?
12584 */
12595 #ifdef STDEBUG
12601 }
12603 }
12605 }
12606 #endif
12608 /*
12609 * parse the param_codes
12610 */
12622 }
12627 }
12630 }
12631 }
12632 }
12634 /*
12635 * if the log sense returned valid numbers then determine
12636 * the read and write error thresholds based on the amount of
12637 * data transferred
12638 */
12649 WRITE_SOFT_ERROR_WARNING_THRESHOLD) {
12650 normal_retries =
12651 DAT_SMALL_WRITE_ERROR_THRESHOLD;
12653 normal_retries =
12654 DAT_LARGE_WRITE_ERROR_THRESHOLD;
12655 }
12658 READ_SOFT_ERROR_WARNING_THRESHOLD) {
12659 normal_retries =
12660 DAT_SMALL_READ_ERROR_THRESHOLD;
12662 normal_retries =
12663 DAT_LARGE_READ_ERROR_THRESHOLD;
12664 }
12665 }
12672 "Soft error rate (retries = %d) during "
12676 "Periodic head cleaning required "
12678 }
12683 }
12684 }
12686 /*
12687 * reset all values
12688 */
12707 }
12708 done:
12712 }
12714 static int
12716 {
12730 /*NOTREACHED*/
12733 /*NOTREACHED*/
12737 }
12738 }
12740 /*
12741 * persistent error routines
12742 */
12744 /*
12745 * enable persistent errors, and set the throttle appropriately, checking
12746 * for flush-on-errors capability
12747 */
12748 static void
12750 {
12758 /*
12759 * only use flush-on-errors if auto-request-sense and untagged-qing are
12760 * enabled. This will simplify the error handling for request senses
12761 */
12764 uchar_t f_o_e;
12774 }
12778 else
12784 /* this will send a marker pkt */
12786 }
12788 /*
12789 * This turns persistent errors permanently off
12790 */
12791 static void
12793 {
12798 /* turn it off for good */
12801 /* this will send a marker pkt */
12804 /* turn off flush on error capability, if enabled */
12809 }
12813 }
12815 /*
12816 * This clear persistent errors, allowing more commands through, and also
12817 * sending a marker packet.
12818 */
12819 static void
12821 {
12830 }
12832 /*
12833 * This will flag persistent errors, shutting everything down, if the
12834 * application had enabled persistent errors via MTIOCPERSISTENT
12835 */
12836 static void
12838 {
12847 }
12848 }
12850 static int
12852 {
12858 /*
12859 * Issue a Throw-Away reserve command to clear the
12860 * check condition.
12861 * If the current behaviour of reserve/release is to
12862 * hold reservation across opens , and if a Bus reset
12863 * has been issued between opens then this command
12864 * would set the ST_LOST_RESERVE flags in rsvd_status.
12865 * In this case return an EACCES so that user knows that
12866 * reservation has been lost in between opens.
12867 * If this error is not returned and we continue with
12868 * successful open , then user may think position of the
12869 * tape is still the same but inreality we would rewind the
12870 * tape and continue from BOT.
12871 */
12875 ST_LOST_RESERVE_BETWEEN_OPENS) {
12879 }
12881 }
12884 }
12887 }
12890 }
12892 static int
12894 {
12900 /*
12901 * If already reserved no need to do it again.
12902 * Also if Reserve and Release are disabled Just return.
12903 */
12911 }
12913 /* See if command is on the list */
12921 /*
12922 * cmd is on list.
12923 * if byte is zero always allowed.
12924 */
12931 }
12939 }
12942 }
12944 static int
12946 {
12952 /*
12953 * Do not reserve when already reserved, when not supported or when
12954 * auto-rewinding on device closure.
12955 */
12964 }
12966 /* search for this command on the list */
12974 /*
12975 * cmd is on list.
12976 * if byte is zero always allowed.
12977 */
12983 }
12990 }
12993 }
12995 static int
12997 {
13018 }
13035 }
13036 /*
13037 * dynamically turn off reserve/release support
13038 * in case of drives which do not support
13039 * reserve/release command(ATAPI drives).
13040 */
13045 "Tape unit does not support "
13047 }
13049 }
13050 }
13052 }
13054 static int
13056 {
13068 /*
13069 * XXX -> Should reset be done only if we get EACCES.
13070 * .
13071 */
13075 }
13082 /*
13083 * remove the check condition.
13084 */
13093 }
13094 }
13095 /*
13096 * Set tape state to ST_STATE_OFFLINE , in case if
13097 * the user wants to continue and start using
13098 * the tape.
13099 */
13102 }
13104 }
13106 static int
13108 {
13113 /*
13114 * Create device error kstats
13115 */
13122 KSTAT_FLAG_PERSISTENT);
13129 KSTAT_DATA_ULONG);
13131 KSTAT_DATA_ULONG);
13133 KSTAT_DATA_ULONG);
13135 KSTAT_DATA_CHAR);
13137 KSTAT_DATA_CHAR);
13139 KSTAT_DATA_CHAR);
13141 KSTAT_DATA_CHAR);
13145 /*
13146 * Fill in the static data
13147 */
13150 /*
13151 * XXX: Emulex MT-02 (and emulators) predates
13152 * SCSI-1 and has no vid & pid inquiry data.
13153 */
13159 }
13160 }
13161 }
13163 }
13165 static int
13167 {
13176 /* Can't restore an invalid position */
13179 }
13181 /*
13182 * Assumtions:
13183 * If a position was read and is in logical position mode.
13184 * If a drive supports read position it supports locate.
13185 * If the read position type is not NO_POS. even though
13186 * a read position make not have been attemped yet.
13187 *
13188 * The drive can locate to the position.
13189 */
13191 /*
13192 * If position mode is logical or legacy mode try
13193 * to locate there as it is faster.
13194 * If it fails try the old way.
13195 */
13202 /* Assume we are there copy rest of position back */
13205 }
13207 }
13209 /*
13210 * If logical block locate failed to restore a logical
13211 * position, can't recover.
13212 */
13215 }
13216 }
13223 /*
13224 * Rewind ? Oh yeah, Fidelity has got the STK F/W changed
13225 * so as not to rewind tape on RESETS: Gee, Has life ever
13226 * been simple in tape land ?
13227 */
13231 "Failed to restore the last file and block position: In"
13235 }
13237 /* If the position was as the result of back space file */
13239 /* Go one extra file forward */
13241 /* Figure how many blocks to back into the previous file */
13243 }
13245 /* Go to requested fileno */
13250 "Failed to restore the last file position: In this "
13251 " state, Tape will be loaded at BOT during next"
13256 }
13257 }
13259 /*
13260 * If backing into a file we already did an extra file forward.
13261 * Now we have to back over the filemark to get to the end of
13262 * the previous file. The blkno has been ajusted to a negative
13263 * value so we will get to the expected location.
13264 */
13269 "Failed to restore the last file position: In this "
13270 " state, Tape will be loaded at BOT during next"
13275 }
13276 }
13278 /*
13279 * The position mode, block and fileno should be correct,
13280 * This updates eof and logical position information.
13281 */
13286 }
13288 /*
13289 * check sense key, ASC, ASCQ in order to determine if the tape needs
13290 * to be ejected
13291 */
13293 static int
13295 {
13306 }
13308 }
13310 /*
13311 * st_logpage_supported() sends a Log Sense command with
13312 * page code = 0 = Supported Log Pages Page to the device,
13313 * to see whether the page 'page' is supported.
13314 * Return values are:
13315 * -1 if the Log Sense command fails
13316 * 0 if page is not supported
13317 * 1 if page is supported
13318 */
13320 static int
13322 {
13329 SCMD_LOG_SENSE_G1,
13331 SUPPORTED_LOG_PAGES_PAGE,
13338 0
13339 };
13359 /* uscsi-command failed */
13370 }
13371 }
13372 }
13376 }
13379 /*
13380 * st_check_clean_bit() gets the status of the tape's cleaning bit.
13381 *
13382 * If the device does support the TapeAlert log page, then the cleaning bit
13383 * information will be read from this page. Otherwise we will see if one of
13384 * ST_CLN_TYPE_1, ST_CLN_TYPE_2 or ST_CLN_TYPE_3 is set in the properties of
13385 * the device, which means, that we can get the cleaning bit information via
13386 * a RequestSense command.
13387 * If both methods of getting cleaning bit information are not supported
13388 * st_check_clean_bit() will return with 0. Otherwise st_check_clean_bit()
13389 * returns with
13390 * - MTF_TAPE_CLN_SUPPORTED if cleaning bit is not set or
13391 * - MTF_TAPE_CLN_SUPPORTED | MTF_TAPE_HEAD_DIRTY if cleaning bit is set.
13392 * If the call to st_uscsi_cmd() to do the Log Sense or the Request Sense
13393 * command fails, or if the amount of Request Sense data is not enough, then
13394 * st_check_clean_bit() returns with -1.
13395 */
13397 static int
13399 {
13408 }
13415 }
13419 }
13424 }
13428 }
13433 }
13434 }
13443 }
13444 }
13451 }
13452 }
13459 }
13460 }
13462 /*
13463 * If found a supported means to check need to clean.
13464 */
13467 /*
13468 * head needs to be cleaned.
13469 */
13472 /*
13473 * Print log message only first time
13474 * found needing cleaned.
13475 */
13482 }
13487 }
13488 }
13491 }
13494 static int
13496 {
13499 ushort_t parameter;
13505 SCMD_LOG_SENSE_G1,
13514 0
13515 };
13541 }
13549 }
13562 }
13563 }
13566 }
13572 }
13575 static int
13577 {
13583 tape_alert_flags flag;
13585 SCMD_LOG_SENSE_G1,
13594 0
13595 };
13623 }
13632 }
13637 /*
13638 * if rval is bad before the first pass don't bother
13639 */
13643 }
13650 }
13651 /*
13652 * check to see if current parameter is of interest.
13653 * CLEAN_FOR_ERRORS is vendor specific to 9840 9940 stk's.
13654 */
13673 }
13675 }
13677 /*
13678 * Report it as dirty till we see it cleaned
13679 */
13685 }
13691 }
13694 static int
13696 {
13700 ushort_t byte_pos;
13701 uchar_t bit_mask;
13708 /*
13709 * Since this tape does not support Tape Alert,
13710 * we now try to get the cleanbit status via
13711 * Request Sense.
13712 */
13729 }
13767 }
13768 }
13773 }
13775 /*
13776 * st_clear_unit_attention
13777 *
13778 * run test unit ready's to clear out outstanding
13779 * unit attentions.
13780 * returns zero for SUCCESS or the errno from st_cmd call
13781 */
13782 static int
13784 {
13795 }
13797 static void
13799 {
13808 }
13809 }
13816 }
13817 }
13825 }
13826 }
13834 }
13835 }
13843 }
13844 }
13852 }
13853 }
13861 }
13862 }
13863 }
13866 static writablity
13868 {
13871 }
13873 static writablity
13875 {
13876 writablity wrt;
13880 /* Mode sense should be current */
13889 }
13891 }
13893 #define HP_DAT_INQUIRY 0x4A
13894 static writablity
13896 {
13899 writablity wrt;
13914 /* This drive doesn't support it so don't check again */
13923 }
13927 /*
13928 * If drive doesn't support it no point in checking further.
13929 */
13931 }
13933 static writablity
13935 {
13936 writablity wrt;
13940 /* Mode sense should be current */
13964 }
13982 }
13985 }
13987 #define LTO_REQ_INQUIRY 44
13988 static writablity
13990 {
13993 writablity wrt;
14008 /* This drive doesn't support it so don't check again */
14017 }
14021 /*
14022 * If drive doesn't support it no point in checking further.
14023 */
14025 }
14027 static writablity
14029 {
14030 writablity wrt;
14042 }
14044 }
14046 #define SEQ_CAP_PAGE (char)0xb0
14047 static writablity
14049 {
14052 writablity wrt;
14062 "Read Vitial Inquiry for Sequental Capability"
14069 /* This drive doesn't support it so don't check again */
14078 }
14083 }
14086 #define STK_REQ_SENSE 26
14088 static writablity
14090 {
14096 writablity wrt;
14135 }
14140 }
14142 #define DLT_INQ_SZ 44
14144 static writablity
14146 {
14147 caddr_t buf;
14149 writablity wrt;
14155 /* Read Attribute Media Type */
14159 /*
14160 * If this quantum drive is attached via an HBA that cannot
14161 * support thr read attributes command return error in the
14162 * hope that someday they will support the t10 method.
14163 */
14166 "Read Attribute Command for WORM Media detection is not "
14171 }
14176 result);
14180 }
14190 }
14192 out:
14195 }
14197 static writablity
14199 {
14200 caddr_t buf;
14202 writablity wrt;
14215 }
14229 }
14230 out:
14234 }
14241 uchar_t page_len;
14249 uchar_t span;
14260 uchar_t page_len;
14268 uchar_t span;
14275 #endif
14278 #define AIT_DEV_PAGE 0x31
14279 static writablity
14281 {
14283 writablity wrt;
14316 }
14322 /* No further checking required */
14324 }
14329 "AIT device config mode sense page read command failed"
14333 }
14337 }
14339 static writablity
14341 {
14342 writablity wrt;
14365 }
14373 }
14379 }
14381 /*
14382 * If any of the above failed try the t10 standard method.
14383 */
14386 }
14388 /*
14389 * Unknown method for detecting WORM media.
14390 */
14396 }
14399 }
14401 static int
14404 {
14416 }
14453 /*
14454 * If this returns invalid operation code don't try again.
14455 */
14461 }
14465 /*
14466 * The attribute retured should match the attribute requested.
14467 */
14470 "st_read_attribute got wrong data back expected "
14475 }
14476 }
14481 }
14483 static int
14485 uchar_t page)
14486 {
14520 }
14521 }
14527 }
14530 static int
14532 {
14542 /*
14543 * If read position command returned good status
14544 * Parse the data to see if the position can be interpreted.
14545 */
14550 /*
14551 * Update the running position as well if un_pos was
14552 * ok. But only if recovery is enabled.
14553 */
14556 }
14567 "st_update_block_pos() read position cmd 0x%x"
14570 /* ENOTTY means it read garbage. try something else. */
14575 }
14578 "st_update_block_pos() read position cmd %x"
14581 }
14600 }
14602 }
14605 }
14607 static int
14609 {
14612 caddr_t pos_info;
14619 }
14627 }
14633 }
14635 /*
14636 * Copy the buf to a double-word aligned memory that can hold the
14637 * tape_position_t data structure.
14638 */
14644 }
14647 #ifdef STDEBUG
14652 }
14653 #endif
14664 }
14666 #if defined(_BIG_ENDIAN)
14668 #define FIX_ENDIAN16(x)
14669 #define FIX_ENDIAN32(x)
14670 #define FIX_ENDIAN64(x)
14672 #elif defined(_LITTLE_ENDIAN)
14674 static void
14676 {
14683 }
14685 static void
14687 {
14696 }
14698 static void
14700 {
14712 }
14714 #define FIX_ENDIAN16(x) st_swap16(x)
14715 #define FIX_ENDIAN32(x) st_swap32(x)
14716 #define FIX_ENDIAN64(x) st_swap64(x)
14717 #endif
14719 /*
14720 * st_interpret_read_pos()
14721 *
14722 * Returns:
14723 * 0 If secsessful.
14724 * EIO If read postion responce data was unuseable or invalid.
14725 * ERANGE If the position of the drive is too large for the read_p_type.
14726 * ENOTTY If the responce data looks invalid for the read position type.
14727 */
14729 static int
14732 {
14735 tapepos_t org;
14739 /*
14740 * We expect the position value to change after a space command.
14741 * So if post_space is set we don't print out what has changed.
14742 */
14747 }
14749 /*
14750 * See what kind of read position was requested.
14751 */
14755 {
14759 /* If reserved fields are non zero don't use the data */
14767 }
14768 /*
14769 * Position is to large to use this type of read position.
14770 */
14776 }
14777 /*
14778 * If your at the begining of partition and end at the same
14779 * time it's very small partition or bad data.
14780 */
14783 "SHORT_POS returned begin and end of"
14787 }
14794 /*
14795 * If the tape is rewound the host blcok should be 0.
14796 */
14800 "SHORT_POS returned begin of partition"
14804 }
14808 flag++;
14812 }
14816 /*
14817 * If the begining of partition is true and the
14818 * block number is zero we will beleive that it is
14819 * rewound. Promote the pmode to legacy.
14820 */
14827 /*
14828 * otherwise if the pmode was invalid,
14829 * promote it to logical.
14830 */
14833 }
14837 flag++;
14842 }
14850 }
14852 }
14855 {
14860 /* If reserved fields are non zero don't use the data */
14868 }
14870 /* Is position Valid */
14877 /*
14878 * If it says we are at the begining of partition
14879 * the block value better be 0.
14880 */
14884 "LONG_POS returned begin of partition but"
14888 }
14889 /*
14890 * Can't be at the start and the end of the partition
14891 * at the same time if the partition is larger the 0.
14892 */
14896 "LONG_POS returned begin and end of"
14900 }
14902 /*
14903 * If the logical block number is not what we expected.
14904 */
14907 flag++;
14909 "LONG_POS current logical 0x%"PRIx64
14912 }
14915 /*
14916 * If the begining of partition is true and the
14917 * block number is zero we will beleive that it is
14918 * rewound. Promote the pmode to legacy.
14919 */
14926 /*
14927 * otherwise if the pmode was invalid,
14928 * promote it to logical.
14929 */
14932 }
14938 flag++;
14940 "LONG_POS current partition %d"
14942 }
14945 /*
14946 * If the drive doesn't know location,
14947 * we don't either.
14948 */
14952 }
14954 /* Is file position valid */
14958 /*
14959 * If it says we are at the begining of partition
14960 * the block value better be 0.
14961 */
14965 "LONG_POS returned begin of partition but"
14969 }
14974 flag++;
14976 "LONG_POS fileno 0x%"PRIx64
14981 }
14983 }
14987 }
14990 }
14993 {
14999 /* Make sure that there is enough data there */
15002 }
15004 /* If reserved fields are non zero don't use the data */
15010 }
15012 /*
15013 * In the unlikely event of overflowing 64 bits of position.
15014 */
15018 }
15026 len);
15029 }
15031 /* Is block position information valid */
15039 "EXT_POS returned begining of partition but"
15043 }
15047 flag++;
15049 "EXT_POS current logical 0x%"PRIx64
15052 }
15055 /*
15056 * If the begining of partition is true and the
15057 * block number is zero we will beleive that it is
15058 * rewound. Promote the pmode to legacy.
15059 */
15066 }
15067 /*
15068 * otherwise if the pmode was invalid,
15069 * promote it to logical.
15070 */
15073 }
15077 flag++;
15082 }
15087 }
15089 }
15095 }
15102 }
15105 }
15107 static int
15110 {
15118 /*
15119 * Not sure what to do when doing recovery and not wanting
15120 * to update un_pos
15121 */
15138 /*
15139 * If the drive doesn't give a 64 bit read position data
15140 * it is unlikely it will accept 64 bit locates.
15141 */
15145 }
15163 }
15178 /*
15179 * XXX This is a work around till we handle Descriptor format
15180 * sense data. Since we are sending a command where the standard
15181 * sense data can not correctly represent a correct residual in
15182 * 4 bytes.
15183 */
15187 /* Doesn't like big locate command */
15191 /* Aborted big locate command */
15194 rval);
15198 /* read position failed */
15203 /* read position worked but position was not expected */
15205 "Big LOCATE and recover read less then desired 0x%"
15211 /* read position was what was expected */
15221 }
15224 /* Worked as requested */
15229 /* Got part way there but wasn't enough blocks on tape */
15236 /* Got part way there but drive didn't tell what we missed by */
15249 }
15254 }
15256 static int
15258 {
15266 #if 0
15271 }
15272 #endif
15273 /* pmode == invalid already handled */
15275 /*
15276 * forward space over filemark
15277 *
15278 * For ASF we allow a count of 0 on fsf which means
15279 * we just want to go to beginning of current file.
15280 * Equivalent to "nbsf(0)" or "bsf(1) + fsf".
15281 * Allow stepping over double fmk with reel
15282 */
15286 /* we're at EOM */
15292 }
15294 /*
15295 * physical tape position may not be what we've been
15296 * telling the user; adjust the request accordingly
15297 */
15301 /*
15302 * For positive direction case, we're now covered.
15303 * For zero or negative direction, we're covered
15304 * (almost)
15305 */
15306 files--;
15307 }
15309 }
15315 }
15318 /*
15319 * Forward space file marks.
15320 * We leave ourselves at block zero
15321 * of the target file number.
15322 */
15327 }
15330 }
15332 static int
15334 {
15345 /*
15346 * A space with a count of zero means take me to the start of file.
15347 */
15350 /* Hay look were already there */
15355 }
15357 /*
15358 * Well we are in the first file.
15359 * A rewind will get to the start.
15360 */
15364 /*
15365 * Can we backspace to get there?
15366 * This should work in logical mode.
15367 */
15371 /*
15372 * Can't back space but current file number is known,
15373 * So rewind and space from the begining of the partition.
15374 */
15379 /*
15380 * pmode is logical and ST_BSF is not set.
15381 * The LONG_POS read position contains the fileno.
15382 * If the read position works, rewind and space.
15383 */
15387 /*
15388 * We didn't get the file position from the
15389 * read position command.
15390 * We are going to trust the drive to backspace
15391 * and then position after the filemark.
15392 */
15394 }
15402 }
15405 }
15406 /*
15407 * If something didn't work we are lost
15408 */
15415 }
15419 }
15422 /*
15423 * we came here with a count < 0; we now need
15424 * to skip back to end up before the filemark
15425 */
15427 }
15430 }
15432 static int
15434 {
15443 }
15446 }
15448 static int
15450 {
15455 /*
15456 * Back space of the file at the begining of the file.
15457 */
15462 }
15464 /*
15465 * Other interesting answers might be crashed BOT which isn't bad.
15466 */
15469 }
15473 /*
15474 * Now we are on the BOP side of the filemark. Forward space to
15475 * the EOM side and we are at the begining of the file.
15476 */
15480 }
15483 }
15485 static int
15487 {
15491 /*
15492 * forward space to inter-record gap
15493 *
15494 */
15500 /*
15501 * If were are at end of tape and count is forward.
15502 * Return blank check.
15503 */
15505 /* we're at EOM */
15511 }
15513 /*
15514 * If count is zero there is nothing to do.
15515 */
15522 }
15524 }
15526 /*
15527 * physical tape position may not be what we've been
15528 * telling the user; adjust the position accordingly
15529 */
15540 }
15545 }
15546 }
15552 }
15555 }
15557 static int
15559 {
15573 }
15575 }
15579 /* Already there */
15584 }
15586 /*
15587 * If the destination block is forward
15588 * or the drive will backspace records.
15589 */
15591 /*
15592 * If we're spacing forward, or the device can
15593 * backspace records, we can just use the SPACE
15594 * command.
15595 */
15602 /*
15603 * check if we hit BOT/EOT
15604 */
15611 /*
15612 * we skipped over a filemark
15613 * and need to go forward again
15614 */
15620 }
15622 }
15625 "st_space_records: EIO : space_rec rval"
15628 }
15629 }
15631 /*
15632 * else we rewind, space forward across filemarks to
15633 * the desired file, and then space records to the
15634 * desired block.
15635 */
15640 /*
15641 * Wups - we're backing up over a filemark
15642 */
15647 }
15655 }
15664 "st_space_records: EIO :space_records : rewind "
15668 }
15669 }
15672 }
15674 static int
15676 {
15681 /*
15682 * backward space of file filemark (1/2" and 8mm)
15683 * tape position will end on the beginning of tape side
15684 * of the desired file mark
15685 */
15688 }
15692 /*
15693 * If a negative count (which implies a forward space op)
15694 * is specified, and we're at logical or physical eot,
15695 * bounce the request.
15696 */
15704 }
15705 /*
15706 * physical tape position may not be what we've been
15707 * telling the user; adjust the request accordingly
15708 */
15712 files++;
15717 }
15718 }
15724 }
15727 /*
15728 * for a negative count, we need to step forward
15729 * first and then step back again
15730 */
15733 }
15735 }
15737 static int
15739 {
15749 /*
15750 * Backspace files (MTNBSF): infront == 0
15751 *
15752 * For tapes that can backspace, backspace
15753 * count+1 filemarks and then run forward over
15754 * a filemark
15755 *
15756 * For tapes that can't backspace,
15757 * calculate desired filenumber
15758 * (un->un_pos.fileno - count), rewind,
15759 * and then space forward this amount
15760 *
15761 * Backspace filemarks (MTBSF) infront == 1
15762 *
15763 * For tapes that can backspace, backspace count
15764 * filemarks
15765 *
15766 * For tapes that can't backspace, calculate
15767 * desired filenumber (un->un_pos.fileno - count),
15768 * add 1, rewind, space forward this amount,
15769 * and mark state as ST_EOF_PENDING appropriately.
15770 */
15775 "st_backward_space_files: mt_op=%x count=%"PRIx64
15780 /* In case a drive that won't back space gets in logical mode */
15784 }
15794 }
15796 }
15799 "st_backward_space_files: mt_op=%x count=%"PRIx64
15805 /*
15806 * Handle the simple case of BOT
15807 * playing a role in these cmds.
15808 * We do this by calculating the
15809 * ending file number. If the ending
15810 * file is < BOT, rewind and set an
15811 * error and mark resid appropriately.
15812 * If we're backspacing a file (not a
15813 * filemark) and the target file is
15814 * the first file on the tape, just
15815 * rewind.
15816 */
15818 /* figure expected destination of this SPACE command */
15821 /*
15822 * Would the end effect of this SPACE be the same as rewinding?
15823 * If so just rewind instead.
15824 */
15829 "st_backward_space_files: EIO : "
15832 }
15835 "st_backward_space_files: EIO : "
15840 }
15842 }
15846 /*
15847 * If we are going to end up at the beginning
15848 * of the file, we have to space one extra file
15849 * first, and then space forward later.
15850 */
15859 }
15865 }
15866 }
15868 /*
15869 * If we have to space forward, do so...
15870 */
15880 /*
15881 * If we had to space forward, and we're
15882 * not a tape that can backspace, mark state
15883 * as if we'd just seen a filemark during a
15884 * a read.
15885 */
15891 }
15892 }
15893 }
15897 }
15900 }
15902 static int
15904 {
15913 /*
15914 * backward space file to beginning of file
15915 *
15916 * If a negative count (which implies a forward space op)
15917 * is specified, and we're at logical or physical eot,
15918 * bounce the request.
15919 */
15927 }
15928 /*
15929 * physical tape position may not be what we've been
15930 * telling the user; adjust the request accordingly
15931 */
15935 count++;
15936 }
15937 }
15943 }
15952 }
15954 }
15956 static int
15958 {
15965 /*
15966 * backward space into inter-record gap
15967 *
15968 * If a negative count (which implies a forward space op)
15969 * is specified, and we're at logical or physical eot,
15970 * bounce the request.
15971 */
15978 }
15985 }
15987 }
15989 /*
15990 * physical tape position may not be what we've been
15991 * telling the user; adjust the position accordingly.
15992 * bsr can not skip filemarks and continue to skip records
15993 * therefore if we are logically before the filemark but
15994 * physically at the EOT side of the filemark, we need to step
15995 * back; this allows fsr N where N > number of blocks in file
15996 * followed by bsr 1 to position at the beginning of last block
15997 */
15999 tapepos_t save;
16007 }
16011 }
16012 }
16020 }
16024 }
16026 static int
16028 {
16038 /*
16039 * Drive says invalid field in cdb.
16040 * Doesn't like space multiple. Position isn't lost.
16041 */
16048 }
16050 }
16052 static int
16054 {
16064 /*
16065 * Drive says invalid field in cdb.
16066 * Doesn't like space multiple. Position isn't lost.
16067 */
16074 }
16076 }
16078 #ifdef __x86
16080 /*
16081 * release contig_mem and wake up waiting thread, if any
16082 */
16083 static void
16085 {
16096 }
16098 /*
16099 * St_get_contig_mem will return a contig_mem if there is one available
16100 * in current system. Otherwise, it will try to alloc one, if the total
16101 * number of contig_mem is within st_max_contig_mem_num.
16102 * It will sleep, if allowed by caller or return NULL, if no contig_mem
16103 * is available for now.
16104 */
16107 {
16110 ddi_acc_handle_t acc_hdl;
16111 caddr_t addr;
16116 /* Try to get one available contig_mem */
16124 /*
16125 * we failed to get one. we're going to
16126 * alloc one more contig_mem for this I/O
16127 */
16131 alloc_flags);
16136 }
16143 /*
16144 * we failed to get one and we're NOT allowed to
16145 * alloc more contig_mem
16146 */
16150 }
16157 }
16158 }
16161 /* We need to check if this block of mem is big enough for this I/O */
16163 /* not big enough, need to alloc a new one */
16173 /* release previous one before attach new one */
16175 }
16182 /* attach new mem to this cp */
16188 }
16191 }
16193 /* cannot find/alloc a usable cp, when we get here */
16200 }
16202 /*
16203 * we're allowed to sleep, and there is one big enough
16204 * contig mem in the system, which is currently in use,
16205 * wait for it...
16206 */
16214 /* we get the big enough contig mem, finally */
16216 alloc_ok:
16217 /* init bp attached to this cp */
16223 }
16225 /*
16226 * this is the biodone func for the bp used in big block I/O
16227 */
16228 static int
16230 {
16236 /* sanity check */
16239 }
16244 }
16252 /* special handling for special I/O */
16254 #ifndef __lock_lint
16256 #endif
16259 }
16266 /* copy data back to original bp */
16269 }
16276 }
16278 /*
16279 * We use this func to replace original bp that may not be able to do I/O
16280 * in big block size with one that can
16281 */
16284 {
16292 }
16296 /* try to get one contig_mem */
16303 }
16307 /* make sure that we "are" using un_sbufp for special I/O */
16309 #ifndef __lock_lint
16311 #endif
16314 }
16316 /* clone bp */
16337 /* get data in original bp */
16340 }
16343 }
16344 #else
16345 #ifdef __lock_lint
16346 static int
16348 {
16350 }
16351 #endif
16352 #endif
16355 {
16362 "AFTER_EOM"
16363 };
16367 "logical"
16368 };
16370 static void
16373 {
16390 }
16391 static int
16393 {
16399 /*
16400 * find non alpha numeric working from the end.
16401 */
16406 }
16407 }
16410 /*
16411 * Drive seems to think its returning useful data
16412 * but it looks like all junk
16413 */
16415 }
16417 size++;
16419 /*
16420 * Actually got a valid serial number.
16421 * If never stored one before alloc space for it.
16422 */
16433 }
16454 }
16459 }
16460 #define ID_SIZE 32
16462 {
16463 uchar_t avilable_data0;
16464 uchar_t avilable_data1;
16465 uchar_t avilable_data2;
16466 uchar_t avilable_data3;
16467 uchar_t attribute_msb;
16468 uchar_t attribute_lsb;
16469 #ifdef _BIT_FIELDS_LTOH
16473 #else
16477 #endif
16478 uchar_t attribute_len_msb;
16479 uchar_t attribute_len_lsb;
16483 attribute_header header;
16487 static int
16489 {
16493 uchar_t byte;
16505 else
16508 }
16514 }
16517 static int
16519 {
16527 again:
16537 "resizing read attribute data from %d to %d format"
16543 }
16547 result =
16551 newsize);
16552 }
16555 "Read Attribute Command for Media Identification is not "
16558 }
16564 }
16567 static int
16569 {
16575 caddr_t buf;
16581 }
16584 upsize:
16613 "media serial command returned %d scsi_status %d"
16616 /*
16617 * If this returns invalid operation code don't try again.
16618 */
16624 }
16629 /*
16630 * get reported size.
16631 */
16635 /* documentation says mod 4. */
16637 act_size++;
16638 }
16640 /*
16641 * If reported size is larger that we our buffer.
16642 * Free the old one and allocate one that is larger
16643 * enough and re-issuse the command.
16644 */
16649 }
16657 /*
16658 * set data pointer to point to the start
16659 * of that serial number.
16660 */
16662 st_get_media_id_via_media_serial_cmd;
16663 rval =
16665 }
16666 }
16672 }
16675 /* ARGSUSED */
16676 static int
16678 {
16686 }
16690 media_chk_function media_chk_functions[] = {
16691 st_get_media_id_via_media_serial_cmd,
16692 st_get_media_id_via_read_attribute,
16693 st_bogus_media_id
16694 };
16696 static int
16698 {
16706 /*
16707 * Last operation type not supported by this device.
16708 * Make so next time it doesn`t do that again.
16709 */
16714 }
16716 /*
16717 * If result indicates the function was successful or
16718 * that the media is not the same as last known, break.
16719 */
16722 }
16723 }
16726 }
16728 static errstate
16730 errstate onentry)
16731 {
16743 /*
16744 * Don't try and recover a reset that this device sent.
16745 */
16749 }
16751 /*
16752 * See if expected position was passed with scsi_pkt.
16753 */
16756 /*
16757 * Not for this command.
16758 */
16761 }
16763 /*
16764 * Create structure to hold all error state info.
16765 */
16771 /* disabled */
16773 }
16778 DDI_NOSLEEP);
16783 }
16785 }
16788 static void
16790 {
16798 #if !defined(lint)
16800 #endif
16819 /* FALLTHROUGH */
16823 /* FALLTHROUGH */
16831 }
16835 }
16838 static void
16840 {
16844 tapepos_t cur_pos;
16878 /*
16879 * If the drive responed to the TUR lets try and get it to sync
16880 * any data it might have in the buffer.
16881 */
16889 }
16890 }
16896 /*
16897 * For now if we can't talk to the device we are done.
16898 * If the drive is reserved we can try to get it back.
16899 */
16903 }
16905 /*
16906 * If reservation conflict and do a preempt, fail it.
16907 */
16911 SCMD_PERSISTENT_RESERVE_OUT) &&
16913 ST_SA_SCSI3_PREEMPT) &&
16915 STATUS_RESERVATION_CONFLICT)) {
16918 }
16919 }
16921 /*
16922 * If we have already set a scsi II reserve and get a
16923 * conflict on a scsi III type reserve fail without
16924 * any attempt to recover.
16925 */
16928 SCMD_PERSISTENT_RESERVE_OUT) ||
16930 SCMD_PERSISTENT_RESERVE_IN)) {
16933 }
16935 /*
16936 * If scsi II lost reserve try and get it back.
16937 */
16940 ST_LOST_RESERVE)) &&
16943 st_uscsi_rcmd);
16947 COMMAND_DONE_EACCES);
16949 }
16950 }
16954 }
16959 }
16962 /*
16963 * Check if the ASC/ASCQ says mode data has changed.
16964 */
16969 /*
16970 * See if mode sense changed.
16971 */
16973 st_uscsi_rcmd);
16977 }
16978 }
16979 /*
16980 * if we have a media id and its not bogus.
16981 * Check to see if it the same.
16982 */
16988 }
16989 }
16995 }
16997 /*
16998 * if command is retriable retry it.
16999 * Special case here. The command attribute for SCMD_REQUEST_SENSE
17000 * does not say that it is retriable. That because if you reissue a
17001 * request sense and the target responds the sense data will have
17002 * been consumed and no long be valid. If we get a busy status on
17003 * request sense while the state is ST_STATE_SENSING this will
17004 * reissue that pkt.
17005 *
17006 * XXX If this request sense gets sent to a different port then
17007 * the original command that failed was sent on it will not get
17008 * valid sense data for that command.
17009 */
17013 /*
17014 * if drive doesn't support read position we are done
17015 */
17018 /*
17019 * If this command results in a changed tape position,
17020 * lets see where we are.
17021 */
17023 /*
17024 * XXX May be a reason to choose a different type here.
17025 * Long format has file position information.
17026 * Short and Extended have information about whats
17027 * in the buffer. St's positioning assumes in the buffer
17028 * to be the same as on tape.
17029 */
17039 }
17042 }
17045 }
17047 static void
17049 {
17056 /*
17057 * Get the buf from the packet.
17058 */
17063 /*
17064 * get the unit from the buf.
17065 */
17086 }
17097 else
17105 }
17107 /*
17108 * check for undetected path failover.
17109 */
17115 "Failover detected in recovery, action is "
17117 }
17119 }
17120 }
17146 /* longish timeout */
17148 /* FALLTHRU */
17152 /*
17153 * let st_handle_intr_busy put this bp back on waitq and make
17154 * checks to see if it is ok to requeue the command.
17155 */
17158 /*
17159 * Save the throttle before setting up the timeout
17160 */
17163 }
17167 }
17183 }
17186 }
17188 static int
17190 {
17203 #ifdef STDEBUG
17206 }
17207 #endif
17225 }
17227 /* args used */
17228 static int
17230 {
17237 /*
17238 * Get buffer resources...
17239 */
17257 /*
17258 * Free resources
17259 */
17264 }
17266 /*
17267 * Add data to scsi_pkt to help know what to do if the command fails.
17268 */
17269 static void
17272 {
17286 }
17292 /*
17293 * lookup the command attributes and add them to the recovery info.
17294 */
17299 /*
17300 * For commands that there is no way to figure the expected position
17301 * once completed, we save the position the command was started from
17302 * so that if they fail we can position back and try again.
17303 * This has already been done in st_cmd() or st_iscsi_cmd().
17304 */
17306 /* save current position as the starting position. */
17310 }
17312 /*
17313 * Don't want to update the running position for recovery.
17314 */
17318 }
17319 /*
17320 * If running position is invalid copy the current position.
17321 * Running being set invalid means we are not in a read, write
17322 * or write filemark sequence.
17323 * We'll copy the current position and start from there.
17324 */
17331 /*
17332 * Always should be more logical blocks then
17333 * data blocks and files marks.
17334 */
17338 }
17339 }
17341 /*
17342 * If the command is not expected to change the drive position
17343 * then the running position should be the expected position.
17344 */
17348 }
17354 /*
17355 * This is a user generated CDB.
17356 */
17362 /*
17363 * See if this CDB will generate a locate or change
17364 * partition.
17365 */
17374 }
17388 }
17393 }
17397 /* should not have got an invalid position from running. */
17400 }
17402 /* should have either a get count or or get lba function */
17406 /* only explicit commands have both and they're handled above */
17410 /* if it has a get count function */
17415 }
17416 /*
17417 * Changes position but doesn't transfer data.
17418 * i.e. rewind, write_file_mark and load.
17419 */
17424 SCMD_ERASE);
17449 SCMD_LOAD);
17482 }
17487 }
17489 /*
17490 * Changes position and does transfer data.
17491 * i.e. read or write.
17492 */
17509 }
17510 }
17512 /* Have a get LBA fuction. i.e. Locate */
17514 DIR_EITH);
17524 }
17526 }
17531 }
17533 static int
17535 {
17540 /*
17541 * check to see if mode data has changed.
17542 */
17547 }
17550 }
17552 }
17554 static int
17556 {
17561 caddr_t that;
17565 /* recovery called with mode tamper before mode selection */
17570 }
17581 }
17590 }
17591 #ifdef STDEBUG
17596 "sense data changed at byte %d was "
17599 }
17600 }
17601 }
17602 #endif
17606 }
17608 static int
17610 {
17616 /*
17617 * XXX Newer drives may not RESEVATION CONFLICT a TUR.
17618 */
17624 }
17628 limit--;
17635 }
17637 /*
17638 * Does read position using recov_buf and doesn't update un_pos.
17639 * Does what ever kind of read position you want.
17640 */
17641 static int
17644 {
17683 }
17688 }
17690 }
17692 static int
17695 {
17721 }
17725 }
17727 }
17733 }
17735 }
17737 /*
17738 * based on the command do we retry, continue or give up?
17739 * possable return values?
17740 * zero do nothing looks fine.
17741 * EAGAIN retry.
17742 * EIO failed makes no sense.
17743 */
17744 static int
17747 {
17768 }
17775 }
17777 /*
17778 * Command that changes tape position and have an expected position
17779 * if it were to chave completed sucessfully.
17780 */
17792 /*
17793 * At expected?
17794 */
17799 /*
17800 * If the command should move tape and it got a busy
17801 * it shouldn't be in the expected position.
17802 */
17806 /*
17807 * If the command doesn't transfer data should be good.
17808 */
17812 /*
17813 * Command transfers data, should have done so.
17814 */
17816 STATE_XFERRED_DATA) {
17820 }
17821 }
17824 difference =
17828 "difference between expected and actual is %"
17834 }
17836 /*
17837 * If rewound or somewhere between the starting position
17838 * and the expected position (partial read or write).
17839 * Locate to the starting position and try the whole
17840 * thing over again.
17841 */
17853 }
17854 /*
17855 * This handles flushed read ahead on the drive or
17856 * an aborted read that presents as a busy and advanced
17857 * the tape position.
17858 */
17870 }
17871 /*
17872 * XXX swag seeing difference of 2 on write filemark.
17873 * If the space to the starting position works on a
17874 * write that means the previous write made it to tape.
17875 * If not we lost data and have to give up.
17876 *
17877 * The plot thickens. Now I am attempting to cover a
17878 * count of 1 and a differance of 2 on a write.
17879 */
17890 }
17894 rval);
17897 "Not expected transfers_data = %d "
17900 }
17905 /* Don't think we can write backwards */
17907 difference =
17910 "difference between expected and actual is %"
17916 }
17928 }
17929 /* This handles read ahead in reverse direction */
17941 }
17944 "Not expected transfers_data = %d "
17947 }
17951 /*
17952 * Commands that change tape position either
17953 * direction or don't change position should not
17954 * get here.
17955 */
17957 }
17961 /*
17962 * Command that changes tape position and can only be recovered
17963 * by going back to the point of origin and retrying.
17964 *
17965 * Example SCMD_SPACE.
17966 */
17968 /*
17969 * This type of command stores the starting position.
17970 * If the read position is the starting position,
17971 * reissue the command.
17972 */
17975 "Found Space command at starting position, "
17978 }
17979 /*
17980 * Not in the position that the command was originally issued,
17981 * Attempt to locate to that position.
17982 */
17988 "Found Space at an unexpected position and locate "
17991 }
17993 "Found Space at an unexpected position and locate "
17996 }
18003 }
18005 static errstate
18007 {
18013 uint_t cdblen;
18028 }
18030 /*
18031 * Some non-uscsi commands use the b_bcount for values that
18032 * have nothing to do with how much data is transfered.
18033 * In those cases we need to hide the buf_t from scsi_init_pkt().
18034 */
18041 }
18043 /*
18044 * if this is a queued command make sure it the only one in the
18045 * run queue.
18046 */
18051 }
18058 }
18066 }
18084 /*
18085 * oldpkt passed in was a copy of the original.
18086 * to distroy we need the address of the original.
18087 */
18093 }
18102 }
18107 }
18113 }
18116 }
18118 static int
18120 {
18134 }
18136 /*
18137 * Removed the buf_t bp from the queue referenced to by head and tail.
18138 * Returns the buf_t pointer if it is found in the queue.
18139 * Returns NULL if it is not found.
18140 */
18143 {
18149 /* found it, is it at the head? */
18154 }
18157 }
18160 }
18162 }
18164 }
18166 /*
18167 * Adds a buf_t to the queue pointed to by head and tail.
18168 * Adds it either to the head end or the tail end based on which
18169 * the passed variable end (head or tail) points at.
18170 */
18171 static void
18173 {
18177 /* Queue is not empty */
18179 /* Add at front of queue */
18183 /* Add at end of queue */
18188 }
18190 /* Queue is empty */
18193 }
18194 }
18197 static uint64_t
18199 {
18203 /* fixed block mode, the count is the number of blocks */
18204 count =
18209 /* variable block mode, the count is the block size */
18211 }
18213 }
18215 static uint64_t
18217 {
18220 count =
18224 /*
18225 * If the sign bit of the 3 byte value is set, extended it.
18226 */
18229 }
18231 }
18233 static uint64_t
18235 {
18238 count =
18243 }
18245 static uint64_t
18247 {
18251 /* fixed block mode */
18252 count =
18257 /* variable block mode */
18259 }
18261 }
18263 static uint64_t
18265 {
18268 }
18270 static uint64_t
18272 {
18274 }
18276 static uint64_t
18278 {
18280 }
18282 static uint64_t
18284 {
18287 lba =
18293 }
18295 static uint64_t
18297 {
18304 }
18306 static uint64_t
18308 {
18311 lba =
18321 }
18456 };
18460 {
18468 }
18469 }
18472 }
18474 static int
18476 {
18506 }
18507 }
18511 }
18513 #define SAS_TLR_MOD_LEN sizeof (struct seq_mode)
18514 static int
18516 {
18529 }
18532 }
18533 /* Must be SAS protocol */
18538 }
18547 }
18555 else
18557 }
18558 #ifdef STDEBUG
18561 #endif
18562 out:
18565 }
18568 static void
18570 {
18578 ST_RESERVE) {
18585 }
18592 }
18596 }