st.c revision 38d6b75a067abaff85b53171045f9fdca1c4f636
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* SCSI SCSA-compliant and not-so-DDI-compliant Tape Driver
*/
#define DEBUG 1
#endif
#include <sys/ddidmareq.h>
/*
*/
kstat_function(IOSP); \
}
#define ST_DO_ERRSTATS(un, x) \
if (un->un_errstats) { \
struct st_errstats *stp; \
}
int _lun; \
DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0); \
if (_lun > 0) { \
_lun; \
} \
}
/*
* Global External Data Definitions
*/
extern struct scsi_key_strings scsi_cmds[];
/*
* Local Static Data
*/
static void *st_state;
static char *st_label = "st";
/*
* We need to use below DMA attr to alloc physically contiguous
* memory to do I/O in big block size
*/
static ddi_dma_attr_t st_contig_mem_dma_attr = {
DMA_ATTR_V0, /* version number */
0x0, /* lowest usable address */
0xFFFFFFFFull, /* high DMA address range */
0xFFFFFFFFull, /* DMA counter register */
1, /* DMA address alignment */
1, /* DMA burstsizes */
1, /* min effective DMA size */
0xFFFFFFFFull, /* max DMA xfer size */
0xFFFFFFFFull, /* segment boundary */
1, /* s/g list length */
1, /* granularity of device */
0 /* DMA transfer flags */
};
static ddi_device_acc_attr_t st_acc_attr = {
};
/* set limitation for the number of contig_mem */
static int st_max_contig_mem_num = ST_MAX_CONTIG_MEM_NUM;
#endif
/*
* Tunable parameters
*
* DISCLAIMER
* ----------
* These parameters are intended for use only in system testing; if you use
* them in production systems, you do so at your own risk. Altering any
* variable not listed below may cause unpredictable system behavior.
*
* st_check_media_time
*
* Three second state check
*
* st_allow_large_xfer
*
* Gated with ST_NO_RECSIZE_LIMIT
*
* 0 - Transfers larger than 64KB will not be allowed
* regardless of the setting of ST_NO_RECSIZE_LIMIT
* 1 - Transfers larger than 64KB will be allowed
* if ST_NO_RECSIZE_LIMIT is TRUE for the drive
*
* st_report_soft_errors_on_close
*
* Gated with ST_SOFT_ERROR_REPORTING
*
* 0 - Errors will not be reported on close regardless
* of the setting of ST_SOFT_ERROR_REPORTING
*
* 1 - Errors will be reported on close if
* ST_SOFT_ERROR_REPORTING is TRUE for the drive
*/
static int st_selection_retry_count = ST_SEL_RETRY_COUNT;
static int st_retry_count = ST_RETRY_COUNT;
static int st_io_time = ST_IO_TIME;
static int st_long_timeout_x = ST_LONG_TIMEOUT_X;
static int st_space_time = ST_SPACE_TIME;
static int st_long_space_time_x = ST_LONG_SPACE_TIME_X;
static int st_error_level = SCSI_ERR_RETRYABLE;
static int st_max_throttle = ST_MAX_THROTTLE;
static int st_allow_large_xfer = 1;
static int st_report_soft_errors_on_close = 1;
/*
* End of tunable parameters list
*/
/*
* Asynchronous I/O and persistent errors, refer to PSARC/1995/228
*
* Asynchronous I/O's main offering is that it is a non-blocking way to do
* reads and writes. The driver will queue up all the requests it gets and
* have them ready to transport to the HBA. Unfortunately, we cannot always
* just ship the I/O requests to the HBA, as there errors and exceptions
* that may happen when we don't want the HBA to continue. Therein comes
* the flush-on-errors capability. If the HBA supports it, then st will
* send in st_max_throttle I/O requests at the same time.
*
* Persistent errors : This was also reasonably simple. In the interrupt
* routines, if there was an error or exception (FM, LEOT, media error,
* transport error), the persistent error bits are set and shuts everything
* down, but setting the throttle to zero. If we hit and exception in the
* HBA, and flush-on-errors were set, we wait for all outstanding I/O's to
* come back (with CMD_ABORTED), then flush all bp's in the wait queue with
* the appropriate error, and this will preserve order. Of course, depending
* on the exception we have to show a zero read or write before we show
* errors back to the application.
*/
extern const int st_ndrivetypes; /* defined in st_conf.c */
extern const struct st_drivetype st_drivetypes[];
#ifdef STDEBUG
static int st_soft_error_report_debug = 0;
static int st_debug = 0;
#endif
#define ST_MT02_NAME "Emulex MT02 QIC-11/24 "
static const struct driver_minor_data {
char *name;
int minor;
} st_minor_data[] = {
/*
* The top 4 entries are for the default densities,
* don't alter their position.
*/
{"", 0},
{"n", MT_NOREWIND},
{"b", MT_BSD},
{"l", MT_DENSITY1},
{"m", MT_DENSITY2},
{"h", MT_DENSITY3},
{"c", MT_DENSITY4},
{"u", MT_DENSITY4},
};
/* strings used in many debug and warning messages */
static const char wr_str[] = "write";
static const char rd_str[] = "read";
static const char wrg_str[] = "writing";
static const char rdg_str[] = "reading";
/* default density offsets in the table above */
#define DEF_BLANK 0
#define DEF_NOREWIND 1
#define DEF_BSD 2
#define DEF_BSD_NR 3
static struct tape_failure_code {
} st_tape_failure_code[] = {
{ 0xff}
};
/* clean bit position and mask */
static struct cln_bit_position {
} st_cln_bit_position[] = {
{ 21, 0x08},
{ 70, 0xc0},
{ 18, 0x81} /* 80 bit indicates in bit mode, 1 bit clean light is on */
};
/*
* Configuration Data:
*
* Device driver ops vector
*/
st_open, /* open */
st_close, /* close */
st_strategy, /* strategy */
nodev, /* print */
nodev, /* dump */
st_read, /* read */
st_write, /* write */
st_ioctl, /* ioctl */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
nochpoll, /* poll */
ddi_prop_op, /* cb_prop_op */
0, /* streamtab */
CB_REV, /* cb_rev */
st_aread, /* async I/O read entry point */
st_awrite /* async I/O write entry point */
};
void **result);
DEVO_REV, /* devo_rev, */
0, /* refcnt */
stinfo, /* info */
nulldev, /* identify */
st_probe, /* probe */
st_attach, /* attach */
st_detach, /* detach */
nodev, /* reset */
&st_cb_ops, /* driver operations */
(struct bus_ops *)0, /* bus operations */
nulldev /* power */
};
/*
* Local Function Declarations
*/
static int st_get_conf_from_st_dot_conf(struct scsi_tape *, char *,
struct st_drivetype *);
static int st_get_conf_from_st_conf_dot_c(struct scsi_tape *, char *,
struct st_drivetype *);
static int st_get_default_conf(struct scsi_tape *, char *,
struct st_drivetype *);
struct scsi_status *);
static void st_delayed_cv_broadcast(void *arg);
static void st_intr_restart(void *arg);
static void st_start_restart(void *arg);
int page_size);
/*
* routines for I/O in big block size
*/
int alloc_flags);
#endif
/*
*/
static int st_create_errstats(struct scsi_tape *, int);
#ifdef STDEBUG
#endif /* STDEBUG */
#if !defined(lint)
#endif
/*
* autoconfiguration routines.
*/
char _depends_on[] = "misc/scsi";
&mod_driverops, /* Type of module. This one is a driver */
"SCSI tape Driver %I%", /* Name of the module. */
&st_ops /* driver ops */
};
static struct modlinkage modlinkage = {
};
/*
* Notes on Post Reset Behavior in the tape driver:
*
* When the tape drive is opened, the driver attempts to make sure that
* the tape head is positioned exactly where it was left when it was last
* closed provided the medium is not changed. If the tape drive is
* opened in O_NDELAY mode, the repositioning (if necessary for any loss
* of position due to reset) will happen when the first tape operation or
* I/O occurs. The repositioning (if required) may not be possible under
* certain situations such as when the device firmware not able to report
* the medium change in the REQUEST SENSE data because of a reset or a
* misbehaving bus not allowing the reposition to happen. In such
* extraordinary situations, where the driver fails to position the head
* at its original position, it will fail the open the first time, to
* save the applications from overwriting the data. All further attempts
* to open the tape device will result in the driver attempting to load
* the tape at BOT (beginning of tape). Also a warning message to
* indicate that further attempts to open the tape device may result in
* the tape being loaded at BOT will be printed on the console. If the
* tape device is opened in O_NDELAY mode, failure to restore the
* original tape head position, will result in the failure of the first
* tape operation or I/O, Further, the driver will invalidate its
* internal tape position which will necessitate the applications to
* validate the position by using either a tape positioning ioctl (such
* as MTREW) or closing and reopening the tape device.
*
*/
int
_init(void)
{
int e;
if (((e = ddi_soft_state_init(&st_state,
sizeof (struct scsi_tape), ST_MAXUNIT)) != 0)) {
return (e);
}
if ((e = mod_install(&modlinkage)) != 0) {
}
return (e);
}
int
_fini(void)
{
int e;
if ((e = mod_remove(&modlinkage)) != 0) {
return (e);
}
return (e);
}
int
{
}
static int
{
int instance;
struct scsi_device *devp;
int rval;
#if !defined(__sparc)
char *tape_prop;
int tape_prop_len;
#endif
/* If self identifying device */
return (DDI_PROBE_DONTCARE);
}
#if !defined(__sparc)
/*
* Since some x86 HBAs have devnodes that look like SCSI as
* far as we can tell but aren't really SCSI (DADK, like mlx)
* we check for the presence of the "tape" property.
*/
DDI_PROP_CANSLEEP, "tape",
return (DDI_PROBE_FAILURE);
}
return (DDI_PROBE_FAILURE);
}
#endif
return (DDI_PROBE_PARTIAL);
}
/*
* Turn around and call probe routine to see whether
* we actually have a tape at this SCSI nexus.
*/
/*
* In checking the whole inq_dtype byte we are looking at both
* the Peripheral Qualifier and the Peripheral Device Type.
* For this driver we are only interested in sequential devices
* that are connected or capable if connecting to this logical
* unit.
*/
(DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) {
"probe exists\n");
} else {
}
} else {
"probe failure: nothing there\n");
}
return (rval);
}
static int
{
int instance;
int wide;
int dev_instance;
int ret_status;
struct scsi_device *devp;
int node_ix;
switch (cmd) {
case DDI_ATTACH:
return (DDI_FAILURE);
}
break;
case DDI_RESUME:
/*
*
* When the driver suspended, there might be
* outstanding cmds and therefore we need to
* reset the suspended flag and resume the scsi
* watch thread and restart commands and timeouts
*/
return (DDI_FAILURE);
}
un->un_tids_at_suspend = 0;
if (un->un_swr_token) {
}
/*
* Restart timeouts
*/
un->un_delay_tid =
}
}
/*
* now check if we need to restore the tape position
*/
if ((un->un_suspend_fileno > 0) ||
(un->un_suspend_blkno > 0)) {
if (ret_status != 0) {
/*
* tape didn't get good TUR
* just print out error messages
*/
"st_attach-RESUME: tape failure "
" tape position will be lost");
} else {
/* this prints errors */
(void) st_validate_tapemarks(un,
}
/*
* there are no retries, if there is an error
* we don't know if the tape has changed
*/
un->un_suspend_fileno = 0;
un->un_suspend_blkno = 0;
}
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
"st_attach: instance=%x\n", instance);
/*
* find the drive type for this target
*/
int minor;
char *name;
/*
* For default devices set the density to the
* preferred default density for this device.
*/
if (node_ix <= DEF_BSD_NR) {
}
continue;
}
if (un) {
}
if (un->un_uscsi_rqs_buf) {
}
}
}
return (DDI_FAILURE);
}
/*
* Add a zero-length attribute to tell the world we support
* kernel ioctls (for layered drivers)
*/
DDI_KERNEL_IOCTL, NULL, 0);
/*
* If it's a SCSI-2 tape drive which supports wide,
* tell the host adapter to use wide.
*/
1 : 0;
}
/*
* enable autorequest sense; keep the rq packet around in case
* the autorequest sense fails because of a busy condition
* do a getcap first in case the capability is not variable
*/
} else {
un->un_arq_enabled =
}
/*
* XXX - This is just for 2.6. to tell users that write buffering
* has gone away.
*/
"tape-driver-buffering", 0) != 0) {
"Write Data Buffering has been depricated. Your "
"applications should continue to work normally.\n"
" But, they should ported to use Asynchronous "
" I/O\n"
" For more information, read about "
" tape-driver-buffering "
"property in the st(7d) man page\n");
}
}
un->un_flush_on_errors = 0;
"throttle=%x, max_throttle = %x\n",
/* initialize persistent errors to nil */
un->un_persistence = 0;
un->un_persist_errors = 0;
/*
* Get dma-max from HBA driver. If it is not defined, use 64k
*/
}
/*
* initialize kstats
*/
}
return (DDI_SUCCESS);
}
/*
* st_detach:
*
* we allow a detach if and only if:
* - no tape is currently inserted
* - tape position is at BOT or unknown
* (if it is not at BOT then a no rewind
* device was opened and we have to preserve state)
* - it must be in a closed state : no timeouts or scsi_watch requests
* will exist if it is closed, so we don't need to check for
* them here.
*/
/*ARGSUSED*/
static int
{
int instance;
int dev_instance;
struct scsi_device *devp;
return (DDI_FAILURE);
}
switch (cmd) {
case DDI_DETACH:
/*
* Undo what we did in st_attach & st_doattach,
* freeing resources and removing things we installed.
* The system framework guarantees we are not active
* with this devinfo node in any other entry points at
* this time.
*/
"st_detach: instance=%x, un=%p\n", instance,
(void *)un);
/*
* we cannot unload some targets because the
* inquiry returns junk unless immediately
* after a reset
*/
"cannot unload instance %x\n", instance);
return (DDI_FAILURE);
}
/*
* if the tape has been removed then we may unload;
* do a test unit ready and if it returns NOT READY
* then we assume that it is safe to unload.
* as a side effect, fileno may be set to -1 if the
* the test unit ready fails;
* also un_state may be set to non-closed, so reset it
*/
/*
* Send Test Unit Ready in the hopes that if
* the drive is not in the state we think it is.
* And the state will be changed so it can be detached.
* If the command fails to reach the device and
* the drive was not rewound or unloaded we want
* to fail the detach till a user command fails
* where after the detach will succead.
*/
0, SYNC_CMD);
/*
* After TUR un_state may be set to non-closed,
* so reset it back.
*/
}
"un_status=%x, fileno=%x, blkno=%lx\n",
/*
* check again:
* if we are not at BOT then it is not safe to unload
*/
"cannot detach: fileno=%x, blkno=%lx\n",
return (DDI_FAILURE);
}
/*
* Just To make sure that we have released the
* tape unit .
*/
}
/*
* now remove other data structures allocated in st_doattach()
*/
"destroying/freeing\n");
if (un->un_hib_tid) {
un->un_hib_tid = 0;
}
if (un->un_delay_tid) {
un->un_delay_tid = 0;
}
}
#endif
}
if (un->un_uscsi_rqs_buf) {
}
}
}
if (un->un_mkr_pkt) {
}
if (un->un_arq_enabled) {
}
if (un->un_dp_size) {
}
}
if (un->un_errstats) {
}
devp = ST_SCSI_DEVP;
return (DDI_SUCCESS);
case DDI_SUSPEND:
/*
*
* To process DDI_SUSPEND, we must do the following:
*
* - check ddi_removing_power to see if power will be turned
* off. if so, return DDI_FAILURE
* - check if we are already suspended,
* if so, return DDI_FAILURE
* - check if device state is CLOSED,
* if not, return DDI_FAILURE.
* - wait until outstanding operations complete
* - save tape state
* - block new operations
* - cancel pending timeouts
*
*/
if (ddi_removing_power(devi))
return (DDI_FAILURE);
/*
* Shouldn't already be suspended, if so return failure
*/
return (DDI_FAILURE);
}
return (DDI_FAILURE);
}
/*
* Wait for all outstanding I/O's to complete
*
* we wait on both ncmds and the wait queue for times
* when we are flushing after persistent errors are
* flagged, which is when ncmds can be 0, and the
* queue can still have I/O's. This way we preserve
* order of biodone's.
*/
wait_cmds_complete) == -1) {
/*
* Time expired then cancel the command
*/
if (un->un_last_throttle) {
un->un_throttle =
}
return (DDI_FAILURE);
} else {
break;
}
}
}
/*
* DDI_SUSPEND says that the system "may" power down, we
* remember the file and block number before rewinding.
* we also need to save state before issuing
* any WRITE_FILE_MARK command.
*/
un->un_suspend_fileno = 0;
un->un_suspend_blkno = 0;
} else {
}
/*
* Issue a zero write file fmk command to tell the drive to
* flush any buffered tape marks
*/
/*
* Because not all tape drives correctly implement buffer
* flushing with the zero write file fmk command, issue a
* synchronous rewind command to force data flushing.
* st_validate_tapemarks() will do a rewind during DDI_RESUME
* anyway.
*/
/* stop any new operations */
un->un_throttle = 0;
/*
* cancel any outstanding timeouts
*/
if (un->un_delay_tid) {
un->un_delay_tid = 0;
}
if (un->un_hib_tid) {
un->un_hib_tid = 0;
}
/*
* Suspend the scsi_watch_thread
*/
if (un->un_swr_token) {
} else {
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
/* ARGSUSED */
static int
{
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
return (DDI_FAILURE);
*result = (void *) ST_DEVINFO;
error = DDI_SUCCESS;
break;
case DDI_INFO_DEVT2INSTANCE:
error = DDI_SUCCESS;
break;
default:
error = DDI_FAILURE;
}
return (error);
}
static int
{
int instance;
/*
* Call the routine scsi_probe to do some of the dirty work.
* If the INQUIRY command succeeds, the field sd_inq in the
* device structure will be filled in.
*/
"st_doattach(): probing\n");
/*
* In checking the whole inq_dtype byte we are looking at both
* the Peripheral Qualifier and the Peripheral Device Type.
* For this driver we are only interested in sequential devices
* that are connected or capable if connecting to this logical
* unit.
*/
(DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) {
"probe exists\n");
} else {
/* Something there but not a tape device */
return (DDI_FAILURE);
}
} else {
/* Nothing there */
"probe failure: nothing there\n");
return (DDI_FAILURE);
}
if (!bp) {
goto error;
}
if (!rqpkt) {
goto error;
}
SCMD_REQUEST_SENSE, 0, SENSE_LENGTH, 0);
/*
* The actual unit is present.
* Now is the time to fill in the rest of our info..
*/
goto error;
}
}
"probe partial failure: no space\n");
goto error;
}
#endif
/* Initialize power managemnet condition variable */
un->un_suspend_fileno = 0;
un->un_suspend_blkno = 0;
"allocation of contiguous memory dma handle failed!");
goto error;
}
#endif
/*
* Since this driver manages devices with "remote" hardware,
* i.e. the devices themselves have no "reg" properties,
* called by the power management framework unless we request
* it by creating a "pm-hardware-state" property and setting it
* to value "needs-suspend-resume".
*/
"pm-hardware-state", "needs-suspend-resume") !=
"ddi_prop_update(\"pm-hardware-state\") failed\n");
goto error;
}
"ddi_prop_create(\"no-involuntary-power-cycles\") "
"failed\n");
goto error;
}
return (DDI_SUCCESS);
if (un) {
}
}
if (un->un_uscsi_rqs_buf) {
}
}
#endif
}
if (rqpkt) {
}
if (bp) {
}
}
return (DDI_FAILURE);
}
typedef int
static cfg_functp config_functs[] = {
};
/*
* determine tape type, using tape-config-list or built-in table or
* use a generic tape config entry
*/
static void
{
struct st_drivetype *dp;
/*
* XXX: Emulex MT-02 (and emulators) predates SCSI-1 and has
* no vid & pid inquiry data. So, we provide one.
*/
if (ST_INQUIRY->inq_len == 0 ||
}
/*
* Loop through the configuration methods till one works.
*/
break;
}
}
/*
* If we didn't just make up this configuration and
* all the density codes are the same..
* Set Auto Density over ride.
*/
if (*config_funct != st_get_default_conf) {
/*
* If this device is one that is configured and all
* densities are the same, This saves doing gets and set
* that yield nothing.
*/
}
}
/*
* Store tape drive characteristics.
*/
/* setup operation time-outs based on options */
/* make sure if we are supposed to be variable, make it variable */
}
}
typedef struct {
int mask;
int bottom;
int top;
char *name;
} conf_limit;
static const conf_limit conf_limits[] = {
-1, 1, 2, "conf version",
-1, 0, 0xffffff, "block size",
-1, 0, 4, "number of densities",
-1, 0, 3, "default density",
0, 0, 0, NULL
};
static int
const char *conf_name)
{
int dens;
int ndens;
int value;
int type;
int count;
"%s %s value invalid bits set: 0x%X\n",
"%s %s value too low: value = %d limit %d\n",
"%s %s value too high: value = %d limit %d\n",
} else {
"%s %s value = 0x%X\n",
}
/* If not the number of densities continue */
continue;
}
/* If number of densities is not in range can't use config */
return (-1);
}
"%s conf version 1 with %d densities has %d items"
" should have %d",
"%s conf version 2 with %d densities has %d items"
" should have %d",
}
limit++;
count--;
list++;
"%s density[%d] value too low: value ="
" 0x%X limit 0x%X\n",
"%s density[%d] value too high: value ="
" 0x%X limit 0x%X\n",
} else {
"%s density[%d] value = 0x%X\n",
}
}
}
return (0);
}
static int
struct st_drivetype *dp)
{
int *data_ptr;
int version;
int found = 0;
/*
* Determine type of tape controller. Type is determined by
* checking the vendor ids of the earlier inquiry command and
* comparing those with vids in tape-config-list defined in st.conf
*/
!= DDI_PROP_SUCCESS) {
return (found);
}
"st_get_conf_from_st_dot_conf(): st.conf has tape-config-list\n");
/*
* Compare vids in each triplet - if it matches, get value for
* data_name and contruct a st_drivetype struct
* tripletlen is not set yet!
*/
len > 0;
if (vidlen == 0) {
continue;
}
/*
* If inquiry vid dosen't match this triplets vid,
* try the next.
*/
continue;
}
/*
* if prettylen is zero then use the vid string
*/
if (prettylen == 0) {
}
"vid = %s, pretty=%s, dataname = %s\n",
/*
* get the data list
*/
&data_list_len) != DDI_PROP_SUCCESS) {
/*
* Error in getting property value
* print warning!
*/
"data property (%s) has no value\n",
continue;
}
/*
* now initialize the st_drivetype struct
*/
/*
* check if data is enough for version, type,
* bsize, options, # of densities, density1,
* density2, ..., default_density
*/
if ((data_list_len < 5 * sizeof (int)) ||
(data_list_len < 6 * sizeof (int) +
*(data_ptr + 4) * sizeof (int))) {
/*
* print warning and skip to next triplet.
*/
"data property (%s) incomplete\n",
continue;
}
data_list_len / sizeof (int), datanameptr)) {
"data property (%s) rejected\n",
continue;
}
/*
* check version
*/
/* print warning but accept it */
"Version # for data property (%s) "
"not set to 1 or 2\n", datanameptr);
}
for (i = 0; i < NDENSITIES; i++) {
if (i < len) {
}
}
if (version == 2 &&
data_ptr++;
}
found = 1;
"found in st.conf: vid = %s, pretty=%s\n",
break;
}
/*
* free up the memory allocated by ddi_getlongprop
*/
if (config_list) {
}
return (found);
}
static int
struct st_drivetype *dp)
{
int i;
/*
* Determine type of tape controller. Type is determined by
* checking the result of the earlier inquiry command and
* comparing vendor ids with strings in a table declared in st_conf.c.
*/
"st_get_conf_from_st_conf_dot_c(): looking at st_drivetypes\n");
for (i = 0; i < st_ndrivetypes; i++) {
if (st_drivetypes[i].length == 0) {
continue;
}
st_drivetypes[i].length)) {
continue;
}
return (1);
}
return (0);
}
static int
{
int i;
"st_get_default_conf(): making drivetype from INQ cmd\n");
/*
* Make up a name
*/
/*
* 'clean' vendor and product strings of non-printing chars
*/
for (i = 0; i < ST_NAMESIZE - 2; i++) {
}
}
return (1); /* Can Not Fail */
}
/*
* Regular Unix Entry points
*/
/* ARGSUSED */
static int
{
int rval = 0;
/*
* validate that we are addressing a sensible unit
*/
#ifdef STDEBUG
"st_open(node = %s dev = 0x%lx, flag = %d, otyp = %d)\n",
#endif
/*
* All device accesss go thru st_strategy() where we check
* suspend status
*/
if (!un->un_attached) {
if (!un->un_attached) {
goto exit;
}
}
/*
* Check for the case of the tape in the middle of closing.
* This isn't simply a check of the current state, because
* we could be in state of sensing with the previous state
* that of closing.
*
* And don't allow multiple opens.
*/
while (IS_CLOSING(un) ||
goto exit;
}
}
goto busy;
}
/*
* record current dev
*/
un->un_restore_pos = 0;
un->un_rqs_state = 0;
/*
* If we are opening O_NDELAY, or O_NONBLOCK, we don't check for
* anything, leave internal states alone, if fileno >= 0
*/
} else {
/*
* set un_read_only/write-protect status.
*
* If the tape is not bot we can assume
* that mspl->wp_status is set properly.
* else
* again to get the actual tape status.(since
* user might have replaced the tape)
* Hence make the st state OFFLINE so that
* we re-intialize the tape once again.
*/
un->un_read_only =
} else {
}
}
rval = 0;
} else {
/*
* then call st_tape_reservation_init().
*/
if (ST_RESERVE_SUPPORTED(un)) {
if (rval) {
goto exit;
}
}
if (rval) {
/*
* Release the tape unit, if no preserve reserve
*/
if ((ST_RESERVE_SUPPORTED(un)) &&
}
} else {
}
}
exit:
/*
* we don't want any uninvited guests scrogging our data when we're
* busy with something, so for successful opens or failed opens
* (except for EBUSY), reset these counters and state appropriately.
*/
if (rval) {
}
un->un_err_resid = 0;
un->un_retry_ct = 0;
un->un_tran_retry_ct = 0;
}
busy:
return (rval);
}
#define ST_LOST_RESERVE_BETWEEN_OPENS \
int
{
int rval = 0;
"st_tape_reservation_init(dev = 0x%lx)\n", dev);
/*
* Issue a Throw-Away reserve command to clear the
* check condition.
* hold reservation across opens , and if a Bus reset
* has been issued between opens then this command
* would set the ST_LOST_RESERVE flags in rsvd_status.
* In this case return an EACCES so that user knows that
* reservation has been lost in between opens.
* If this error is not returned and we continue with
* successful open , then user may think position of the
* tape is still the same but inreality we would rewind the
* tape and continue from BOT.
*/
if (rval) {
un->un_rsvd_status &=
~(ST_LOST_RESERVE | ST_RESERVE);
return (EACCES);
}
}
if (rval == 0)
return (rval);
}
static int
{
int err;
int rval = 0;
/*
* Clean up after any errors left by 'last' close.
* This also handles the case of the initial open.
*/
}
un->un_kbytes_xferred = 0;
/*
* do a throw away TUR to clear check condition
*/
/*
* If test unit ready fails because the drive is reserved
* by another host fail the open for no access.
*/
if (err) {
"st_tape_init: RESERVATION CONFLICT\n");
goto exit;
}
}
/*
* See whether this is a generic device that we haven't figured
* anything out about yet.
*/
if (st_determine_generic(dev)) {
"st_open: EIO invalid type\n");
goto exit;
}
/*
* If this is a Unknown Type drive,
* Use the READ BLOCK LIMITS to determine if
* allow large xfer is approprate if not globally
* disabled with st_allow_large_xfer.
*/
} else {
/*
* If we allow_large_xfer (ie >64k) and have not yet found out
* the max block size supported by the drive,
* find it by issueing a READ_BLKLIM command.
* if READ_BLKLIM cmd fails, assume drive doesn't
*/
}
/*
* if maxbsize is unknown, set the maximum block size.
*/
/*
* Get the Block limits of the tape drive.
* if un->un_allow_large_xfer = 0 , then make sure
* that maxbsize is <= ST_MAXRECSIZE_FIXED.
*/
if (err) {
/* Retry */
}
if (!err) {
/*
* if cmd successful, use limit returned
*/
if ((un->un_maxbsize == 0) ||
(un->un_allow_large_xfer == 0 &&
/*
* Drive is not one that is configured, But the
* READ BLOCK LIMITS tells us it can do large
* xfers.
*/
}
/*
* If max and mimimum block limits are the
* same this is a fixed block size device.
*/
}
}
if (un->un_minbsize == 0) {
}
} else { /* error on read block limits */
"!st_tape_init: Error on READ BLOCK LIMITS,"
" errno = %d un_rsvd_status = 0x%X\n",
/*
* since read block limits cmd failed,
* do not allow large xfers.
* use old values in st_minphys
*/
} else {
un->un_allow_large_xfer = 0;
"!Disabling large transfers\n");
/*
* we guess maxbsize and minbsize
*/
} else {
}
/*
* Data Mod must be set,
* Even if read block limits fails.
* Prevents Divide By Zero in st_rw().
*/
}
}
}
if (rval) {
goto exit;
}
}
"maxdma = %d, maxbsize = %d, minbsize = %d, %s large xfer\n",
if (err != 0) {
goto exit;
}
/*
* Make sure the tape is ready
*/
/*
* allow open no media. Subsequent MTIOCSTATE
* with media present will complete the open
* logic.
*/
rval = 0;
goto exit;
} else {
"st_open EIO no media, not opened O_NONBLOCK|O_EXCL\n");
goto exit;
}
}
}
/*
* On each open, initialize block size from drivetype struct,
* as it could have been changed by MTSRSZ ioctl.
* Now, ST_VARIABLE simply means drive is capable of variable
* mode. All drives are assumed to support fixed records.
* Hence, un_bsize tells what mode the drive is in.
* un_bsize = 0 - variable record length
* = x - fixed record length is x
*/
if (un->un_restore_pos) {
un->un_save_blkno) != 0) {
un->un_restore_pos = 0;
goto exit;
}
un->un_restore_pos = 0;
}
"st_open : EIO can't open tape\n");
goto exit;
}
/*
* do a mode sense to pick up state of current write-protect,
*/
(void) st_modesense(un);
/*
* If we are opening the tape for writing, check
* to make sure that the tape can be written.
*/
err = 0;
goto exit;
} else {
un->un_read_only = 0;
}
} else {
}
/*
* If we're opening the tape write-only, we need to
* write 2 filemarks on the HP 1/2 inch drive, to
* create a null file.
*/
} else {
un->un_fmneeded = 0;
}
/*
* Make sure the density can be selected correctly.
*/
"st_open: EIO can't determine density\n");
goto exit;
}
/*
* Destroy the knowledge that we have 'determined'
* density so that a later read at BOT comes along
* does the right density determination.
*/
un->un_density_known = 0;
/*
* Okay, the tape is loaded and either at BOT or somewhere past.
* Mark the state such that any I/O or tape space operations
*/
/*
* Set test append flag if writing.
* First write must check that tape is positioned correctly.
*/
exit:
un->un_err_resid = 0;
un->un_last_resid = 0;
un->un_last_count = 0;
"st_tape_init: return val = %x\n", rval);
return (rval);
}
/* ARGSUSED */
static int
{
int err = 0;
#endif
/*
* wait till all cmds in the pipeline have been completed
*/
/* turn off persistent errors on close, as we want close to succeed */
/*
* set state to indicate that we are in process of closing
*/
/*
* BSD behavior:
* a close always causes a silent span to the next file if we've hit
* an EOF (but not yet read across it).
*/
}
}
/*
* rewinding?
*/
/*
* SVR4 behavior for skipping to next file:
*
* If we have not seen a filemark, space to the next file
*
* If we have already seen the filemark we are physically in the next
* file and we only increment the filenumber
*/
case ST_NO_EOF:
/*
* if we were reading and did not read the complete file
* skip to the next file, leaving the tape correctly
* positioned to read the first record of the next file
* Check first for REEL if we are at EOT by trying to
* read a block
*/
"st_close : EIO can't space\n");
break;
}
break;
}
}
"st_close: EIO can't space #2\n");
} else {
"st_close2: fileno=%x,blkno=%lx,"
"un_eof=%x\n",
}
break;
case ST_EOF_PENDING:
case ST_EOF:
break;
case ST_EOT:
case ST_EOT_PENDING:
/* nothing to do */
break;
}
}
/*
* For performance reasons (HP 88780), the driver should
* postpone writing the second tape mark until just before a file
* positioning ioctl is issued (e.g., rewind). This means that
* the user must not manually rewind the tape because the tape will
* be missing the second tape mark which marks EOM.
* However, this small performance improvement is not worth the risk.
*/
/*
* We need to back up over the filemark we inadvertently popped
* over doing a read in between the two filemarks that constitute
* logical eot for 1/2" tapes. Note that ST_EOT_PENDING is only
* set while reading.
*
* If we happen to be at physical eot (ST_EOM) (writing case),
* the writing of filemark(s) will clear the ST_EOM state, which
* we don't want, so we save this state and restore it later.
*/
"flag=%x, fmneeded=%x, lastop=%x, eof=%x\n",
if (norew) {
"st_close: EIO can't space #3\n");
} else {
}
} else {
}
/*
* Do we need to write a file mark?
*
* only write filemarks if there are fmks to be written and
* - the last operation was a write
* or:
* - opened for wronly
* - no data was written
*/
/* save ST_EOM state */
/*
* Note that we will write a filemark if we had opened
* the tape write only and no data was written, thus
* creating a null file.
*
* If the user already wrote one, we only have to write 1 more.
* If they wrote two, we don't have to write any.
*/
if (count > 0) {
"st_close : EIO can't wfm\n");
}
SYNC_CMD)) {
"st_close : EIO space fmk(-1)\n");
}
/* fix up block number */
}
}
/*
* If we aren't going to be rewinding, and we were at
* physical eot, restore the state that indicates we
* are at physical eot. Once you have reached physical
* eot, and you close the tape, the only thing you can
* do on the next open is to rewind. Access to trailer
* records is only allowed without closing the device.
*/
if (norew == 0 && was_at_eom)
}
/*
* report soft errors if enabled and available, if we never accessed
* the drive, don't get errors. This will prevent some DAT error
* messages upon LOG SENSE.
*/
(last_state != ST_STATE_OFFLINE)) {
/*
* Make sure we have reserve the tape unit.
* This is the case when we do a O_NDELAY open and
* then do a close without any I/O.
*/
goto error;
}
}
}
/*
* Do we need to rewind? Can we rewind?
*/
/*
* We'd like to rewind with the
* 'immediate' bit set, but this
* causes problems on some drives
* where subsequent opens get a
* 'NOT READY' error condition
* back while the tape is rewinding,
* which is impossible to distinguish
* from the condition of 'no tape loaded'.
*
* Also, for some targets, if you disconnect
* with the 'immediate' bit set, you don't
* actually return right away, i.e., the
* target ignores your request for immediate
* return.
*
* Instead, we'll fire off an async rewind
* command. We'll mark the device as closed,
* and any subsequent open will stall on
* the first TEST_UNIT_READY until the rewind
* completes.
*
*/
goto error;
}
}
if (ST_RESERVE_SUPPORTED(un)) {
} else {
}
}
/*
* eject tape if necessary
*/
if (un->un_eject_tape_on_failure) {
un->un_eject_tape_on_failure = 0;
"st_close : can't unload tape\n");
} else {
"st_close : tape unloaded \n");
}
}
/*
* behaviour.
*/
if (ST_RESERVE_SUPPORTED(un) &&
}
/*
* clear up state
*/
un->un_retry_ct = 0;
un->un_tran_retry_ct = 0;
/* Restore the options to the init time settings */
} else {
}
} else {
}
} else {
}
/*
* Signal anyone awaiting a close operation to complete.
*/
/*
* any kind of error on closing causes all state to be tossed
*/
un->un_density_known = 0;
/*
* note that st_intr has already set un_fileno to -1
*/
}
/*
* free any contiguous mem alloc'ed for big block I/O
*/
while (cp) {
}
}
}
un->un_contig_mem_total_num = 0;
#endif
"st_close3: return val = %x, fileno=%x, blkno=%lx, un_eof=%x\n",
return (err);
}
/*
* These routines perform raw i/o operations.
*/
/* ARGSUSED2 */
static int
{
}
/* ARGSUSED2 */
static int
{
}
/* ARGSUSED */
static int
{
}
/* ARGSUSED */
static int
{
}
/*
* Due to historical reasons, old limits are: For variable-length devices:
* if greater than 64KB - 1 (ST_MAXRECSIZE_VARIABLE), block into 64 KB - 2
* ST_MAXRECSIZE_VARIABLE_LIMIT) requests; otherwise,
* (let it through unmodified. For fixed-length record devices:
* 63K (ST_MAXRECSIZE_FIXED) is max (default minphys).
*
* The new limits used are un_maxdma (retrieved using scsi_ifgetcap()
* from the HBA) and un_maxbsize (retrieved by sending SCMD_READ_BLKLIM
* command to the drive).
*
*/
static void
{
#if !defined(lint)
#endif
"st_minphys(bp = 0x%p): b_bcount = 0x%lx\n", (void *)bp,
if (un->un_allow_large_xfer) {
/*
* check un_maxbsize for variable length devices only
*/
}
/*
* can't go more that HBA maxdma limit in either fixed-length
* or variable-length tape drives.
*/
}
} else {
/*
* use old fixed limits
*/
}
} else {
}
}
}
#if !defined(lint)
#endif /* lint */
/*
* For regular raw I/O and Fixed Block length devices, make sure
* the adjusted block count is a whole multiple of the device
* block size.
*/
}
}
/*ARGSUSED*/
static void
{
/*
* do not break up because the CDB count would then be
* incorrect and create spurious data underrun errors.
*/
}
static int
{
int rval = 0;
long len;
"st_rw(dev = 0x%lx, flag = %s)\n", dev,
/* get local copy of transfer length */
/*
* If in fixed block size mode and requested read or write
* is not an even multiple of that block size.
*/
"%s: not modulo %d block size\n",
}
/* If device has set granularity in the READ_BLKLIM we honor it. */
"%s: not modulo %d device granularity\n",
}
if (rval != 0) {
return (rval);
}
un->un_silent_skip = 0;
/*
* if we have hit logical EOT during this xfer and there is not a
* full residue, then set un_eof back to ST_EOM to make sure that
* the user will see at least one zero write
* after this short write
*/
}
}
}
}
return (rval);
}
static int
{
int rval = 0;
long len;
"st_rw(dev = 0x%lx, flag = %s)\n", dev,
/* get local copy of transfer length */
/*
* If in fixed block size mode and requested read or write
* is not an even multiple of that block size.
*/
"%s: not modulo %d block size\n",
}
/* If device has set granularity in the READ_BLKLIM we honor it. */
"%s: not modulo %d device granularity\n",
}
if (rval != 0) {
return (rval);
}
/*
* if we have hit logical EOT during this xfer and there is not a
* full residue, then set un_eof back to ST_EOM to make sure that
* the user will see at least one zero write
* after this short write
*
* we keep this here just in case the application is not using
* persistent errors
*/
}
}
}
return (rval);
}
static int
{
/*
* validate arguments
*/
goto error;
}
}
"st_strategy(): bcount=0x%lx, fileno=%d, blkno=%lx, eof=%d\n",
/*
* If persistent errors have been flagged, just nix this one. We wait
* for any outstanding I/O's below, so we will be in order.
*/
if (IS_PE_FLAG_SET(un))
goto exit;
int wasopening = 0;
/*
* do it now.
*/
if (ST_RESERVE_SUPPORTED(un)) {
if (st_tape_reservation_init(dev)) {
goto exit;
}
/*
* Enter here to restore position for possible
* resets when the device was closed and opened
* in O_NDELAY mode subsequently
*/
0, SYNC_CMD);
}
}
/*
* If we are offline, we have to initialize everything first.
* This is to handle either when opened with O_NDELAY, or
* we just got a new tape in the drive, after an offline.
* We don't observe O_NDELAY past the open,
* as it will not make sense for tapes.
*/
/* reset state to avoid recursion */
if (st_tape_init(dev)) {
"stioctl : OFFLINE init failure ");
goto b_done_err;
}
}
/*
* Check for legal operations
*/
"strategy with un->un_fileno < 0\n");
goto b_done_err;
}
"st_strategy(): regular io\n");
/*
* Process this first. If we were reading, and we're pending
* logical eot, that means we've bumped one file mark too far.
*/
/*
* Recursion warning: st_cmd will route back through here.
*/
un->un_density_known = 0;
goto b_done_err;
}
}
/*
* If we are in the process of opening, we may have to
* to do a test_append (if QIC) to see whether we are
* in a position to append to the end of the tape.
*
* If we're already at logical eot, we transition
* to ST_NO_EOF. If we're at physical eot, we punt
* to the switch statement below to handle.
*/
goto b_done_err;
}
}
"pending_io@fileno %d rw %d qic %d eof %d\n",
/*
* st_test_append() will do it all
*/
goto done;
}
}
wasopening = 1;
}
}
/*
* Process rest of END OF FILE and END OF TAPE conditions
*/
"un_eof=%x, wasopening=%x\n",
case ST_EOM:
/*
* This allows writes to proceed past physical
* eot. We'll *really* be in trouble if the
* user continues blindly writing data too
* much past this point (unwind the tape).
* Physical eot really means 'early warning
* eot' in this context.
*
* Every other write from now on will succeed
* (if sufficient tape left).
* This write will return with resid == count
* but the next one should be successful
*
* Note that we only transition to logical EOT
* if the last state wasn't the OPENING state.
* We explicitly prohibit running up to physical
* eot, closing the device, and then re-opening
* to proceed. Trailer records may only be gotten
* at by keeping the tape open after hitting eot.
*
* Also note that ST_EOM cannot be set by reading-
* this can only be set during writing. Reading
* up to the end of the tape gets a blank check
* or a double-filemark indication (ST_EOT_PENDING),
* and we prohibit reading after that point.
*
*/
if (wasopening == 0) {
/*
* this allows st_rw() to reset it back to
* ST_EOM to make sure that the application
* will see a zero write
*/
}
goto b_done;
case ST_WRITE_AFTER_EOM:
case ST_EOT:
if (SVR4_BEHAVIOR && reading) {
goto b_done_err;
}
if (reading) {
goto b_done;
}
break;
case ST_EOF_PENDING:
"EOF PENDING\n");
if (SVR4_BEHAVIOR) {
goto b_done;
}
/* FALLTHROUGH */
case ST_EOF:
if (SVR4_BEHAVIOR) {
goto b_done_err;
}
if (BSD_BEHAVIOR) {
}
if (reading) {
"now file %d (read)\n",
goto b_done;
}
break;
default:
break;
}
}
st_bioerror(bp, 0);
SET_BP_PKT(bp, 0);
"st_strategy: cmd=0x%p count=%ld resid=%ld flags=0x%x"
" pkt=0x%p\n",
/*
* We will replace bp with a new bp that can do big blk xfer
* if the requested xfer size is bigger than ST_BIGBLK_XFER
*
* Also, we need to make sure that we're handling real I/O
* by checking group 0/1 SCSI I/O commands, if needed
*/
}
#endif
/* put on wait queue */
"st_strategy: un->un_quef = 0x%p, bp = 0x%p\n",
} else {
}
done:
return (0);
"st_strategy: error exit\n");
return (0);
"st_strategy : EIO b_done_err\n");
"st_strategy: b_done\n");
exit:
/*
* make sure no commands are outstanding or waiting before closing,
* so we can guarantee order
*/
/* override errno here, if persistent errors were flagged */
if (IS_PE_FLAG_SET(un))
return (0);
}
/*
* this routine spaces forward over filemarks
*/
static int
{
int rval = 0;
/*
* the risk with doing only one space operation is that we
* may accidentily jump in old data
* the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
* because the 8200 does not append a marker; in order not to
* sacrifice the fast file skip, we do a slow skip if the low
* density device has been opened
*/
"space_fmks : EIO can't do space cmd #1\n");
}
} else {
while (count > 0) {
"space_fmks : EIO can't do space cmd #2\n");
break;
}
count -= 1;
/*
* read a block to see if we have reached
* end of medium (double filemark for reel or
* medium error for others)
*/
if (count > 0) {
SYNC_CMD)) {
"space_fmks : EIO can't do "
"space cmd #3\n");
break;
}
"space_fmks : EIO ST_REEL\n");
break;
count--;
"space_fmks, EIO > ST_EOF\n");
break;
}
}
}
}
return (rval);
}
/*
* this routine spaces to EOM
*
* it keeps track of the current filenumber and returns the filenumber after
* the last successful space operation, we keep the number high because as
* tapes are getting larger, the possibility of more and more files exist,
* 0x100000 (1 Meg of files) probably will never have to be changed any time
* soon
*/
static int
{
int instance;
return (-1);
/*
* see if the drive is smart enough to do the skips in
* one operation; 1/2" use two filemarks
* the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
* because the 8200 does not append a marker; in order not to
* sacrifice the fast file skip, we do a slow skip if the low
* density device has been opened
*/
} else {
count = 1;
}
/*
* If we're not EOM smart, space a record
* to see whether we're now in the slot between
* the two sequential filemarks that logical
* EOM consists of (REEL) or hit nowhere land
* (8mm).
*/
if (count == 1) {
/*
* no fast skipping, check a record
*/
break;
break;
break;
}
} else {
break;
}
}
}
}
"st_find_eom: %x\n", savefile);
return (savefile);
}
/*
* this routine is frequently used in ioctls below;
* it determines whether we know the density and if not will
* determine it
* if we have written the tape before, one or more filemarks are written
*
* depending on the stepflag, the head is repositioned to where it was before
* the filemarks were written in order not to confuse step counts
*/
#define STEPBACK 0
#define NO_STEPBACK 1
static int
{
"st_check_density_or_wfm(dev= 0x%lx, wfm= %d, mode= %d, stpflg= %d)\n",
/*
* If we don't yet know the density of the tape we have inserted,
* we have to either unconditionally set it (if we're 'writing'),
* or we have to determine it. As side effects, check for any
* write-protect errors, and for the need to put out any file-marks
* before positioning a tape.
*
* If we are going to be spacing forward, and we haven't determined
* the tape density yet, we have to do so now...
*/
"check_density_or_wfm : EIO can't determine "
"density\n");
return (EIO);
}
/*
* Presumably we are at BOT. If we attempt to write, it will
* either work okay, or bomb. We don't do a st_test_append
* unless we're past BOT.
*/
/*
* We need to write one or two filemarks.
* In the case of the HP, we need to
* position the head between the two
* marks.
*/
un->un_fmneeded = 0;
}
un->un_density_known = 0;
"check_density_or_wfm : EIO can't write fm\n");
return (EIO);
}
"check_density_or_wfm : EIO can't space "
"(-wfm)\n");
return (EIO);
}
}
}
/*
* Whatever we do at this point clears the state of the eof flag.
*/
/*
* If writing, let's check that we're positioned correctly
* at the end of tape before issuing the next write.
*/
if (!un->un_read_only) {
}
return (0);
}
/*
* Wait for all outstaning I/O's to complete
*
* we wait on both ncmds and the wait queue for times when we are flushing
* after persistent errors are flagged, which is when ncmds can be 0, and the
* queue can still have I/O's. This way we preserve order of biodone's.
*/
static void
{
}
}
/*
* This routine implements the ioctl calls. It is called
* from the device switch at normal priority.
*/
/*ARGSUSED*/
static int
int *rval_p)
{
"st_ioctl(): fileno=%x, blkno=%lx, un_eof=%x, state = %d, "
"pe_flag = %d\n",
IS_PE_FLAG_SET(un));
/*
* We don't want to block on these, so let them through
* and we don't care about setting driver states here.
*/
if ((cmd == MTIOCGETDRIVETYPE) ||
(cmd == MTIOCGUARANTEEDORDER) ||
(cmd == MTIOCPERSISTENTSTATUS)) {
goto check_commands;
}
/*
* wait for all outstanding commands to complete, or be dequeued.
* And because ioctl's are synchronous commands, any return value
* after this, will be in order
*/
/*
* allow only a through clear errors and persistent status, and
* status
*/
if (IS_PE_FLAG_SET(un)) {
if ((cmd == MTIOCLRERR) ||
(cmd == MTIOCPERSISTENT) ||
(cmd == USCSIGETRQS)) {
goto check_commands;
} else {
goto exit;
}
}
/*
* first and foremost, handle any ST_EOT_PENDING cases.
* That is, if a logical eot is pending notice, notice it.
*/
"stioctl : EIO can't space fmk(-1)\n");
goto exit;
}
if (status == SUN_KEY_EOF) {
} else {
}
}
/*
* now, handle the rest of the situations
*/
switch (cmd) {
case MTIOCGET:
{
#ifdef _MULTI_DATAMODEL
/*
* For use when a 32 bit app makes a call into a
* 64 bit ioctl
*/
struct mtget32 mtg_local32;
#endif /* _MULTI_DATAMODEL */
/* Get tape status */
"st_ioctl: MTIOCGET\n");
} else { /* 1/4" cartridges */
/* Emulex cartridge tape */
case MT_ISMT02:
break;
default:
break;
}
}
/*
* If large transfers are allowed and drive options
* has no record size limit set. Calculate blocking
* factor from the lesser of maxbsize and maxdma.
*/
if ((un->un_allow_large_xfer) &&
}
if (rval == -1) {
goto exit;
} else {
rval = 0;
}
un->un_err_resid = 0;
#ifdef _MULTI_DATAMODEL
case DDI_MODEL_ILP32:
/*
* Convert 64 bit back to 32 bit before doing
* copyout. This is what the ILP32 app expects.
*/
}
break;
case DDI_MODEL_NONE:
}
break;
}
#else /* ! _MULTI_DATAMODE */
}
#endif /* _MULTI_DATAMODE */
break;
}
case MTIOCSTATE:
{
/*
* return when media presence matches state
*/
enum mtio_state state;
"st_ioctl: MTIOCSTATE\n");
if (rval != 0) {
break;
}
sizeof (int), flag))
break;
}
case MTIOCGETDRIVETYPE:
{
#ifdef _MULTI_DATAMODEL
/*
* For use when a 32 bit app makes a call into a
* 64 bit ioctl
*/
struct mtdrivetype_request32 mtdtrq32;
#endif /* _MULTI_DATAMODEL */
/*
* return mtdrivetype
*/
struct mtdrivetype_request mtdtrq;
struct mtdrivetype mtdrtyp;
"st_ioctl: MTIOCGETDRIVETYPE\n");
#ifdef _MULTI_DATAMODEL
case DDI_MODEL_ILP32:
{
sizeof (struct mtdrivetype_request32), flag)) {
break;
}
break;
}
case DDI_MODEL_NONE:
sizeof (struct mtdrivetype_request), flag)) {
break;
}
break;
}
#else /* ! _MULTI_DATAMODEL */
sizeof (struct mtdrivetype_request), flag)) {
break;
}
#endif /* _MULTI_DATAMODEL */
/*
* if requested size is < 0 then return
* error.
*/
break;
}
/*
* Speed hasn't been used since the hayday of reel tape.
* For all drives not setting the option ST_KNOWS_MEDIA
* the speed member renamed to mediatype are zeros.
* Those drives that have ST_KNOWS_MEDIA set use the
* new mediatype member which is used to figure the
* type of media loaded.
*
* So as to not break applications speed in the
* mtdrivetype structure is not renamed.
*/
}
/*
* Limit the maximum length of the result to
* sizeof (struct mtdrivetype).
*/
tmp = sizeof (struct mtdrivetype);
}
break;
}
case MTIOCPERSISTENT:
{
int persistence = 0;
sizeof (int), flag)) {
break;
}
/* non zero sets it, only 0 turns it off */
if (un->un_persistence)
TURN_PE_ON(un);
else
"st_ioctl: MTIOCPERSISTENT : persistence = %d\n",
un->un_persistence);
break;
}
case MTIOCPERSISTENTSTATUS:
{
sizeof (int), flag)) {
}
"st_ioctl: MTIOCPERSISTENTSTATUS:persistece = %d\n",
un->un_persistence);
break;
}
case MTIOCLRERR:
{
/* clear persistent errors */
"st_ioctl: MTIOCLRERR\n");
break;
}
case MTIOCGUARANTEEDORDER:
{
/*
* this is just a holder to make a valid ioctl and
* it won't be in any earlier release
*/
"st_ioctl: MTIOCGUARANTEEDORDER\n");
break;
}
case MTIOCRESERVE:
{
"st_ioctl: MTIOCRESERVE\n");
/*
*/
if (!(ST_RESERVE_SUPPORTED(un))) {
break;
}
if (rval == 0) {
}
break;
}
case MTIOCRELEASE:
{
"st_ioctl: MTIOCRELEASE\n");
/*
*/
if (!(ST_RESERVE_SUPPORTED(un))) {
break;
}
break;
}
case MTIOCFORCERESERVE:
{
"st_ioctl: MTIOCFORCERESERVE\n");
/*
*/
if (!(ST_RESERVE_SUPPORTED(un))) {
break;
}
/*
* allow only super user to run this.
*/
break;
}
/*
* Throw away reserve,
* not using test-unit-ready
* since reserve can succeed without tape being
* present in the drive.
*/
break;
}
case USCSIGETRQS:
{
#ifdef _MULTI_DATAMODEL
/*
* For use when a 32 bit app makes a call into a
* 64 bit ioctl
*/
struct uscsi_rqs32 urqs_32;
#endif /* _MULTI_DATAMODEL */
#ifdef _MULTI_DATAMODEL
case DDI_MODEL_ILP32:
{
sizeof (struct uscsi_rqs32), flag)) {
break;
}
break;
}
case DDI_MODEL_NONE:
break;
}
}
#else /* ! _MULTI_DATAMODEL */
break;
}
#endif /* _MULTI_DATAMODEL */
(ST_RQS_OVR | ST_RQS_VALID);
} else {
len = SENSE_LENGTH;
- SENSE_LENGTH;
}
}
#ifdef _MULTI_DATAMODEL
case DDI_MODEL_ILP32:
}
break;
case DDI_MODEL_NONE:
flag)) {
}
break;
}
}
}
#else /* ! _MULTI_DATAMODEL */
}
}
}
#endif /* _MULTI_DATAMODEL */
break;
}
case USCSICMD:
{
#ifdef _MULTI_DATAMODEL
/*
* For use when a 32 bit app makes a call into a
* 64 bit ioctl
*/
struct uscsi_cmd32 ucmd_32;
#endif /* _MULTI_DATAMODEL */
/*
* Run a generic USCSI command
*/
"st_ioctl: USCSICMD\n");
cr = ddi_get_cred();
break;
}
#ifdef _MULTI_DATAMODEL
case DDI_MODEL_ILP32:
{
sizeof (struct uscsi_cmd32), flag)) {
break;
}
break;
}
case DDI_MODEL_NONE:
flag)) {
break;
}
}
#else /* ! _MULTI_DATAMODEL */
break;
}
#endif /* _MULTI_DATAMODEL */
/*
* tape unit do it now.
*/
if (ST_RESERVE_SUPPORTED(un) &&
goto exit;
}
/*
* although st_ioctl_cmd() never makes use of these
* now, we are just being safe and consistent
*/
#ifdef _MULTI_DATAMODEL
case DDI_MODEL_ILP32:
/*
* Convert 64 bit back to 32 bit before doing
* copyout. This is what the ILP32 app expects.
*/
if (rval != 0)
}
break;
case DDI_MODEL_NONE:
if (rval != 0)
}
break;
}
#else /* ! _MULTI_DATAMODEL */
if (rval != 0)
}
#endif /* _MULTI_DATAMODEL */
break;
}
case MTIOCTOP:
"st_ioctl: MTIOCTOP\n");
break;
case MTIOCREADIGNOREILI:
{
int set_ili;
break;
}
break;
}
switch (set_ili) {
case 0:
break;
case 1:
break;
default:
break;
}
break;
}
case MTIOCREADIGNOREEOFS:
{
int ignore_eof;
sizeof (ignore_eof), flag)) {
break;
}
break;
}
switch (ignore_eof) {
case 0:
break;
case 1:
break;
default:
break;
}
break;
}
case MTIOCSHORTFMK:
{
int short_fmk;
break;
}
case ST_TYPE_EXB8500:
case ST_TYPE_EXABYTE:
if (!short_fmk) {
} else if (short_fmk == 1) {
} else {
}
break;
default:
break;
}
break;
}
default:
"st_ioctl: unknown ioctl\n");
}
exit:
if (!IS_PE_FLAG_SET(un))
return (rval);
}
/*
* do some MTIOCTOP tape operations
*/
static int
{
#ifdef _MULTI_DATAMODEL
/*
* For use when a 32 bit app makes a call into a
* 64 bit ioctl
*/
struct mtop32 mtop_32_for_64;
#endif /* _MULTI_DATAMODEL */
#ifdef _MULTI_DATAMODEL
case DDI_MODEL_ILP32:
{
return (EFAULT);
}
break;
}
case DDI_MODEL_NONE:
return (EFAULT);
}
break;
}
#else /* ! _MULTI_DATAMODEL */
return (EFAULT);
}
#endif /* _MULTI_DATAMODEL */
rval = 0;
/*
* do it now.
*/
if (ST_RESERVE_SUPPORTED(un) &&
return (rval);
}
/*
* if we are going to mess with a tape, we have to make sure we have
* one and are not offline (i.e. no tape is initialized). We let
* commands pass here that don't actually touch the tape, except for
* loading and initialization (rewinding).
*/
case MTLOAD:
case MTNOP:
/*
* We don't want strategy calling st_tape_init here,
* so, change state
*/
"st_mtioctop : OFFLINE state = %d\n",
break;
default:
/*
* reinitialize by normal means
*/
if (st_tape_init(dev)) {
"st_mtioctop : OFFLINE init failure ");
return (EIO);
}
break;
}
}
/*
* If the file position is invalid, allow only those
* commands that properly position the tape and fail
* the rest with EIO
*/
case MTWEOF:
case MTRETEN:
case MTERASE:
case MTEOM:
case MTFSF:
case MTFSR:
case MTBSF:
case MTNBSF:
case MTBSR:
case MTSRSZ:
case MTGRSZ:
return (EIO);
/* NOTREACHED */
case MTREW:
case MTLOAD:
case MTOFFL:
case MTNOP:
break;
default:
return (ENOTTY);
/* NOTREACHED */
}
}
case MTERASE:
/*
* MTERASE rewinds the tape, erase it completely, and returns
* to the beginning of the tape
*/
return (EACCES);
}
"st_mtioctop : EIO space or erase or check den)\n");
} else {
/* QIC and helical scan rewind after erase */
}
}
break;
case MTWEOF:
/*
* write an end-of-file record
*/
return (EACCES);
}
/*
* zero count means just flush buffers
* negative count is not permitted
*/
return (EINVAL);
if (!un->un_read_only) {
}
"st_mtioctop : EIO : MTWEOF can't determine"
"density");
return (EIO);
}
}
/*
* Failure due to something other than illegal
* request results in loss of state (st_intr).
*/
"st_mtioctop : EIO : MTWEOF can't write file mark");
}
break;
case MTRETEN:
/*
* retension the tape
*/
"st_mtioctop : EIO : MTRETEN ");
}
break;
case MTREW:
/*
* rewind the tape
*/
return (EIO);
}
"st_mtioctop : EIO : MTREW ");
}
break;
case MTOFFL:
/*
* rewinds, and, if appropriate, takes the device offline by
* unloading the tape
*/
return (EIO);
}
"st_mtioctop : EIO : MTOFFL");
return (EIO);
}
break;
case MTLOAD:
/*
* This is to load a tape into the drive
* Note that if the tape is not loaded, the device will have
* to be opened via O_NDELAY or O_NONBLOCK.
*/
/*
* Let's try and clean things up, if we are not
* initializing, and then send in the load command, no
* matter what.
*
* we try the load twice because some drives fail the first
* load after a media change by the user.
*/
"st_mtioctop : EIO : MTLOAD\n");
/*
* If load tape fails, who knows what happened...
*/
break;
}
/*
* reset all counters appropriately using rewind, as if LOAD
* succeeds, we are at BOT
*/
if (st_tape_init(dev)) {
"st_mtioctop : EIO : MTLOAD calls st_tape_init\n");
}
break;
case MTNOP:
un->un_err_resid = 0;
break;
case MTEOM:
/*
* positions the tape at a location just after the last file
* written on the tape. For cartridge and 8 mm, this after
* the last file mark; for reel, this is inbetween the two
* last 2 file marks
*/
/*
* If the command wants to move to logical end
* of media, and we're already there, we're done.
* If we were at logical eot, we reset the state
* to be *not* at logical eot.
*
* If we're at physical or logical eot, we prohibit
* forward space operations (unconditionally).
*
* Also if the last operation was a write of any
* kind the tape is at EOD.
*/
return (0);
}
/*
* physical tape position may not be what we've been
* telling the user; adjust the request accordingly
*/
}
return (EIO);
}
/*
* st_find_eom() returns the last fileno we knew about;
*/
"st_mtioctop : EIO : MTEOM status check failed");
} else {
/*
* For 1/2" reel tapes assume logical EOT marked
* by two file marks or we don't care that we may
* be extending the last file on the tape.
*/
SYNC_CMD)) {
"st_mtioctop : EIO : MTEOM space "
"cmd failed");
break;
}
/*
* Fix up the block number.
*/
un->un_err_blkno = 0;
}
un->un_err_resid = 0;
}
break;
case MTFSF:
/*
* forward space over filemark
*
* For ASF we allow a count of 0 on fsf which means
* we just want to go to beginning of current file.
* Equivalent to "nbsf(0)" or "bsf(1) + fsf".
* Allow stepping over double fmk with reel
*/
/* we're at EOM */
"st_mtioctop : EIO : MTFSF at EOM");
return (EIO);
}
/*
* physical tape position may not be what we've been
* telling the user; adjust the request accordingly
*/
/*
* For positive direction case, we're now covered.
* For zero or negative direction, we're covered
* (almost)
*/
}
return (EIO);
}
/*
* Forward space file marks.
* We leave ourselves at block zero
* of the target file number.
*/
goto bspace;
}
un->un_err_resid = 0;
break;
SYNC_CMD) ||
} else {
SYNC_CMD));
}
if (rval != 0) {
"st_mtioctop : EIO : fspace fileno = -1");
}
} else {
}
/*
* we came here with a count < 0; we now need
* to skip back to end up before the filemark
*/
goto bspace;
}
break;
case MTFSR:
/*
* forward space to inter-record gap
*
*/
/* we're at EOM */
"st_mtioctop : EIO : MTFSR un_eof > ST_EOT");
return (EIO);
}
un->un_err_resid = 0;
}
return (0);
}
/*
* physical tape position may not be what we've been
* telling the user; adjust the position accordingly
*/
== -1) {
"st_mtioctop : EIO :MTFSR count && IN_EOF");
return (EIO);
}
}
"st_mtioctop : EIO : MTFSR st_check_den");
return (EIO);
}
un->un_err_resid = 0;
break;
/*
* If we're spacing forward, or the device can
* backspace records, we can just use the SPACE
* command.
*/
"st_mtioctop :EIO:space_records can't spc");
/*
*/
/*
* we skipped over a filemark
* and need to go forward again
*/
SYNC_CMD)) {
"st_mtioctop : EIO : "
"space_records can't "
"space #2");
}
}
if (rval == 0) {
"st_mtioctop : EIO : space_rec rval"
" == 0");
}
}
} else {
/*
* else we rewind, space forward across filemarks to
* the desired file, and then space records to the
* desired block.
*/
if (tmp < 0) {
/*
* Wups - we're backing up over a filemark
*/
}
"st_mtioctop :EIO:space_records : tmp < 0");
SYNC_CMD)) {
"st_mtioctop : EIO :space_records : rewind "
"and space failed");
}
}
break;
case MTBSF:
/*
* backward space of file filemark (1/2" and 8mm)
* tape position will end on the beginning of tape side
* of the desired file mark
*/
return (ENOTTY);
}
/*
* If a negative count (which implies a forward space op)
* is specified, and we're at logical or physical eot,
* bounce the request.
*/
"st_ioctl : EIO : MTBSF : un_eof > ST_EOF");
return (EIO);
}
/*
* physical tape position may not be what we've been
* telling the user; adjust the request accordingly
*/
"bsf in eof: count=%ld, op=%x\n",
}
"st_ioctl : EIO : MTBSF : check den wfm");
return (EIO);
}
/*
* for a negative count, we need to step forward
* first and then step back again
*/
goto fspace;
}
{
int skip_cnt, end_at_eof;
/*
* Backspace files (MTNBSF):
*
* For tapes that can backspace, backspace
* count+1 filemarks and then run forward over
* a filemark
*
* For tapes that can't backspace,
* calculate desired filenumber
* (un->un_fileno - count), rewind,
* and then space forward this amount
*
* Backspace filemarks (MTBSF)
*
* For tapes that can backspace, backspace count
* filemarks
*
* For tapes that can't backspace, calculate
* desired filenumber (un->un_fileno - count),
* add 1, rewind, space forward this amount,
* and mark state as ST_EOF_PENDING appropriately.
*/
end_at_eof = 1;
} else {
end_at_eof = 0;
}
"bspace: mt_op=%x, count=%lx, fileno=%x, blkno=%lx\n",
/*
* Handle the simple case of BOT
* playing a role in these cmds.
* We do this by calculating the
* ending file number. If the ending
* file is < BOT, rewind and set an
* error and mark resid appropriately.
* If we're backspacing a file (not a
* filemark) and the target file is
* the first file on the tape, just
* rewind.
*/
"st_ioctl : EIO : bspace : end_at_eof && "
"tmp < 0");
}
if (tmp < 0) {
"st_ioctl : EIO : bspace : tmp < 0");
}
break;
}
/*
* If we are going to end up at the beginning
* of the file, we have to space one extra file
* first, and then space forward later.
*/
"st_ioctl : EIO : bspace : can't space "
"tmp");
}
} else {
} else {
}
}
/*
* If we have to space forward, do so...
*/
"st_ioctl : EIO : bspace : can't space "
"skip_cnt");
} else if (end_at_eof) {
/*
* If we had to space forward, and we're
* not a tape that can backspace, mark state
* as if we'd just seen a filemark during a
* a read.
*/
}
}
}
if (rval != 0) {
}
break;
}
case MTNBSF:
/*
* backward space file to beginning of file
*
* If a negative count (which implies a forward space op)
* is specified, and we're at logical or physical eot,
* bounce the request.
*/
"st_ioctl : EIO : > EOT and count < 0");
return (EIO);
}
/*
* physical tape position may not be what we've been
* telling the user; adjust the request accordingly
*/
}
"st_ioctl : EIO : MTNBSF check den and wfm");
return (EIO);
}
goto fspace;
}
goto bspace;
case MTBSR:
/*
* backward space into inter-record gap
*
* If a negative count (which implies a forward space op)
* is specified, and we're at logical or physical eot,
* bounce the request.
*/
"st_ioctl : EIO : MTBSR > EOT");
return (EIO);
}
un->un_err_resid = 0;
}
return (0);
}
/*
* physical tape position may not be what we've been
* telling the user; adjust the position accordingly.
* bsr can not skip filemarks and continue to skip records
* therefore if we are logically before the filemark but
* physically at the EOT side of the filemark, we need to step
* back; this allows fsr N where N > number of blocks in file
* followed by bsr 1 to position at the beginning of last block
*/
== -1) {
"st_write_fm : EIO : MTBSR can't space");
return (EIO);
}
}
"st_ioctl : EIO : MTBSR : can't set density or "
"wfm");
return (EIO);
}
goto space_records;
case MTSRSZ:
/*
* Set record-size to that sent by user
* Check to see if there is reason that the requested
* block size should not be set.
*/
/* If requesting variable block size is it ok? */
return (ENOTTY);
}
/*
* If requested block size is not variable "0",
* is it less then minimum.
*/
return (EINVAL);
}
/* Is the requested block size more then maximum */
(un->un_maxbsize != 0)) {
return (EINVAL);
}
/* Is requested block size a modulus the device likes */
return (EINVAL);
}
"st_ioctl : MTSRSZ : EIO : cant set block size");
return (EIO);
}
return (0);
case MTGRSZ:
{
#ifdef _MULTI_DATAMODEL
/*
* For use when a 32 bit app makes a call into a
* 64 bit ioctl
*/
struct mtop32 mtop_32_for_64;
#endif /* _MULTI_DATAMODEL */
/*
* Get record-size to the user
*/
#ifdef _MULTI_DATAMODEL
case DDI_MODEL_ILP32:
/*
* Convert 64 bit back to 32 bit before doing
* copyout. This is what the ILP32 app expects.
*/
return (EFAULT);
}
break;
case DDI_MODEL_NONE:
return (EFAULT);
}
break;
}
#else /* ! _MULTI_DATAMODE */
return (EFAULT);
#endif /* _MULTI_DATAMODE */
return (0);
}
default:
}
un->un_density_known = 0;
}
return (rval);
}
/*
* Run a command for uscsi ioctl.
* cdbspace is address space of cdb.
* dataspace is address space of the uscsi data buffer.
*/
static int
enum uio_seg rqbufspace)
{
int flag;
int err;
int rqlen;
int offline_state = 0;
"st_ioctl_cmd(dev = 0x%lx)\n", dev);
/*
* We really don't know what commands are coming in here and
* we don't want to limit the commands coming in.
*
* If st_tape_init() gets called from st_strategy(), then we
* will hang the process waiting for un->un_sbuf_busy to be cleared,
* which it never will, as we set it below. To prevent
* st_tape_init() from getting called, we have to set state to other
* than ST_STATE_OFFLINE, so we choose ST_STATE_INITIALIZING, which
* achieves this purpose already
*
* We use offline_state to preserve the OFFLINE state, if it exists,
* so other entry points to the driver might have the chance to call
* st_tape_init().
*/
offline_state = 1;
}
/*
* Is this a request to reset the bus?
* If so, we need go no further.
*/
"reset %s %s\n",
/*
* If scsi reset successful, don't write any filemarks.
*/
if (err == 0) {
un->un_fmneeded = 0;
} else {
"st_ioctl_cmd : EIO : scsi_reset failed");
}
goto exit;
}
/*
* First do some sanity checks for USCSI commands.
*/
if (ucmd->uscsi_cdblen <= 0) {
return (EINVAL);
}
/*
* In order to not worry about where the uscsi structure
* or cdb it points to came from, we kmem_alloc copies
* of them here. This will allow reference to the data
* they contain long after this process has gone to
* sleep and its kernel stack has been unmapped, etc.
*/
if (cdbspace == UIO_SYSSPACE) {
} else {
goto exit;
}
}
#ifdef STDEBUG
if (st_debug > 6) {
if (kcmd->uscsi_buflen) {
"uscsi %s of %ld bytes %s %s space\n",
}
}
#endif /* ST_DEBUG */
/*
* Initialize Request Sense buffering, if requested.
* For user processes, allocate a kernel copy of the sense buffer
*/
if (rqbufspace == UIO_USERSPACE) {
}
} else {
kcmd->uscsi_rqlen = 0;
kcmd->uscsi_rqresid = 0;
}
/*
* Get buffer resources...
*/
while (un->un_sbuf_busy)
/*
* Force asynchronous mode, if necessary.
*/
"forced async ok\n");
} else {
"forced async failed\n");
goto done;
}
}
}
/*
* Re-enable synchronous mode, if requested
*/
"re-enabled sync %s\n",
(i == 1) ? "ok" : "failed");
}
}
if (kcmd->uscsi_buflen) {
/*
* We're going to do actual I/O.
* Set things up for physio.
*/
/*
* Let physio do the rest...
*/
} else {
/*
* Mimic physio
*/
(void) st_strategy(bp);
/*
* BugTraq #4260046
* ----------------
* See comments in st_cmd.
*/
"st_ioctl_cmd: biowait returns %d\n", err);
}
/*
* Copy status from kernel copy of uscsi_cmd to user copy
* of uscsi_cmd - this was saved in st_done_and_mutex_exit()
*/
done:
/*
* Update the Request Sense status and resid
*/
/*
* Copy out the sense data for user processes
*/
}
}
"st_ioctl_cmd status is 0x%x, resid is 0x%lx\n",
int i, n, len;
"rqstatus=0x%x rqlen=0x%x rqresid=0x%x\n",
for (i = 0; i < len; i += 16) {
" ", &data[i], n);
}
}
/*
* Free resources
*/
un->un_sbuf_busy = 0;
if (krqbuf) {
}
"st_ioctl_cmd returns 0x%x\n", err);
exit:
/* don't lose offline state */
if (offline_state)
return (err);
}
static int
{
int i;
/*
* write one filemark at the time after EOT
*/
for (i = 0; i < wfm; i++) {
"st_write_fm : EIO : write EOT file mark");
return (EIO);
}
}
"st_write_fm : EIO : write file mark");
return (EIO);
}
return (0);
}
#ifdef STDEBUG
static void
{
"st_start: cmd=0x%p count=%ld resid=%ld flags=0x%x pkt=0x%p\n",
"st_start: cdb %x %x %x %x %x %x, fileno=%d, blk=%ld\n",
}
#endif
/*
* Command start && done functions
*/
/*
* st_start()
*
* Called from:
* st_strategy() to start a command.
* st_runout() to retry when scsi_pkt allocation fails on previous attempt(s).
* st_attach() when resuming from power down state.
* st_start_restart() to retry transport when device was previously busy.
* st_done_and_mutex_exit() to start the next command when previous is done.
*
* On entry:
* scsi_pkt may or may not be allocated.
*
*/
static void
{
int status;
return;
}
/*
* Don't send more than un_throttle commands to the HBA
*/
return;
}
/*
* If the buf has no scsi_pkt call st_make_cmd() to get one and
* build the command.
*/
/*
* Some HBA's don't call bioerror() to set an error.
* And geterror() returns zero if B_ERROR is not set.
* So if we get zero we must check b_error.
*/
}
/*
* Some HBA's convert DDI_DMA_NORESOURCES into ENOMEM.
* In tape ENOMEM has special meaning so we'll change it.
*/
status = 0;
}
/*
* Did it fail and is it retryable?
* If so return and wait for the callback through st_runout.
* Also looks like scsi_init_pkt() will setup a callback even
* if it isn't retryable.
*/
if (status == 0) {
/*
* If first attempt save state.
*/
}
"temp no resources for pkt\n");
} else {
/*
* Unlikely that it would be retryable then not.
*/
}
"perm no resources for pkt errno = 0x%x\n",
status);
}
return;
}
/*
* Worked this time set the state back.
*/
}
}
/*
* move from waitq to runq
*/
/*
* For the case of queue having one
* element, set the tail pointer to
* point to the element.
*/
}
} else {
}
#ifdef STDEBUG
#endif
/* could not get here if throttle was zero */
if (un->un_last_throttle) {
}
if (status != TRAN_ACCEPT) {
/* if too many retries, fail the transport */
ST_TRAN_BUSY_TIMEOUT) == 0)
goto done;
}
"transport rejected\n");
#ifndef __lock_lint
/*
* warlock doesn't understand this potential
* recursion?
*/
#endif
} else {
un->un_tran_retry_ct = 0;
}
done:
}
/*
* if the transport is busy, then put this bp back on the waitq
*/
static int
{
int rval = 0;
"st_handle_start_busy()\n");
/*
* Check to see if we hit the retry timeout and one last check for
* making sure this is the last on the runq, if it is not, we have
* to fail
*/
rval = -1;
goto exit;
}
/* put the bp back on the waitq */
} else {
}
/*
* Decrement un_ncmds so that this
* gets thru' st_start() again.
*/
/*
* since this is an error case, we won't have to do
* this list walking much. We've already made sure this bp was the
* last on the runq
*/
} else {
while (runq_bp) {
break;
}
}
}
/*
* send a marker pkt, if appropriate
*/
/*
* all queues are aligned, we are just waiting to
* transport, don't alloc any more buf p's, when
* st_start is reentered.
*/
exit:
return (rval);
}
/*
* st_runout a callback that is called what a resource allocatation failed
*/
static int
{
/*
* failed scsi_init_pkt(). If errno is zero its retryable.
*/
"errors after pkt alloc (b_flags=0x%x, b_error=0x%x)\n",
/*
* For the case of queue having one
* element, set the tail pointer to
* point to the element.
*/
}
/*
* Set resid, Error already set, then unblock calling thread.
*/
} else {
/*
* Try Again
*/
}
/*
* Comments courtesy of sd.c
* The scsi_init_pkt routine allows for the callback function to
* return a 0 indicating the callback should be rescheduled or a 1
* indicating not to reschedule. This routine always returns 1
* because the driver always provides a callback function to
* scsi_init_pkt. This results in a callback always being scheduled
* (via the scsi_init_pkt callback implementation) if a resource
* failure occurs.
*/
return (1);
}
/*
* st_done_and_mutex_exit()
* - remove bp from runq
* - start up the next request
* - if this was an asynch bp, clean up
* - exit with released mutex
*/
static void
{
int pe_flagged = 0;
#if !defined(lint)
#endif
/*
* if bp is still on the runq (anywhere), then remove it
*/
} else {
}
}
break;
}
}
"st_done_and_mutex_exit(): cmd=0x%x count=%ld resid=%ld flags=0x%x\n",
/*
* update kstats with transfer count info
*/
} else {
}
}
/*
* Start the next one before releasing resources on this one, if
* there is something on the queue and persistent errors has not been
* flagged
*/
}
}
/*
* Since we marked this ourselves as ASYNC,
* there isn't anybody around waiting for
* completion any more.
*/
}
"st_done_and_mutex_exit(async): freeing pkt\n");
un->un_sbuf_busy = 0;
return;
}
/*
* Copy status from scsi_pkt to uscsi_cmd
* since st_ioctl_cmd needs it
*/
}
#ifdef STDEBUG
if ((st_debug >= 4) &&
"st_d_a_m_exit(): ncmds = %d, thr = %d, "
"un_errno = %d, un_pe = %d\n",
}
#endif
"st_done_and_mutex_exit: freeing pkt\n");
/*
* now that we biodoned that command, if persistent errors have been
* flagged, flush the waitq
*/
if (pe_flagged)
}
/*
* Tape error, flush tape driver queue.
*/
static void
{
"st_flush(), ncmds = %d, quef = 0x%p\n",
/*
* if we still have commands outstanding, wait for them to come in
* before flushing the queue, and make sure there is a queue
*/
goto exit;
/*
* we have no more commands outstanding, so let's deal with special
* cases in the queue for EOM and FM. If we are here, and un_errno
* is 0, then we know there was no error and we return a 0 read or
* write before showing errors
*/
/* Flush the wait queue. */
"st_flush() : blkno=%ld, err=%d, b_bcount=%ld\n",
/* it should have one, but check anyway */
}
}
/*
* It's not a bad practice to reset the
* waitq tail pointer to NULL.
*/
exit:
/* we mucked with the queue, so let others know about it */
}
/*
* Utility functions
*/
static int
{
int bsize;
static char *cart = "0.25 inch cartridge";
char *sizestr;
"st_determine_generic(dev = 0x%lx)\n", dev);
if (st_modesense(un)) {
return (-1);
}
if (bsize == 0) {
} else if (bsize > ST_MAXRECSIZE_FIXED) {
/*
* record size of this device too big.
* try and convert it to variable record length.
*
*/
if (st_change_block_size(dev, 0) != 0) {
"Fixed Record Size %d is too large\n", bsize);
"Cannot switch to variable record size\n");
return (-1);
}
} else if (st_change_block_size(dev, 0) == 0) {
/*
* If the drive was set to a non zero block size,
* See if it can be set to a zero block size.
* If it works, ST_VARIABLE so user can set it as they want.
*/
} else {
}
default:
case 0x0:
/*
* default density, cannot determine any other
* information.
*/
sizestr = "Unknown type- assuming 0.25 inch cartridge";
break;
case 0x1:
case 0x2:
case 0x3:
case 0x6:
/*
* 1/2" reel
*/
sizestr = "0.50 inch reel";
break;
case 0x4:
case 0x5:
case 0x7:
case 0x0b:
/*
* Quarter inch.
*/
break;
case 0x0f:
case 0x10:
case 0x11:
case 0x12:
/*
* QIC-120, QIC-150, QIC-320, QIC-600
*/
break;
case 0x09:
case 0x0a:
case 0x0c:
case 0x0d:
/*
* 1/2" cartridge tapes. Include HI-TC.
*/
break;
case 0x13:
case 0x24:
case 0x25:
case 0x26:
sizestr = "DAT Data Storage (DDS)";
break;
case 0x14:
/*
* Helical Scan (Exabyte) devices
*/
sizestr = "8mm helical scan cartridge";
break;
}
/*
* Assume LONG ERASE, BSF and BSR
*/
/*
* Only if mode sense data says no buffered write, set NOBUF
*/
/*
* set up large read and write retry counts
*/
/*
* If this is a 0.50 inch reel tape, and
* it is *not* variable mode, try and
* set it to variable record length
* mode.
*/
if (st_change_block_size(dev, 0) == 0) {
}
}
/*
* Write to console about type of device found
*/
sizestr);
"!Variable record length I/O\n");
} else {
"!Fixed record length (%d byte blocks) I/O\n",
}
return (0);
}
static int
{
int rval = 0;
"st_determine_density(dev = 0x%lx, rw = %s)\n",
/*
* If we're past BOT, density is determined already.
*/
/*
* XXX: put in a bitch message about attempting to
* XXX: change density past BOT.
*/
goto exit;
}
/*
* If we're going to be writing, we set the density
*/
/* un_curdens is used as an index into densities table */
if (st_set_density(dev)) {
rval = -1;
}
goto exit;
}
/*
* If density is known already,
* we don't have to get it again.(?)
*/
if (!un->un_density_known) {
if (st_get_density(dev)) {
rval = -1;
}
}
exit:
return (rval);
}
/*
* Try to determine density. We do this by attempting to read the
* first record off the tape, cycling through the available density
* codes as we go.
*/
static int
{
"st_get_density(dev = 0x%lx)\n", dev);
/*
* If Auto Density override is enabled The drive has
* only one density and there is no point in attempting
* find the correct one.
*
* Since most modern drives auto detect the density
* and format of the recorded media before they come
* ready. What this function does is a legacy behavior
* and modern drives not only don't need it, The backup
* utilities that do positioning via uscsi find the un-
* expected rewinds problematic.
*
* The drives that need this are old reel to reel devices.
* I took a swag and said they must be scsi-1 or older.
* I don't beleave there will any of the newer devices
* that need this. There will be some scsi-1 devices that
* don't need this but I don't think they will be using the
* BIG aftermarket backup and restore utilitys.
*/
rval = 0;
goto exit;
}
/*
* This will only work on variable record length tapes
* if and only if all variable record length tapes autodensity
* select.
*/
/*
* Start at the specified density
*/
(un->un_curdens = 0) :
/*
* If we've done this density before,
* don't bother to do it again.
*/
continue;
"trying density 0x%x\n", dens);
if (st_set_density(dev)) {
continue;
}
/*
* XXX - the creates lots of headaches and slowdowns - must
* fix.
*/
break;
}
if (succes) {
rval = 0;
break;
}
}
exit:
return (rval);
}
static int
{
int rval = 0;
"st_set_density(dev = 0x%lx): density = 0x%x\n", dev,
/*
* If auto density override is not set, Use mode select
* to set density and compression.
*/
if (st_modeselect(un)) {
rval = -1;
}
/*
* If auto density and mode select compression are set,
* This is a drive with one density code but compression
* can be enabled or disabled.
* Set compression but no need to set density.
*/
rval = -1;
} else {
rval = 0;
}
}
if (rval == 0) {
}
return (rval);
}
static int
{
int rval = 0;
"st_loadtape(dev = 0x%lx)\n", dev);
/*
* 'LOAD' the tape to BOT by rewinding
*/
rval = -1;
} else {
un->un_density_known = 0;
}
return (rval);
}
/*
* Note: QIC devices aren't so smart. If you try to append
* after EOM, the write can fail because the device doesn't know
* it's at EOM. In that case, issue a read. The read should fail
* because there's no data, but the device knows it's at EOM,
* so a subsequent write should succeed. To further confuse matters,
* the target returns the same error if the tape is positioned
* such that a write would overwrite existing data. That's why
* we have to do the append test. A read in the middle of
* recorded data would succeed, thus indicating we're attempting
* something illegal.
*/
static void
{
unsigned bcount;
un->un_test_append = 0;
/*
* first, map in the buffer, because we're doing a double write --
* first into the kernel, then onto the tape.
*/
/*
* get a copy of the data....
*/
/*
* attempt the write..
*/
"append write succeeded\n");
return;
}
/*
* The append failed. Do a short read. If that fails, we are at EOM
* so we can retry the write command. If that succeeds, than we're
* all screwed up (the controller reported a real error).
*
* XXX: should the dummy read be > SECSIZE? should it be the device's
* XXX: block size?
*
*/
"append at EOM\n");
/*
* Okay- the read failed. We should actually have confused
* the controller enough to allow writing. In any case, the
* i/o is on its own from here on out.
*/
SYNC_CMD) == 0) {
goto success;
}
}
"append write failed- not at EOM\n");
"st_test_append : EIO : append write failed - not at EOM");
/*
* backspace one record to get back to where we were
*/
}
/*
* Note: biodone will do a bp_mapout()
*/
}
/*
* Special command handler
*/
/*
* common st_cmd code. The fourth parameter states
* whether the caller wishes to await the results
* Note the release of the mutex during most of the function
*/
static int
{
int err;
"st_cmd(dev = 0x%lx, com = 0x%x, count = %x, wait = %d)\n",
#ifdef STDEBUG
if (st_debug)
#endif
while (un->un_sbuf_busy)
/*
* Set count to the actual size of the data tranfer.
* For commands with no data transfer, set bp->b_bcount
* to the value to be used when constructing the
* cdb in st_make_cmd().
*/
switch (com) {
case SCMD_READ:
"special read %d\n", count);
break;
case SCMD_WRITE:
"special write %d\n", count);
break;
case SCMD_WRITE_FILE_MARK:
"write %d file marks\n", count);
count = 0;
break;
case SCMD_REWIND:
count = 0;
break;
case SCMD_SPACE:
count = 0;
break;
case SCMD_RESERVE:
count = 0;
break;
case SCMD_RELEASE:
count = 0;
break;
case SCMD_LOAD:
count = 0;
break;
case SCMD_ERASE:
"erase tape\n");
count = 0;
break;
case SCMD_MODE_SENSE:
"mode sense\n");
break;
case SCMD_MODE_SELECT:
"mode select\n");
break;
case SCMD_READ_BLKLIM:
"read block limits\n");
break;
case SCMD_TEST_UNIT_READY:
"test unit ready\n");
count = 0;
break;
default:
"Unhandled scsi command 0x%x in st_cmd()\n", com);
}
if (count > 0) {
/*
* We're going to do actual I/O.
* Set things up for physio.
*/
/*
* Let physio do the rest...
*/
st_minphys, uio);
"st_cmd: physio returns %d\n", err);
} else {
/*
* Mimic physio
*/
(void) st_strategy(bp);
if (!wait) {
/*
* This is an async command- the caller won't wait
* and doesn't care about errors.
*/
return (0);
}
/*
* BugTraq #4260046
* ----------------
* Restore Solaris 2.5.1 behavior, namely call biowait
* unconditionally. The old comment said...
*
* "if strategy was flagged with persistent errors, we would
* have an error here, and the bp would never be sent, so we
* don't want to wait on a bp that was never sent...or hang"
*
* The new rationale, courtesy of Chitrank...
*
* "we should unconditionally biowait() here because
* st_strategy() will do a biodone() in the persistent error
* case and the following biowait() will return immediately.
* If not, in the case of "errors after pkt alloc" in
* st_start(), we will not biowait here which will cause the
* next biowait() to return immediately which will cause
* us to send out the next command. In the case where both of
* these use the sbuf, when the first command completes we'll
* free the packet attached to sbuf and the same pkt will
* get freed again when we complete the second command.
* see esc 518987. BTW, it is necessary to do biodone() in
* st_start() for the pkt alloc failure case because physio()
* does biowait() and will hang if we don't do biodone()"
*/
"st_cmd: biowait returns %d\n", err);
}
un->un_sbuf_busy = 0;
return (err);
}
static int
{
int rval;
int turn_compression_on;
/*
* Drive either dosn't have compression or it is controlled with
* special density codes. Return ENOTTY so caller
* knows nothing was done.
*/
un->un_comp_page = 0;
return (ENOTTY);
}
/* set compression based on minor node opened */
/*
* If this the compression density or
* the drive has two densities and uses mode select for
* control of compression turn on compression for MT_DENSITY2
* as well.
*/
if ((minor == ST_COMPRESSION_DENSITY) ||
turn_compression_on = 1;
} else {
turn_compression_on = 0;
}
/*
* Need to determine which page does the device use for compression.
* First try the data compression page. If this fails try the device
* configuration page
*/
return (rval);
}
if (rval != 0) {
/*
* This device does not support data
* compression page
*/
} else {
rval = -1;
}
} else {
}
}
return (rval);
}
if (rval != 0) {
/*
* This device does not support
* compression at all advice the
* user and unset ST_MODE_SEL_COMP
*/
un->un_comp_page = 0;
"Device Does Not Support Compression\n");
} else {
rval = -1;
}
}
}
return (rval);
}
/*
* set or unset compression thru device configuration page.
*/
static int
{
unsigned char cflag;
int rval = 0;
/*
* Figure what to set compression flag to.
*/
if (compression_on) {
/* They have selected a compression node */
} else {
}
} else {
}
/*
* If compression is already set the way it was requested.
* And if this not the first time we has tried.
*/
return (EALREADY);
}
/*
* need to send mode select even if correct compression is
* already set since need to set density code
*/
#ifdef STDEBUG
if (st_debug >= 6) {
"st_set_devconfig_page: sense data for mode select",
}
#endif
return (rval);
}
/*
*/
static int
{
int rval = 0;
/*
* If drive is not capable of compression (at this time)
* return EALREADY so caller doesn't think that this page
* is not supported. This check is for drives that can
* disable compression from the front panel or configuration.
* I doubt that a drive that supports this page is not really
* capable of compression.
*/
return (EALREADY);
}
/* See if compression currently turned on */
} else {
}
/*
* If compression is already set the way it was requested.
* And if this not the first time we has tried.
*/
if ((compression_on == compression_on_already) &&
return (EALREADY);
}
/*
* if we are already set to the appropriate compression
* mode, don't set it again
*/
if (compression_on) {
/* compression selected */
} else {
}
#ifdef STDEBUG
if (st_debug >= 6) {
"st_set_datacomp_page: sense data for mode select",
}
#endif
return (rval);
}
static int
{
int rval;
switch (page) {
case ST_DEV_DATACOMP_PAGE:
case ST_DEV_CONFIG_PAGE: /* fall through */
sizeof (struct seq_mode));
break;
sizeof (struct seq_mode));
break;
}
sizeof (struct seq_mode));
break;
}
un->un_comp_page = 0;
} else {
un->un_comp_page = 0;
}
default: /* fall through */
}
return (rval);
}
static int
{
int rval = 0;
int ix;
"st_modeselect(dev = 0x%lx): density = 0x%x\n",
/*
* The parameter list should be the same for all of the
* cases that follow so set them here
*
* Try mode select first if if fails set fields manually
*/
if (rval != 0) {
"st_modeselect: First mode sense failed\n");
}
/*
* If configured to use a specific density code for a media type.
* curdens is previously set by the minor node opened.
* If the media type doesn't match the minor node we change it so it
* looks like the correct one was opened.
*/
/*
* It matches but it might not be the only one.
* Use the highest matching media type but not
* to exceed the density selected by the open.
*/
continue;
}
break;
}
}
/* If a match was found best will not be 0xff any more */
if (best < NDENSITIES) {
"found media 0x%X using density 0x%X\n",
}
} else {
/* Otherwise set density based on minor node opened */
}
} else {
}
/*
* If st_set_compression returned invalid or already it
* found no need to do the mode select.
* So do it here.
*/
/* Zero non-writeable fields */
/* need to set the density code */
if (rval != 0) {
"unable to set tape mode\n");
} else {
rval = -1;
}
}
}
/*
* The spec recommends to send a mode sense after a mode select
*/
(void) st_modesense(un);
return (rval);
}
/*
* st_gen_mode_sense
*
* generic mode sense.. it allows for any page
*/
static int
int page_size)
{
int r;
char cdb[CDB_GROUP0];
cdb[0] = SCMD_MODE_SENSE;
return (r);
}
/*
* st_gen_mode_select
*
* generic mode select.. it allows for any page
*/
static int
int page_size)
{
int r;
char cdb[CDB_GROUP0];
/* Zero non-writeable fields */
page_data->media_type = 0;
/*
* If mode select has any page data, zero the ps (Page Savable) bit.
*/
}
/*
* then, do a mode select to set what ever info
*/
cdb[0] = SCMD_MODE_SELECT;
return (r);
}
/*
* Changes devices blocksize and bsize to requested blocksize nblksz.
* Returns returned value from first failed call or zero on success.
*/
static int
{
int rval;
/* Read current settings */
if (rval != 0) {
"mode sense for change block size failed: rval = %d", rval);
goto finish;
}
/* Figure the current block size */
oldblksz =
/* If current block size is the same as requested were done */
rval = 0;
goto finish;
}
/* Change to requested block size */
/* Attempt to change block size */
if (rval != 0) {
"Set new block size failed: rval = %d", rval);
goto finish;
}
/* Read back and verify setting */
if (rval == 0) {
"Blocksize set does not equal requested blocksize"
}
}
return (rval);
}
static void
{
if (st_error_level != SCSI_ERR_ALL) {
if (DEBUGGING) {
} else {
}
}
}
static void
{
int flags = 0;
char fixbit;
/*
* fixbit is for setting the Fixed Mode and Suppress Incorrect
* the Long bit on erase commands, and for setting the Code
* Field bits on space commands.
* XXX why do we set lastop here?
*/
sizeof (struct scsi_arq_status) : 1);
goto exit;
}
fixbit = 0;
} else {
fixbit = 1;
}
fixbit = 2;
}
} else {
com = SCMD_WRITE;
}
/*
* For really large xfers, increase timeout
*/
/*
* uscsi - build command, allocate scsi resources
*/
goto exit;
} else { /* special I/O */
sizeof (struct scsi_arq_status) : 1);
switch (com) {
case SCMD_READ:
"special read %d\n", count);
} else {
}
break;
case SCMD_WRITE:
"special write %d\n", count);
} else {
fixbit = 0;
}
break;
case SCMD_WRITE_FILE_MARK:
"write %d file marks\n", count);
fixbit = 0;
break;
case SCMD_REWIND:
fixbit = 0;
count = 0;
"rewind\n");
break;
case SCMD_SPACE:
"space %d %s from file %d blk %ld\n",
break;
case SCMD_LOAD:
fixbit = 0;
/* Loading or Unloading */
if (count & 1) {
} else {
}
/* Is Retension requested */
if (count & 2) {
}
break;
case SCMD_ERASE:
"erase tape\n");
count = 0;
/*
* We support long erase only
*/
fixbit = 1;
break;
case SCMD_MODE_SENSE:
"mode sense\n");
fixbit = 0;
break;
case SCMD_MODE_SELECT:
"mode select\n");
fixbit = 0;
break;
case SCMD_RESERVE:
"reserve\n");
fixbit = 0;
break;
case SCMD_RELEASE:
"release\n");
fixbit = 0;
break;
case SCMD_READ_BLKLIM:
"read block limits\n");
break;
case SCMD_TEST_UNIT_READY:
"test unit ready\n");
fixbit = 0;
break;
default:
"Unhandled scsi command 0x%x in st_make_cmd()\n",
com);
}
goto exit;
}
if (allocbp)
}
/*
*/
/*
* If ST_SHORT_FILEMARKS bit is ON for EXABYTE
* device, set the Vendor Unique bit to
* write Short File Mark.
*/
if (com == SCMD_WRITE_FILE_MARK &&
case ST_TYPE_EXB8500:
case ST_TYPE_EXABYTE:
/*
* Now the Vendor Unique bit 7 in Byte 5 of CDB
* is set to to write Short File Mark
*/
break;
default:
/*
* Well, if ST_SHORT_FILEMARKS is set for other
* tape drives, it is just ignored
*/
break;
}
}
exit:
}
/*
* Build a command based on a uscsi command;
*/
static void
{
int cdblen;
int stat_size;
sizeof (struct scsi_arq_status) : 1);
} else {
stat_size = 1;
}
"st_make_uscsi_cmd: buflen=%ld bcount=%ld\n",
goto exit;
}
#ifdef STDEBUG
if (st_debug >= 6) {
}
#endif
}
exit:
}
/*
* restart cmd currently at the head of the runq
*
* If scsi_transport() succeeds or the retries
* count exhausted, restore the throttle that was
* zeroed out in st_handle_intr_busy().
*
*/
static void
st_intr_restart(void *arg)
{
int status = TRAN_ACCEPT;
"st_intr_restart(), un = 0x%p\n", (void *)un);
un->un_hib_tid = 0;
/*
* move from waitq to runq, if there is anything on the waitq
*/
return;
}
/*
* Here we know :
* throttle = 0, via st_handle_intr_busy
*/
} else {
}
/*
* not good, we don't want to requeue something after
* another.
*/
goto done_error;
} else {
}
if (status != TRAN_ACCEPT) {
ST_TRAN_BUSY_TIMEOUT) == 0)
return; /* timeout is setup again */
}
} else {
un->un_tran_retry_ct = 0;
if (un->un_last_throttle) {
}
return;
}
"restart transport rejected\n");
#ifndef __lock_lint
/*
* warlock doesn't understand this potential
* recursion?
*/
if (un->un_last_throttle) {
}
if (status != TRAN_ACCEPT)
#endif
"busy restart aborted\n");
}
/*
* st_check_media():
* Periodically check the media state using scsi_watch service;
* this service calls back after TUR and possibly request sense
* the callback handler (st_media_watch_cb()) decodes the request sense
* data (if any)
*/
static int
{
int rval = 0;
enum mtio_state prev_state;
"st_check_media:state=%x, mediastate=%x\n",
/*
* is there anything to do?
*/
/*
* submit the request to the scsi_watch service;
* scsi_media_watch_cb() does the real work
*/
goto done;
}
/*
* now wait for media change
* we will not be signalled unless mediastate == state but it
* still better to test for this condition, since there
* is a 5 sec cv_broadcast delay when
* mediastate == MTIO_INSERTED
*/
"st_check_media:waiting for media state change\n");
"st_check_media:waiting for media state "
"was interrupted\n");
goto done;
}
"st_check_media:received signal, state=%x\n",
un->un_mediastate);
}
}
/*
* if we transitioned to MTIO_INSERTED, media has really been
* inserted. If TUR fails, it is probably a exabyte slow spin up.
* Reset and retry the state change. If everything is ok, replay
* the open() logic.
*/
"st_check_media: calling st_cmd to confirm inserted\n");
/*
* set this early so that TUR will make it through strategy
* without triggering a st_tape_init(). We needed it set
* before calling st_tape_init() ourselves anyway. If TUR
* fails, set it back
*/
/*
* tape unit do it now.
*/
if (ST_RESERVE_SUPPORTED(un) &&
goto done;
}
}
"st_check_media: TUR failed, going to retry\n");
goto retry;
}
"st_check_media: media inserted\n");
/* this also rewinds the tape */
if (rval != 0) {
"st_check_media : OFFLINE init failure ");
} else {
}
/*
* supported devices must be rewound before ejection
* rewind resets fileno & blkno
*/
}
done:
if (token) {
(void) scsi_watch_request_terminate(token,
}
return (rval);
}
/*
* st_media_watch_cb() is called by scsi_watch_thread for
* verifying the request sense data (if any)
*/
static int
{
int instance;
return (-1);
}
"st_media_watch_cb: status=%x, sensep=%p, len=%x\n",
/*
* if there was a check condition then sensep points to valid
* sense data
* if status was not a check condition but a reservation or busy
* status then the new state is MTIO_NONE
*/
if (sensep) {
"st_media_watch_cb: KEY=%x, ASC=%x, ASCQ=%x\n",
default:
"st_media_watch_cb: unknown drive type %d, default to ST_TYPE_HP\n",
/* FALLTHROUGH */
case ST_TYPE_STC3490: /* STK 4220 1/2" cartridge */
case ST_TYPE_FUJI: /* 1/2" cartridge */
case ST_TYPE_HP: /* HP 88780 1/2" reel */
"st_media_watch_cb: ST_TYPE_FUJI\n");
} else {
"st_media_watch_cb: ST_TYPE_HP\n");
}
case KEY_UNIT_ATTENTION:
/* not ready to ready transition */
/* hp/es_qual_code == 80 on>off>on */
/* hp/es_qual_code == 0 on>off>unld>ld>on */
}
break;
case KEY_NOT_READY:
/* in process, rewinding or loading */
}
break;
}
break;
case ST_TYPE_EXB8500: /* Exabyte 8500 */
"st_media_watch_cb: ST_TYPE_EXB8500\n");
case KEY_UNIT_ATTENTION:
/* operator medium removal request */
/* not ready to ready transition */
}
break;
case KEY_NOT_READY:
/* medium not present */
}
break;
}
break;
case ST_TYPE_EXABYTE: /* Exabyte 8200 */
"st_media_watch_cb: ST_TYPE_EXABYTE\n");
case KEY_NOT_READY:
/* volume not mounted? */
}
break;
case KEY_UNIT_ATTENTION:
break;
}
break;
case ST_TYPE_DLT: /* quantum DLT4xxx */
case KEY_UNIT_ATTENTION:
}
break;
case KEY_NOT_READY:
/* in transition but could be either */
}
break;
}
break;
}
} else if (*((char *)statusp) == STATUS_GOOD) {
}
"st_media_watch_cb:state=%x, specified=%x\n",
/*
* now signal the waiting thread if this is *not* the specified state;
* delay the signal if the state is MTIO_INSERTED
* to allow the target to recover
*/
if (state == MTIO_INSERTED) {
/*
* delay the signal to give the drive a chance
* to do what it apparently needs to do
*/
"st_media_watch_cb:delayed cv_broadcast\n");
} else {
"st_media_watch_cb:immediate cv_broadcast\n");
}
}
return (0);
}
/*
* delayed cv_broadcast to allow for target to recover
* from media insertion
*/
static void
st_delayed_cv_broadcast(void *arg)
{
"st_delayed_cv_broadcast:delayed cv_broadcast\n");
}
/*
* restart cmd currently at the start of the waitq
*/
static void
st_start_restart(void *arg)
{
"st_tran_restart()\n");
}
}
/*
* Command completion processing
*
*/
static void
{
struct buf *last_runqf;
int action = COMMAND_DONE;
int status;
/* If device has gone away not much else to do */
} else {
}
/*
* At this point we know that the command was successfully
* completed. Now what?
*/
} else if (un->un_arq_enabled &&
/*
* the transport layer successfully completed an autorqsense
*/
/*
* okay. We were running a REQUEST SENSE. Find
* out what to do next.
* some actions are based on un_state, hence
* restore the state st was in before ST_STATE_SENSING.
*/
/*
* set pkt back to original packet in case we will have
* to requeue it
*/
/*
* Okay, we weren't running a REQUEST SENSE. Call a routine
* to see if the status bits we're okay. If a request sense
* is to be run, that will happen.
*/
}
switch (action) {
case QUE_COMMAND:
/*
* return cmd to head to the queue
* since we are suspending so that
* it gets restarted during resume
*/
} else {
}
break;
case QUE_SENSE:
break;
default:
break;
}
}
/*
* Restore old state if we were sensing.
*/
}
"st_intr: pkt=%p, bp=%p, action=%x, status=%x\n",
switch (action) {
case COMMAND_DONE_EACCES:
/* this is to report a reservation conflict */
"Reservation Conflict \n");
/*FALLTHROUGH*/
case COMMAND_DONE_ERROR:
/*
* all errors set state of the tape to 'unknown'
* unless we're at EOT or are doing append testing.
* If sense key was illegal request, preserve state.
*/
}
}
/*
* since we have an error (COMMAND_DONE_ERROR), we want to
* make sure an error ocurrs, so make sure at least EIO is
* returned
*/
}
goto done;
"st_intr(): COMMAND_DONE_ERROR_RECOVERED");
}
/*FALLTHROUGH*/
case COMMAND_DONE:
done:
return;
case QUE_SENSE:
goto sense_error;
}
if (un->un_throttle) {
un->un_throttle = 0;
}
/*
* never retry this, some other command will have nuked the
* sense, anyway
*/
if (un->un_last_throttle) {
}
if (status == TRAN_ACCEPT) {
return;
}
goto done;
case QUE_BUSY_COMMAND:
/* longish timeout */
goto que_it_up;
case QUE_COMMAND:
/* short timeout */
/*
* let st_handle_intr_busy put this bp back on waitq and make
* checks to see if it is ok to requeue the command.
*/
/*
* Save the throttle before setting up the timeout
*/
if (un->un_throttle) {
}
return; /* timeout is setup again */
goto done;
case QUE_LAST_COMMAND:
goto last_command_error;
}
return;
goto done;
case JUST_RETURN:
default:
return;
}
/*NOTREACHED*/
}
static int
{
static char *fail = "SCSI transport failed: reason '%s': %s\n";
int rval = COMMAND_DONE_ERROR;
int result;
switch (pkt->pkt_reason) {
case CMD_INCOMPLETE: /* tran stopped with not normal state */
/*
* this occurs when accessing a powered down drive, no
* need to complain; just fail the open
*/
#ifdef STDEBUG
if (st_debug >= 1) {
}
#endif
/*
* if we have commands outstanding in HBA, and a command
* comes back incomplete, we're hosed, so reset target
* If we have the bus, but cmd_incomplete, we probably just
* have a failed selection, so don't reset the target, just
* requeue the command and try again
*/
goto reset_target;
}
/*
* Retry selection a couple more times if we're
* open. If opening, we only try just once to
* reduce probe time for nonexistant devices.
*/
rval = QUE_COMMAND;
}
break;
case CMD_ABORTED:
/*
* most likely this is caused by flush-on-error support. If
* it was not there, the we're in trouble.
*/
if (!un->un_flush_on_errors) {
goto reset_target;
}
return (COMMAND_DONE_ERROR);
else
return (COMMAND_DONE);
case CMD_TIMEOUT: /* Command timed out */
/*FALLTHROUGH*/
default:
"transport completed with %s\n",
STAT_ABORTED)) == 0)) {
/*
* if target reset fails, then pull the chain
*/
if (result == 0) {
}
/* no hope left to recover */
"recovery by resets failed\n");
return (rval);
}
}
}
(STAT_BUS_RESET | STAT_DEV_RESET))) {
"Lost Reservation\n");
}
}
rval = QUE_COMMAND;
case SCMD_MODE_SENSE:
case SCMD_MODE_SELECT:
case SCMD_READ_BLKLIM:
case SCMD_REWIND:
case SCMD_LOAD:
case SCMD_TEST_UNIT_READY:
/*
* These commands can be rerun with impunity
*/
rval = QUE_COMMAND;
break;
default:
break;
}
}
} else {
}
(rval == COMMAND_DONE_ERROR)?
"giving up" : "retrying command");
}
return (rval);
}
/*
* if the device is busy, then put this bp back on the waitq, on the
* interrupt thread, where we want the head of the queue and not the
* end
*
* The callers of this routine should take measures to save the
* un_throttle in un_last_throttle which will be restored in
* st_intr_restart(). The only exception should be st_intr_restart()
* calling this routine for which the saving is already done.
*/
static int
{
int rval = 0;
"st_handle_intr_busy(), un = 0x%p\n", (void *)un);
/*
* Check to see if we hit the retry timeout. We check to make sure
* this is the first one on the runq and make sure we have not
* queued up any more, so this one has to be the last on the list
* also. If it is not, we have to fail. If it is not the first, but
* is the last we are in trouble anyway, as we are in the interrupt
* context here.
*/
rval = -1;
goto exit;
}
/* put the bp back on the waitq */
} else {
}
/*
* We know that this is the first and last on the runq at this time,
* so we just nullify those two queues
*/
/*
* We don't want any other commands being started in the mean time.
* If start had just released mutex after putting something on the
* runq, we won't even get here.
*/
un->un_throttle = 0;
/*
* send a marker pkt, if appropriate
*/
/*
* all queues are aligned, we are just waiting to
* transport
*/
exit:
return (rval);
}
static int
{
int rval = COMMAND_DONE_ERROR;
int amt;
"st_handle_sense()\n");
"busy unit on request sense\n");
}
return (rval);
"Check Condition on REQUEST SENSE\n");
return (rval);
}
/* was there enough data? */
(amt < SUN_MIN_SENSE_LENGTH)) {
"REQUEST SENSE couldn't get sense data\n");
return (rval);
}
}
static int
{
struct scsi_arq_status *arqstat =
int rval = COMMAND_DONE_ERROR;
int amt;
"st_handle_autosense()\n");
"busy unit on request sense\n");
/*
* we return QUE_SENSE so st_intr will setup the SENSE cmd.
* the disadvantage is that we do not have any delay for the
* second retry of rqsense and we have to keep a packet around
*/
return (QUE_SENSE);
"transport error on REQUEST SENSE\n");
/*
* if target reset fails, then pull the chain
*/
"recovery by resets failed\n");
}
}
}
return (rval);
"Check Condition on REQUEST SENSE\n");
return (rval);
}
/* was there enough data? */
(amt < SUN_MIN_SENSE_LENGTH)) {
"REQUEST SENSE couldn't get sense data\n");
return (rval);
}
}
static int
struct scsi_status *statusp)
{
int rval = COMMAND_DONE_ERROR;
long resid;
int severity;
int get_error;
"st_decode_sense()\n");
/*
* For uscsi commands, squirrel away a copy of the
* results of the Request Sense.
*/
"st_decode_sense: stat=0x%x resid=0x%x\n",
}
}
/*
* If the drive is an MT-02, reposition the
* secondary error code into the proper place.
*
* XXX MT-02 is non-CCS tape, so secondary error code
* is in byte 8. However, in SCSI-2, tape has CCS definition
* so it's in byte 12.
*/
}
/* for normal I/O check extract the resid values. */
}
} else {
}
"st_handle_sense (rw): xferred bit = %d, resid=%ld (%d), "
/*
* The problem is, what should we believe?
*/
}
} else {
/*
* If the command is SCMD_SPACE, we need to get the
* residual as returned in the sense data, to adjust
* our idea of current tape position correctly
*/
"st_handle_sense(other): resid=%ld\n",
resid);
} else {
/*
* If the special command is SCMD_READ,
* the correct resid will be set later.
*/
"st_handle_sense(special read): resid=%ld\n",
resid);
}
}
"count 0x%lx resid 0x%lx pktresid 0x%lx\n",
}
case KEY_NO_SENSE:
goto common;
case KEY_RECOVERABLE_ERROR:
sensep);
"Command will be retried\n");
} else {
sensep);
}
break;
}
/*
* XXX only want reads to be stopped by filemarks.
* Don't want them to be stopped by EOT. EOT matters
* only on write.
*/
rval = COMMAND_DONE;
rval = COMMAND_DONE;
/*
* Fun with variable length record devices:
* for specifying larger blocks sizes than the
* actual physical record size.
*/
/*
* XXX! Ugly.
* The requested blocksize is > tape blocksize,
* so this is ok, so we just return the
* actual size xferred.
*/
rval = COMMAND_DONE;
/*
* The requested blocksize is < tape blocksize,
* so this is not ok, so we err with ENOMEM
*/
} else {
}
} else {
/*
* we hope and pray for this just being
* something we can ignore (ie. a
* truly recoverable soft error)
*/
rval = COMMAND_DONE;
}
"filemark\n");
}
/*
* ignore eom when reading, a fmk should terminate reading
*/
}
break;
case KEY_ILLEGAL_REQUEST:
} else {
}
break;
case KEY_MEDIUM_ERROR:
/*
* for (buffered) writes, a medium error must be fatal
*/
}
/*
* attempt to process the keys in the presence of
* other errors
*/
/*
* Fun with variable length record devices:
* for specifying larger blocks sizes than the
* actual physical record size.
*/
/*
* XXX! Ugly
*/
} else {
}
}
"filemark\n");
}
/*
* ignore eom when reading, a fmk should terminate reading
*/
}
break;
case KEY_VOLUME_OVERFLOW:
goto check_keys;
case KEY_HARDWARE_ERROR:
break;
case KEY_BLANK_CHECK:
/*
* if not a special request and some data was xferred then it
* it is not an error yet
*/
/*
* no error for read with or without data xferred
*/
goto check_keys;
rval = COMMAND_DONE;
} else {
}
"blank check\n");
}
(severity = SCSI_ERR_INFO)) {
/*
* we were doing a fast forward by skipping
* multiple fmk at the time
*/
rval = COMMAND_DONE;
}
goto check_keys;
case KEY_WRITE_PROTECT:
if (st_wrongtapetype(un)) {
"wrong tape for writing- use DC6150 tape (or equivalent)\n");
} else {
}
break;
case KEY_UNIT_ATTENTION:
/*
* If we have detected a Bus Reset and the tape
* drive has been reserved.
*/
"st_decode_sense: Lost Reservation\n");
}
/*
* Look, the tape isn't open yet, now determine
* if the cause is a BUS RESET, Save the file and
* Block positions for the callers to recover from
* the loss of position.
*/
}
}
rval = QUE_COMMAND;
} else {
}
} else {
/*
* Check if it is an Unexpected Unit Attention.
* If state is >= ST_STATE_OPEN, we have
* already done the initialization .
* In this case it is Fatal Error
* can be done with fileno set to < 0.
*/
} else {
}
}
break;
case KEY_NOT_READY:
/*
* If in process of getting ready retry.
*/
rval = QUE_COMMAND;
} else {
/* give up */
}
/*
* If this was an error and after device opened
* do error stats.
*/
if (rval == COMMAND_DONE_ERROR &&
}
if (st_error_level >= SCSI_ERR_FATAL)
"Tape not inserted in drive\n");
}
(rval != QUE_COMMAND))
break;
case KEY_ABORTED_COMMAND:
/*
* Probably a parity error...
* if we retry here then this may cause data to be
* written twice or data skipped during reading
*/
goto check_keys;
default:
/*
* Undecoded sense key. Try retries and hope
* that will fix the problem. Otherwise, we're
* dead.
*/
"Unhandled Sense Key '%s'\n",
goto check_keys;
}
(severity >= st_error_level))) {
"File Mark Detected\n");
}
"End-of-Media Detected\n");
}
"Incorrect Length Indicator Set\n");
}
}
if (((rval == COMMAND_DONE_ERROR) ||
(rval == COMMAND_DONE_ERROR_RECOVERED)) &&
} else {
}
}
return (rval);
}
static int
{
int status = TRAN_ACCEPT;
"st_handle_intr_rtr_lcmd(), un = 0x%p\n", (void *)un);
/*
* Check to see if we hit the retry timeout. We check to make sure
* this is the first one on the runq and make sure we have not
* queued up any more, so this one has to be the last on the list
* also. If it is not, we have to fail. If it is not the first, but
* is the last we are in trouble anyway, as we are in the interrupt
* context here.
*/
goto exit;
}
if (un->un_throttle) {
un->un_throttle = 0;
}
/*
* Here we know : bp is the first and last one on the runq
* it is not necessary to put it back on the head of the
* waitq and then move from waitq to runq. Save this queuing
* and call scsi_transport.
*/
if (status == TRAN_ACCEPT) {
un->un_tran_retry_ct = 0;
if (un->un_last_throttle) {
}
"restart transport \n");
return (0);
}
ST_TRAN_BUSY_TIMEOUT) == 0)
return (0);
}
"restart transport rejected\n");
if (un->un_last_throttle) {
}
exit:
return (-1);
}
static int
{
"st_wrongtapetype()\n");
/*
* Hack to handle 600A, 600XTD, 6150 && 660 vs. 300XL tapes...
*/
case ST_TYPE_WANGTEK:
case ST_TYPE_ARCHIVE:
/*
* If this really worked, we could go off of
* the density codes set in the modesense
* page. For this drive, 0x10 == QIC-120,
* 0xf == QIC-150, and 0x5 should be for
* both QIC-24 and, maybe, QIC-11. However,
* the h/w doesn't do what the manual says
* that it should, so we'll key off of
* getting a WRITE PROTECT error AND wp *not*
* set in the mode sense information.
*/
/*
* XXX but we already know that status is
* write protect, so don't check it again.
*/
return (1);
}
break;
default:
break;
}
}
return (0);
}
static int
{
int action;
} else {
"unit busy too long\n");
}
}
/*
* we should only get here if the auto rqsense failed
* thru a uscsi cmd without autorequest sense
* so we just try again
*/
} else {
}
return (action);
}
static void
{
int n;
} else {
}
}
static void
{
"st_set_state(): un_eof=%x fmneeded=%x pkt_resid=0x%lx (%ld)\n",
#ifdef STDEBUG
"pkt_resid %ld bcount %ld\n",
}
#endif
un->un_fmneeded = 0;
} else {
} else {
}
}
/*
* all is honky dory at this point, so let's
* readjust the throttle, to increase speed, if we
* have not throttled down.
*/
if (un->un_throttle)
} else {
switch (cmd) {
case SCMD_WRITE:
} else {
}
break;
case SCMD_READ:
un->un_fmneeded = 0;
break;
case SCMD_WRITE_FILE_MARK:
un->un_fmneeded -=
if (un->un_fmneeded < 0) {
un->un_fmneeded = 0;
}
} else {
un->un_fmneeded = 0;
}
break;
case SCMD_REWIND:
break;
case SCMD_SPACE:
{
long resid;
if (count >= 0) {
if (space_fmk) {
}
} else {
}
} else if (count < 0) {
if (space_fmk) {
} else {
}
} else {
/*
* we stepped back into
* a previous file; we are not
* making an effort to pretend that
* we are still in the current file
* ie. logical == physical position
* and leave it to st_ioctl to correct
*/
} else {
}
} else {
}
}
}
"aft_space rs %ld fil %d blk %ld\n",
break;
}
case SCMD_LOAD:
} else {
}
un->un_density_known = 0;
break;
case SCMD_ERASE:
break;
case SCMD_RESERVE:
un->un_rsvd_status &=
~(ST_RELEASE | ST_LOST_RESERVE |
break;
case SCMD_RELEASE:
un->un_rsvd_status &=
~(ST_RESERVE | ST_LOST_RESERVE |
break;
case SCMD_TEST_UNIT_READY:
case SCMD_READ_BLKLIM:
case SCMD_REQUEST_SENSE:
case SCMD_INQUIRY:
case SCMD_RECOVER_BUF:
case SCMD_MODE_SELECT:
case SCMD_MODE_SENSE:
case SCMD_DOORLOCK:
case SCMD_READ_POSITION:
case SCMD_READ_BUFFER:
case SCMD_REPORT_DENSITIES:
case SCMD_LOG_SELECT_G1:
case SCMD_LOG_SENSE_G1:
case SCMD_REPORT_LUNS:
break;
case SCMD_LOCATE: /* Locate makes position unknown */
default:
/*
* Unknown command, If was USCSI and USCSI_SILENT
* flag was not set, set position to unknown.
*/
"unknown cmd 0x%X caused loss of state\n",
cmd);
} else {
break;
}
/* FALLTHROUGH */
case SCMD_WRITE_BUFFER: /* Writes new firmware to device */
break;
}
}
/*
* In the st driver we have a logical and physical file position.
* Under BSD behavior, when you get a zero read, the logical position
* is before the filemark but after the last record of the file.
* The physical position is after the filemark. MTIOCGET should always
* return the logical file position.
*
* The next read gives a silent skip to the next file.
* Under SVR4, the logical file position remains before the filemark
* until the file is closed or a space operation is performed.
* Hence set err_resid and err_file before changing fileno if case
* BSD Behaviour.
*/
un->un_retry_ct = 0;
/*
* If we've seen a filemark via the last read operation
* advance the file counter, but mark things such that
* the next read operation gets a zero count. We have
* to put this here to handle the case of sitting right
* at the end of a tape file having seen the file mark,
* but the tape is closed and then re-opened without
* any further i/o. That is, the position information
* must be updated before a close.
*/
/*
* If we're a 1/2" tape, and we get a filemark
* right on block 0, *AND* we were not in the
* first file on the tape, and we've hit logical EOM.
* We'll mark the state so that later we do the
* right thing (in st_close(), st_strategy() or
* st_ioctl()).
*
*/
"eot pending\n");
} else if (BSD_BEHAVIOR) {
/*
* If the read of the filemark was a side effect
* of reading some blocks (i.e., data was actually
* read), then the EOF mark is pending and the
* bump into the next file awaits the next read
* operation (which will return a zero count), or
* a close or a space operation, else the bump
* into the next file occurs now.
*/
"resid=%lx, bcount=%lx\n",
} else {
}
"eof of file %d, un_eof=%d\n",
} else if (SVR4_BEHAVIOR) {
/*
* If the read of the filemark was a side effect
* of reading some blocks (i.e., data was actually
* read), then the next read should return 0
*/
"resid=%lx, bcount=%lx\n",
}
"eof of file=%d, un_eof=%d\n",
}
}
}
/*
* set the correct un_errno, to take corner cases into consideration
*/
static void
{
/* if errno is already set, don't reset it */
return;
/* here un_errno == 0 */
/*
* if the last transfer before flushing all the
* waiting I/O's, was 0 (resid = count), then we
* want to give the user an error on all the rest,
* so here. If there was a transfer, we set the
* resid and counts to 0, and let it drop through,
* giving a zero return. the next I/O will then
* give an error.
*/
case ST_EOM:
break;
case ST_EOT:
case ST_EOF:
break;
}
} else {
/*
* we know they did not have a zero, so make
* sure they get one
*/
}
}
/*
* send in a marker pkt to terminate flushing of commands by BBA (via
* flush-on-errors) property. The HBA will always return TRAN_ACCEPT
*/
static void
{
if (!un->un_flush_on_errors)
return;
#ifdef FLUSH_ON_ERRORS
if (!un->un_mkr_pkt) {
/* we slept, so it must be there */
}
#endif
}
static void
{
int i;
char buf[256];
for (i = 0; i < len; i++) {
(data[i] & 0xff));
}
}
/*
* Conditionally enabled debugging
*/
#ifdef STDEBUG
static void
{
char tmpbuf[64];
"cmd=%s count=0x%x (%d) %ssync\n",
}
/*
* Returns pointer to name of minor node name of device 'dev'.
*/
static char *
{
static char name[4];
int nprt = 0;
}
if (minor & MT_NOREWIND) {
}
/* NULL terminator */
return (name);
}
#endif /* STDEBUG */
/*
* Soft error reporting, so far unique to each drive
*
* Currently supported: exabyte and DAT soft error reporting
*/
static int
{
int amt;
int rval = 0;
"st_report_exabyte_soft_errors(dev = 0x%lx, flag = %d)\n",
*c++ = SCMD_REQUEST_SENSE;
*c++ = 0;
*c++ = 0;
*c++ = 0;
*c++ = TAPE_SENSE_LENGTH;
/*
* set CLRCNT (byte 5, bit 7 which clears the error counts)
*/
*c = (char)0x80;
| USCSI_READ | USCSI_RQENABLE;
goto done;
}
/*
* was there enough data?
*/
"Periodic head cleaning required");
}
goto done;
/*
* check if soft error reporting needs to be done.
*/
count &= 0xffffff;
#ifdef STDEBUG
if (st_soft_error_report_debug) {
"Exabyte Soft Error Report:\n");
"number of bytes transferred: %dK\n",
"error_rate: %d%%\n", error_rate);
if (amt >= 22) {
"unit sense: 0x%b 0x%b 0x%b\n",
}
if (amt >= 27) {
"tracking retry counter: %d\n",
sensep[26]);
sensep[27]);
}
}
#endif
} else {
}
if (error_rate >= rate) {
"Soft error rate (%d%%) during %s was too high",
"Please, replace tape cartridge\n");
}
}
done:
if (rval != 0) {
"exabyte soft error reporting failed\n");
}
return (rval);
}
/*
* this is very specific to Archive 4mm dat
*/
static int
{
int amt, i;
int rval = 0;
*c++ = SCMD_LOG_SENSE_G1;
*c++ = 0;
*c++ = 0;
*c++ = 0;
*c++ = 0;
*c++ = 2;
*c++ = 0;
*c++ = (char)LOG_SENSE_LENGTH;
*c = 0;
com->uscsi_flags =
rval =
if (rval) {
"DAT soft error reporting failed\n");
}
goto done;
}
/*
* was there enough data?
*/
total = -1;
retries = -1;
#ifdef STDEBUG
if (st_soft_error_report_debug) {
(void) printf("logsense:");
for (i = 0; i < MIN_LOG_SENSE_LENGTH; i++) {
if (i % 16 == 0) {
(void) printf("\t\n");
}
}
(void) printf("\n");
}
#endif
/*
* parse the param_codes
*/
for (i = 4; i < amt; i++) {
param_code += sensep[i++];
i++; /* skip control byte */
if (param_code == 5) {
if (sensep[i++] == 4) {
}
} else if (param_code == 0x8007) {
if (sensep[i++] == 2) {
}
} else {
i += sensep[i];
}
}
}
/*
* if the log sense returned valid numbers then determine
* the read and write error thresholds based on the amount of
* data transferred
*/
short normal_retries = 0;
"total xferred (%s) =%x, retries=%x\n",
if (total <=
} else {
}
} else {
if (total <=
} else {
}
}
"normal retries=%d\n", normal_retries);
if (retries >= normal_retries) {
"Soft error rate (retries = %d) during "
"%s was too high", retries,
"Periodic head cleaning required "
}
"log sense parameter code does not make sense\n");
}
}
/*
* reset all values
*/
c = cdb;
*c++ = SCMD_LOG_SELECT_G1;
*c++ = 2; /* this resets all values */
*c++ = (char)0xc0;
*c++ = 0;
*c++ = 0;
*c++ = 0;
*c++ = 0;
*c++ = 0;
*c++ = 0;
*c = 0;
com->uscsi_buflen = 0;
rval =
if (rval) {
"DAT soft error reset failed\n");
}
done:
return (rval);
}
static int
{
case ST_TYPE_EXB8500:
case ST_TYPE_EXABYTE:
/*NOTREACHED*/
case ST_TYPE_PYTHON:
/*NOTREACHED*/
default:
return (-1);
}
}
/*
* persistent error routines
*/
/*
* enable persistent errors, and set the throttle appropriately, checking
* for flush-on-errors capability
*/
static void
{
/*
* only use flush-on-errors if auto-request-sense and untagged-qing are
* enabled. This will simplify the error handling for request senses
*/
1 : 0;
} else {
un->un_flush_on_errors = 0;
}
if (un->un_flush_on_errors)
else
/* this will send a marker pkt */
}
/*
* This turns persistent errors permanently off
*/
static void
{
/* turn it off for good */
un->un_persistence = 0;
/* this will send a marker pkt */
/* turn off flush on error capability, if enabled */
if (un->un_flush_on_errors) {
}
un->un_flush_on_errors = 0;
}
/*
* This clear persistent errors, allowing more commands through, and also
* sending a marker packet.
*/
static void
{
un->un_persist_errors = 0;
}
/*
* This will flag persistent errors, shutting everything down, if the
* application had enabled persistent errors via MTIOCPERSISTENT
*/
static void
{
if (un->un_persistence) {
}
}
int
{
int rval;
char cdb[CDB_GROUP0];
"Releasing":"Reserving");
if (cmd == ST_RELEASE) {
cdb[0] = SCMD_RELEASE;
} else {
cdb[0] = SCMD_RESERVE;
}
"st_reserve_release: rval(1)=%d\n", rval);
if (rval) {
/*
* in case of drives which do not support
*/
if (ST_RESERVE_SUPPORTED(un)) {
"Tape unit does not support "
}
rval = 0;
}
}
return (rval);
}
static int
{
int rval;
"st_take_ownership: Entering ...\n");
/*
* XXX -> Should reset be done only if we get EACCES.
* .
*/
if (rval) {
return (EIO);
}
}
un->un_rsvd_status &=
/*
* remove the check condition.
*/
return (rval);
}
}
/*
* Set tape state to ST_STATE_OFFLINE , in case if
* the user wants to continue and start using
* the tape.
*/
}
return (rval);
}
static int
{
char kstatname[KSTAT_STRLEN];
/*
* Create device error kstats
*/
"device_error", KSTAT_TYPE_NAMED,
sizeof (struct st_errstats) / sizeof (kstat_named_t),
if (un->un_errstats) {
struct st_errstats *stp;
/*
* Fill in the static data
*/
/*
* XXX: Emulex MT-02 (and emulators) predates
* SCSI-1 and has no vid & pid inquiry data.
*/
if (ST_INQUIRY->inq_len != 0) {
}
}
}
return (0);
}
static int
{
/*
* Rewind ? Oh yeah, Fidelity has got the STK F/W changed
* so as not to rewind tape on RESETS: Gee, Has life ever
* been simple in tape land ?
*/
"Failed to restore the last file and block position: In"
" this state, Tape will be loaded at BOT during next open");
return (1);
}
if (fileno) {
"Failed to restore the last file position: In this "
" state, Tape will be loaded at BOT during next open");
return (2);
}
}
if (blkno) {
"Failed to restore the last block position: In this"
" state, tape will be loaded at BOT during next open");
return (3);
}
}
return (0);
}
/*
* check sense key, ASC, ASCQ in order to determine if the tape needs
* to be ejected
*/
static int
{
struct tape_failure_code *code;
return (1);
}
return (0);
}
/*
* st_logpage_supported() sends a Log Sense command with
* page code = 0 = Supported Log Pages Page to the device,
* to see whether the page 'page' is supported.
* Return values are:
* -1 if the Log Sense command fails
* 0 if page is not supported
* 1 if page is supported
*/
static int
{
unsigned length;
int rval;
char cdb[CDB_GROUP1] = {
0,
0,
0,
0,
0,
0,
(char)LOG_SENSE_LENGTH,
0
};
com->uscsi_flags =
/* uscsi-command failed */
rval = -1;
} else {
rval = 1;
break;
}
}
}
return (rval);
}
/*
* st_check_clean_bit() gets the status of the tape's cleaning bit.
*
* If the device does support the TapeAlert log page, then the cleaning bit
* information will be read from this page. Otherwise we will see if one of
* ST_CLN_TYPE_1, ST_CLN_TYPE_2 or ST_CLN_TYPE_3 is set in the properties of
* the device, which means, that we can get the cleaning bit information via
* a RequestSense command.
* If both methods of getting cleaning bit information are not supported
* st_check_clean_bit() will return with 0. Otherwise st_check_clean_bit()
* returns with
* - MTF_TAPE_CLN_SUPPORTED if cleaning bit is not set or
* - MTF_TAPE_CLN_SUPPORTED | MTF_TAPE_HEAD_DIRTY if cleaning bit is set.
* If the call to st_ioctl_cmd() to do the Log Sense or the Request Sense
* command fails, or if the amount of Request Sense data is not enough, then
* st_check_clean_bit() returns with -1.
*/
static int
{
int rval = 0;
return (rval);
}
if (rval == 1) {
}
if (rval == 1) {
}
}
}
rval = 0;
}
}
}
if (rval < 0) {
return (rval);
}
/*
* If found a supported means to check need to clean.
*/
if (rval & MTF_TAPE_CLN_SUPPORTED) {
/*
* head needs to be cleaned.
*/
if (rval & MTF_TAPE_HEAD_DIRTY) {
/*
* Print log message only first time
* found needing cleaned.
*/
"Periodic head cleaning required");
}
} else {
}
}
return (rval);
}
static int
{
int rval;
int ix;
struct log_sequential_page *sp;
struct log_sequential_page_parameter *prm;
char cdb[CDB_GROUP1] = {
0,
0,
0,
0,
0,
(char)(sizeof (struct log_sequential_page) >> 8),
(char)(sizeof (struct log_sequential_page)),
0
};
cmd->uscsi_flags =
rval = -1;
rval = -1;
}
break;
}
if (parameter == SEQUENTIAL_NEED_CLN) {
"sequential log says head dirty\n");
}
}
prm = (struct log_sequential_page_parameter *)
}
return (rval);
}
static int
{
struct st_tape_alert *ta;
int rval;
char cdb[CDB_GROUP1] = {
0,
0,
0,
0,
0,
(char)(sizeof (struct st_tape_alert) >> 8),
(char)(sizeof (struct st_tape_alert)),
0
};
com->uscsi_flags =
rval = -1;
}
if (length != TAPE_ALERT_PARAMETER_LENGTH) {
"TapeAlert length %d\n", length);
}
/*
* if rval is bad before the first pass don't bother
*/
break;
}
/*
* check to see if current parameter is of interest.
* CLEAN_FOR_ERRORS is vendor specific to 9840 9940 stk's.
*/
(parameter == CLEAN_PERIODIC) ||
((parameter == CLEAN_FOR_ERRORS) &&
"alert_page drive needs clean %d\n",
}
} else if (parameter == CLEANING_MEDIA) {
"alert_page drive was cleaned\n");
}
}
}
/*
* Report it as dirty till we see it cleaned
*/
"alert_page still dirty\n");
}
return (rval);
}
static int
{
char cdb[CDB_GROUP0];
unsigned length;
int index;
int rval;
/*
* Since this tape does not support Tape Alert,
* we now try to get the cleanbit status via
* Request Sense.
*/
index = 0;
index = 1;
index = 2;
} else {
return (-1);
}
cdb[0] = SCMD_REQUEST_SENSE;
cdb[1] = 0;
cdb[2] = 0;
cdb[3] = 0;
cdb[5] = 0;
com->uscsi_flags =
rval = -1;
} else {
"sense data says head dirty\n");
}
}
return (rval);
}
/*
* st_clear_unit_attention
*
* run test unit ready's to clear out outstanding
* unit attentions.
* returns zero for SUCCESS or the errno from st_cmd call
*/
static int
{
int i = 0;
int rval;
do {
return (rval);
}
static void
{
} else {
}
}
} else {
}
}
} else {
}
}
} else {
}
}
} else {
}
}
} else {
}
}
} else {
}
}
}
/*
* release contig_mem and wake up waiting thread, if any
*/
static void
{
}
/*
* St_get_contig_mem will return a contig_mem if there is one available
* in current system. Otherwise, it will try to alloc one, if the total
* number of contig_mem is within st_max_contig_mem_num.
* It will sleep, if allowed by caller or return NULL, if no contig_mem
* is available for now.
*/
static struct contig_mem *
{
/* Try to get one available contig_mem */
if (un->un_contig_mem_available_num > 0) {
/*
* we failed to get one. we're going to
* alloc one more contig_mem for this I/O
*/
cp = (struct contig_mem *)
"alloc contig_mem failure\n");
return (NULL); /* cannot get one */
}
} else {
/*
* we failed to get one and we're NOT allowed to
* alloc more contig_mem
*/
if (alloc_flags == KM_SLEEP) {
while (un->un_contig_mem_available_num <= 0) {
ST_MUTEX);
}
} else {
"alloc contig_mem failure\n");
return (NULL); /* cannot get one */
}
}
/* We need to check if this block of mem is big enough for this I/O */
/* not big enough, need to alloc a new one */
"alloc contig_mem failure: not enough mem\n");
return (NULL);
}
/* release previous one before we attach new one */
}
/* attach new mem to this cp */
"alloc contig_mem failure:"
"no enough mem for bp\n");
return (NULL);
}
}
}
/* init bp attached to this cp */
return (cp);
}
/*
* this is the biodone func for the bp used in big block I/O
*/
static int
{
struct contig_mem *cp;
int remapped = 0;
int ioerr;
/* sanity check */
return (DDI_FAILURE);
}
return (DDI_FAILURE);
}
/* special handling for special I/O */
if (cp->cm_use_sbuf) {
cp->cm_use_sbuf = 0;
}
if (ioerr != 0) {
/* copy data back to original bp */
remapped = 1;
}
if (remapped)
}
return (DDI_SUCCESS);
}
/*
* We use this func to replace original bp that may not be able to do I/O
* in big block size with one that can
*/
static struct buf *
{
struct contig_mem *cp;
int remapped = 0;
return (bp);
}
/* try to get one contig_mem */
if (!cp) {
"Cannot alloc contig buf for I/O for %lu blk size",
return (bp);
}
/* make sure that we "are" using un_sbufp for special I/O */
}
/* clone bp */
/* get data in original bp */
remapped = 1;
}
if (remapped)
}
return (cont_bp);
}
#endif