1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2011 Bayard G. Bell. All rights reserved. 25 */ 26 27 /* 28 * SCSI SCSA-compliant and not-so-DDI-compliant Tape Driver 29 */ 30 31 #if defined(lint) && !defined(DEBUG) 32 #define DEBUG 1 33 #endif 34 35 #include <sys/modctl.h> 36 #include <sys/scsi/scsi.h> 37 #include <sys/mtio.h> 38 #include <sys/scsi/targets/stdef.h> 39 #include <sys/file.h> 40 #include <sys/kstat.h> 41 #include <sys/ddidmareq.h> 42 #include <sys/ddi.h> 43 #include <sys/sunddi.h> 44 #include <sys/byteorder.h> 45 46 #define IOSP KSTAT_IO_PTR(un->un_stats) 47 /* 48 * stats maintained only for reads/writes as commands 49 * like rewind etc skew the wait/busy times 50 */ 51 #define IS_RW(bp) ((bp)->b_bcount > 0) 52 #define ST_DO_KSTATS(bp, kstat_function) \ 53 if ((bp != un->un_sbufp) && un->un_stats && IS_RW(bp)) { \ 54 kstat_function(IOSP); \ 55 } 56 57 #define ST_DO_ERRSTATS(un, x) \ 58 if (un->un_errstats) { \ 59 struct st_errstats *stp; \ 60 stp = (struct st_errstats *)un->un_errstats->ks_data; \ 61 stp->x.value.ul++; \ 62 } 63 64 #define FILL_SCSI1_LUN(devp, pkt) \ 65 if ((devp)->sd_inq->inq_ansi == 0x1) { \ 66 int _lun; \ 67 _lun = ddi_prop_get_int(DDI_DEV_T_ANY, (devp)->sd_dev, \ 68 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0); \ 69 if (_lun > 0) { \ 70 ((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun = \ 71 _lun; \ 72 } \ 73 } 74 75 /* 76 * get an available contig mem header, cp. 77 * when big_enough is true, we will return NULL, if no big enough 78 * contig mem is found. 79 * when big_enough is false, we will try to find cp containing big 80 * enough contig mem. if not found, we will ruturn the last cp available. 81 * 82 * used by st_get_contig_mem() 83 */ 84 #define ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough) { \ 85 struct contig_mem *tmp_cp = NULL; \ 86 for ((cp) = (un)->un_contig_mem; \ 87 (cp) != NULL; \ 88 tmp_cp = (cp), (cp) = (cp)->cm_next) { \ 89 if (((cp)->cm_len >= (len)) || \ 90 (!(big_enough) && ((cp)->cm_next == NULL))) { \ 91 if (tmp_cp == NULL) { \ 92 (un)->un_contig_mem = (cp)->cm_next; \ 93 } else { \ 94 tmp_cp->cm_next = (cp)->cm_next; \ 95 } \ 96 (cp)->cm_next = NULL; \ 97 (un)->un_contig_mem_available_num--; \ 98 break; \ 99 } \ 100 } \ 101 } 102 103 #define ST_NUM_MEMBERS(array) (sizeof (array) / sizeof (array[0])) 104 #define COPY_POS(dest, source) bcopy(source, dest, sizeof (tapepos_t)) 105 #define ISALNUM(byte) \ 106 (((byte) >= 'a' && (byte) <= 'z') || \ 107 ((byte) >= 'A' && (byte) <= 'Z') || \ 108 ((byte) >= '0' && (byte) <= '9')) 109 110 #define ONE_K 1024 111 112 #define MAX_SPACE_CNT(cnt) if (cnt >= 0) { \ 113 if (cnt > MIN(SP_CNT_MASK, INT32_MAX)) \ 114 return (EINVAL); \ 115 } else { \ 116 if (-(cnt) > MIN(SP_CNT_MASK, INT32_MAX)) \ 117 return (EINVAL); \ 118 } \ 119 120 /* 121 * Global External Data Definitions 122 */ 123 extern struct scsi_key_strings scsi_cmds[]; 124 extern uchar_t scsi_cdb_size[]; 125 126 /* 127 * Local Static Data 128 */ 129 static void *st_state; 130 static char *const st_label = "st"; 131 static volatile int st_recov_sz = sizeof (recov_info); 132 static const char mp_misconf[] = { 133 "St Tape is misconfigured, MPxIO enabled and " 134 "tape-command-recovery-disable set in st.conf\n" 135 }; 136 137 #ifdef __x86 138 /* 139 * We need to use below DMA attr to alloc physically contiguous 140 * memory to do I/O in big block size 141 */ 142 static ddi_dma_attr_t st_contig_mem_dma_attr = { 143 DMA_ATTR_V0, /* version number */ 144 0x0, /* lowest usable address */ 145 0xFFFFFFFFull, /* high DMA address range */ 146 0xFFFFFFFFull, /* DMA counter register */ 147 1, /* DMA address alignment */ 148 1, /* DMA burstsizes */ 149 1, /* min effective DMA size */ 150 0xFFFFFFFFull, /* max DMA xfer size */ 151 0xFFFFFFFFull, /* segment boundary */ 152 1, /* s/g list length */ 153 1, /* granularity of device */ 154 0 /* DMA transfer flags */ 155 }; 156 157 static ddi_device_acc_attr_t st_acc_attr = { 158 DDI_DEVICE_ATTR_V0, 159 DDI_NEVERSWAP_ACC, 160 DDI_STRICTORDER_ACC 161 }; 162 163 /* set limitation for the number of contig_mem */ 164 static int st_max_contig_mem_num = ST_MAX_CONTIG_MEM_NUM; 165 #endif 166 167 /* 168 * Tunable parameters 169 * 170 * DISCLAIMER 171 * ---------- 172 * These parameters are intended for use only in system testing; if you use 173 * them in production systems, you do so at your own risk. Altering any 174 * variable not listed below may cause unpredictable system behavior. 175 * 176 * st_check_media_time 177 * 178 * Three second state check 179 * 180 * st_allow_large_xfer 181 * 182 * Gated with ST_NO_RECSIZE_LIMIT 183 * 184 * 0 - Transfers larger than 64KB will not be allowed 185 * regardless of the setting of ST_NO_RECSIZE_LIMIT 186 * 1 - Transfers larger than 64KB will be allowed 187 * if ST_NO_RECSIZE_LIMIT is TRUE for the drive 188 * 189 * st_report_soft_errors_on_close 190 * 191 * Gated with ST_SOFT_ERROR_REPORTING 192 * 193 * 0 - Errors will not be reported on close regardless 194 * of the setting of ST_SOFT_ERROR_REPORTING 195 * 196 * 1 - Errors will be reported on close if 197 * ST_SOFT_ERROR_REPORTING is TRUE for the drive 198 */ 199 static int st_selection_retry_count = ST_SEL_RETRY_COUNT; 200 static int st_retry_count = ST_RETRY_COUNT; 201 202 static int st_io_time = ST_IO_TIME; 203 static int st_long_timeout_x = ST_LONG_TIMEOUT_X; 204 205 static int st_space_time = ST_SPACE_TIME; 206 static int st_long_space_time_x = ST_LONG_SPACE_TIME_X; 207 208 static int st_error_level = SCSI_ERR_RETRYABLE; 209 static int st_check_media_time = 3000000; /* 3 Second State Check */ 210 211 static int st_max_throttle = ST_MAX_THROTTLE; 212 213 static clock_t st_wait_cmds_complete = ST_WAIT_CMDS_COMPLETE; 214 215 static int st_allow_large_xfer = 1; 216 static int st_report_soft_errors_on_close = 1; 217 218 /* 219 * End of tunable parameters list 220 */ 221 222 223 224 /* 225 * Asynchronous I/O and persistent errors, refer to PSARC/1995/228 226 * 227 * Asynchronous I/O's main offering is that it is a non-blocking way to do 228 * reads and writes. The driver will queue up all the requests it gets and 229 * have them ready to transport to the HBA. Unfortunately, we cannot always 230 * just ship the I/O requests to the HBA, as there errors and exceptions 231 * that may happen when we don't want the HBA to continue. Therein comes 232 * the flush-on-errors capability. If the HBA supports it, then st will 233 * send in st_max_throttle I/O requests at the same time. 234 * 235 * Persistent errors : This was also reasonably simple. In the interrupt 236 * routines, if there was an error or exception (FM, LEOT, media error, 237 * transport error), the persistent error bits are set and shuts everything 238 * down, but setting the throttle to zero. If we hit and exception in the 239 * HBA, and flush-on-errors were set, we wait for all outstanding I/O's to 240 * come back (with CMD_ABORTED), then flush all bp's in the wait queue with 241 * the appropriate error, and this will preserve order. Of course, depending 242 * on the exception we have to show a zero read or write before we show 243 * errors back to the application. 244 */ 245 246 extern const int st_ndrivetypes; /* defined in st_conf.c */ 247 extern const struct st_drivetype st_drivetypes[]; 248 extern const char st_conf_version[]; 249 250 #ifdef STDEBUG 251 static int st_soft_error_report_debug = 0; 252 volatile int st_debug = 0; 253 static volatile dev_info_t *st_lastdev; 254 static kmutex_t st_debug_mutex; 255 #endif 256 257 #define ST_MT02_NAME "Emulex MT02 QIC-11/24 " 258 259 static const struct vid_drivetype { 260 char *vid; 261 char type; 262 } st_vid_dt[] = { 263 {"LTO-CVE ", MT_LTO}, 264 {"QUANTUM ", MT_ISDLT}, 265 {"SONY ", MT_ISAIT}, 266 {"STK ", MT_ISSTK9840} 267 }; 268 269 static const struct driver_minor_data { 270 char *name; 271 int minor; 272 } st_minor_data[] = { 273 /* 274 * The top 4 entries are for the default densities, 275 * don't alter their position. 276 */ 277 {"", 0}, 278 {"n", MT_NOREWIND}, 279 {"b", MT_BSD}, 280 {"bn", MT_NOREWIND | MT_BSD}, 281 {"l", MT_DENSITY1}, 282 {"m", MT_DENSITY2}, 283 {"h", MT_DENSITY3}, 284 {"c", MT_DENSITY4}, 285 {"u", MT_DENSITY4}, 286 {"ln", MT_DENSITY1 | MT_NOREWIND}, 287 {"mn", MT_DENSITY2 | MT_NOREWIND}, 288 {"hn", MT_DENSITY3 | MT_NOREWIND}, 289 {"cn", MT_DENSITY4 | MT_NOREWIND}, 290 {"un", MT_DENSITY4 | MT_NOREWIND}, 291 {"lb", MT_DENSITY1 | MT_BSD}, 292 {"mb", MT_DENSITY2 | MT_BSD}, 293 {"hb", MT_DENSITY3 | MT_BSD}, 294 {"cb", MT_DENSITY4 | MT_BSD}, 295 {"ub", MT_DENSITY4 | MT_BSD}, 296 {"lbn", MT_DENSITY1 | MT_NOREWIND | MT_BSD}, 297 {"mbn", MT_DENSITY2 | MT_NOREWIND | MT_BSD}, 298 {"hbn", MT_DENSITY3 | MT_NOREWIND | MT_BSD}, 299 {"cbn", MT_DENSITY4 | MT_NOREWIND | MT_BSD}, 300 {"ubn", MT_DENSITY4 | MT_NOREWIND | MT_BSD} 301 }; 302 303 /* strings used in many debug and warning messages */ 304 static const char wr_str[] = "write"; 305 static const char rd_str[] = "read"; 306 static const char wrg_str[] = "writing"; 307 static const char rdg_str[] = "reading"; 308 static const char *space_strs[] = { 309 "records", 310 "filemarks", 311 "sequential filemarks", 312 "eod", 313 "setmarks", 314 "sequential setmarks", 315 "Reserved", 316 "Reserved" 317 }; 318 static const char *load_strs[] = { 319 "unload", /* LD_UNLOAD 0 */ 320 "load", /* LD_LOAD 1 */ 321 "retension", /* LD_RETEN 2 */ 322 "load reten", /* LD_LOAD | LD_RETEN 3 */ 323 "eod", /* LD_EOT 4 */ 324 "load EOD", /* LD_LOAD | LD_EOT 5 */ 325 "reten EOD", /* LD_RETEN | LD_EOT 6 */ 326 "load reten EOD" /* LD_LOAD|LD_RETEN|LD_EOT 7 */ 327 "hold", /* LD_HOLD 8 */ 328 "load and hold" /* LD_LOAD | LD_HOLD 9 */ 329 }; 330 331 static const char *errstatenames[] = { 332 "COMMAND_DONE", 333 "COMMAND_DONE_ERROR", 334 "COMMAND_DONE_ERROR_RECOVERED", 335 "QUE_COMMAND", 336 "QUE_BUSY_COMMAND", 337 "QUE_SENSE", 338 "JUST_RETURN", 339 "COMMAND_DONE_EACCES", 340 "QUE_LAST_COMMAND", 341 "COMMAND_TIMEOUT", 342 "PATH_FAILED", 343 "DEVICE_RESET", 344 "DEVICE_TAMPER", 345 "ATTEMPT_RETRY" 346 }; 347 348 const char *bogusID = "Unknown Media ID"; 349 350 /* default density offsets in the table above */ 351 #define DEF_BLANK 0 352 #define DEF_NOREWIND 1 353 #define DEF_BSD 2 354 #define DEF_BSD_NR 3 355 356 /* Sense Key, ASC/ASCQ for which tape ejection is needed */ 357 358 static struct tape_failure_code { 359 uchar_t key; 360 uchar_t add_code; 361 uchar_t qual_code; 362 } st_tape_failure_code[] = { 363 { KEY_HARDWARE_ERROR, 0x15, 0x01}, 364 { KEY_HARDWARE_ERROR, 0x44, 0x00}, 365 { KEY_HARDWARE_ERROR, 0x53, 0x00}, 366 { KEY_HARDWARE_ERROR, 0x53, 0x01}, 367 { KEY_NOT_READY, 0x53, 0x00}, 368 { 0xff} 369 }; 370 371 /* clean bit position and mask */ 372 373 static struct cln_bit_position { 374 ushort_t cln_bit_byte; 375 uchar_t cln_bit_mask; 376 } st_cln_bit_position[] = { 377 { 21, 0x08}, 378 { 70, 0xc0}, 379 { 18, 0x81} /* 80 bit indicates in bit mode, 1 bit clean light is on */ 380 }; 381 382 /* 383 * architecture dependent allocation restrictions. For x86, we'll set 384 * dma_attr_addr_hi to st_max_phys_addr and dma_attr_sgllen to 385 * st_sgl_size during _init(). 386 */ 387 #if defined(__sparc) 388 static ddi_dma_attr_t st_alloc_attr = { 389 DMA_ATTR_V0, /* version number */ 390 0x0, /* lowest usable address */ 391 0xFFFFFFFFull, /* high DMA address range */ 392 0xFFFFFFFFull, /* DMA counter register */ 393 1, /* DMA address alignment */ 394 1, /* DMA burstsizes */ 395 1, /* min effective DMA size */ 396 0xFFFFFFFFull, /* max DMA xfer size */ 397 0xFFFFFFFFull, /* segment boundary */ 398 1, /* s/g list length */ 399 512, /* granularity of device */ 400 0 /* DMA transfer flags */ 401 }; 402 #elif defined(__x86) 403 static ddi_dma_attr_t st_alloc_attr = { 404 DMA_ATTR_V0, /* version number */ 405 0x0, /* lowest usable address */ 406 0x0, /* high DMA address range [set in _init()] */ 407 0xFFFFull, /* DMA counter register */ 408 512, /* DMA address alignment */ 409 1, /* DMA burstsizes */ 410 1, /* min effective DMA size */ 411 0xFFFFFFFFull, /* max DMA xfer size */ 412 0xFFFFFFFFull, /* segment boundary */ 413 0, /* s/g list length */ 414 512, /* granularity of device [set in _init()] */ 415 0 /* DMA transfer flags */ 416 }; 417 uint64_t st_max_phys_addr = 0xFFFFFFFFull; 418 int st_sgl_size = 0xF; 419 420 #endif 421 422 /* 423 * Configuration Data: 424 * 425 * Device driver ops vector 426 */ 427 static int st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p); 428 static int st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p); 429 static int st_read(dev_t dev, struct uio *uio_p, cred_t *cred_p); 430 static int st_write(dev_t dev, struct uio *uio_p, cred_t *cred_p); 431 static int st_open(dev_t *devp, int flag, int otyp, cred_t *cred_p); 432 static int st_close(dev_t dev, int flag, int otyp, cred_t *cred_p); 433 static int st_strategy(struct buf *bp); 434 static int st_queued_strategy(buf_t *bp); 435 static int st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, 436 cred_t *cred_p, int *rval_p); 437 extern int nulldev(), nodev(); 438 439 static struct cb_ops st_cb_ops = { 440 st_open, /* open */ 441 st_close, /* close */ 442 st_queued_strategy, /* strategy Not Block device but async checks */ 443 nodev, /* print */ 444 nodev, /* dump */ 445 st_read, /* read */ 446 st_write, /* write */ 447 st_ioctl, /* ioctl */ 448 nodev, /* devmap */ 449 nodev, /* mmap */ 450 nodev, /* segmap */ 451 nochpoll, /* poll */ 452 ddi_prop_op, /* cb_prop_op */ 453 0, /* streamtab */ 454 D_64BIT | D_MP | D_NEW | D_HOTPLUG | 455 D_OPEN_RETURNS_EINTR, /* cb_flag */ 456 CB_REV, /* cb_rev */ 457 st_aread, /* async I/O read entry point */ 458 st_awrite /* async I/O write entry point */ 459 460 }; 461 462 static int st_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 463 void **result); 464 static int st_probe(dev_info_t *dev); 465 static int st_attach(dev_info_t *dev, ddi_attach_cmd_t cmd); 466 static int st_detach(dev_info_t *dev, ddi_detach_cmd_t cmd); 467 468 static struct dev_ops st_ops = { 469 DEVO_REV, /* devo_rev, */ 470 0, /* refcnt */ 471 st_info, /* info */ 472 nulldev, /* identify */ 473 st_probe, /* probe */ 474 st_attach, /* attach */ 475 st_detach, /* detach */ 476 nodev, /* reset */ 477 &st_cb_ops, /* driver operations */ 478 (struct bus_ops *)0, /* bus operations */ 479 nulldev, /* power */ 480 ddi_quiesce_not_needed, /* devo_quiesce */ 481 }; 482 483 /* 484 * Local Function Declarations 485 */ 486 static char *st_print_scsi_cmd(char cmd); 487 static void st_print_cdb(dev_info_t *dip, char *label, uint_t level, 488 char *title, char *cdb); 489 static void st_clean_print(dev_info_t *dev, char *label, uint_t level, 490 char *title, char *data, int len); 491 static int st_doattach(struct scsi_device *devp, int (*canwait)()); 492 static void st_known_tape_type(struct scsi_tape *un); 493 static int st_get_conf_from_st_dot_conf(struct scsi_tape *, char *, 494 struct st_drivetype *); 495 static int st_get_conf_from_st_conf_dot_c(struct scsi_tape *, char *, 496 struct st_drivetype *); 497 static int st_get_conf_from_tape_drive(struct scsi_tape *, char *, 498 struct st_drivetype *); 499 static int st_get_densities_from_tape_drive(struct scsi_tape *, 500 struct st_drivetype *); 501 static int st_get_timeout_values_from_tape_drive(struct scsi_tape *, 502 struct st_drivetype *); 503 static int st_get_timeouts_value(struct scsi_tape *, uchar_t, ushort_t *, 504 ushort_t); 505 static int st_get_default_conf(struct scsi_tape *, char *, 506 struct st_drivetype *); 507 static int st_rw(dev_t dev, struct uio *uio, int flag); 508 static int st_arw(dev_t dev, struct aio_req *aio, int flag); 509 static int st_find_eod(struct scsi_tape *un); 510 static int st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag); 511 static int st_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *, int flag); 512 static int st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag); 513 static int st_mtiocltop(struct scsi_tape *un, intptr_t arg, int flag); 514 static int st_do_mtioctop(struct scsi_tape *un, struct mtlop *mtop); 515 static void st_start(struct scsi_tape *un); 516 static int st_handle_start_busy(struct scsi_tape *un, struct buf *bp, 517 clock_t timeout_interval, int queued); 518 static int st_handle_intr_busy(struct scsi_tape *un, struct buf *bp, 519 clock_t timeout_interval); 520 static int st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp); 521 static void st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp); 522 static void st_init(struct scsi_tape *un); 523 static void st_make_cmd(struct scsi_tape *un, struct buf *bp, 524 int (*func)(caddr_t)); 525 static void st_make_uscsi_cmd(struct scsi_tape *, struct uscsi_cmd *, 526 struct buf *bp, int (*func)(caddr_t)); 527 static void st_intr(struct scsi_pkt *pkt); 528 static void st_set_state(struct scsi_tape *un, buf_t *bp); 529 static void st_test_append(struct buf *bp); 530 static int st_runout(caddr_t); 531 static int st_cmd(struct scsi_tape *un, int com, int64_t count, int wait); 532 static int st_setup_cmd(struct scsi_tape *un, buf_t *bp, int com, 533 int64_t count); 534 static int st_set_compression(struct scsi_tape *un); 535 static int st_write_fm(dev_t dev, int wfm); 536 static int st_determine_generic(struct scsi_tape *un); 537 static int st_determine_density(struct scsi_tape *un, int rw); 538 static int st_get_density(struct scsi_tape *un); 539 static int st_set_density(struct scsi_tape *un); 540 static int st_loadtape(struct scsi_tape *un); 541 static int st_modesense(struct scsi_tape *un); 542 static int st_modeselect(struct scsi_tape *un); 543 static errstate st_handle_incomplete(struct scsi_tape *un, struct buf *bp); 544 static int st_wrongtapetype(struct scsi_tape *un); 545 static errstate st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt); 546 static errstate st_handle_sense(struct scsi_tape *un, struct buf *bp, 547 tapepos_t *); 548 static errstate st_handle_autosense(struct scsi_tape *un, struct buf *bp, 549 tapepos_t *); 550 static int st_get_error_entry(struct scsi_tape *un, intptr_t arg, int flag); 551 static void st_update_error_stack(struct scsi_tape *un, struct scsi_pkt *pkt, 552 struct scsi_arq_status *cmd); 553 static void st_empty_error_stack(struct scsi_tape *un); 554 static errstate st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt, 555 struct scsi_arq_status *, tapepos_t *); 556 static int st_report_soft_errors(dev_t dev, int flag); 557 static void st_delayed_cv_broadcast(void *arg); 558 static int st_check_media(dev_t dev, enum mtio_state state); 559 static int st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp); 560 static void st_intr_restart(void *arg); 561 static void st_start_restart(void *arg); 562 static int st_gen_mode_sense(struct scsi_tape *un, ubufunc_t ubf, int page, 563 struct seq_mode *page_data, int page_size); 564 static int st_change_block_size(struct scsi_tape *un, uint32_t nblksz); 565 static int st_gen_mode_select(struct scsi_tape *un, ubufunc_t ubf, 566 struct seq_mode *page_data, int page_size); 567 static int st_read_block_limits(struct scsi_tape *un, 568 struct read_blklim *read_blk); 569 static int st_report_density_support(struct scsi_tape *un, 570 uchar_t *density_data, size_t buflen); 571 static int st_report_supported_operation(struct scsi_tape *un, 572 uchar_t *oper_data, uchar_t option_code, ushort_t service_action); 573 static int st_tape_init(struct scsi_tape *un); 574 static void st_flush(struct scsi_tape *un); 575 static void st_set_pe_errno(struct scsi_tape *un); 576 static void st_hba_unflush(struct scsi_tape *un); 577 static void st_turn_pe_on(struct scsi_tape *un); 578 static void st_turn_pe_off(struct scsi_tape *un); 579 static void st_set_pe_flag(struct scsi_tape *un); 580 static void st_clear_pe(struct scsi_tape *un); 581 static void st_wait_for_io(struct scsi_tape *un); 582 static int st_set_devconfig_page(struct scsi_tape *un, int compression_on); 583 static int st_set_datacomp_page(struct scsi_tape *un, int compression_on); 584 static int st_reserve_release(struct scsi_tape *un, int command, ubufunc_t ubf); 585 static int st_check_cdb_for_need_to_reserve(struct scsi_tape *un, uchar_t *cdb); 586 static int st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd, 587 int count); 588 static int st_take_ownership(struct scsi_tape *un, ubufunc_t ubf); 589 static int st_check_asc_ascq(struct scsi_tape *un); 590 static int st_check_clean_bit(struct scsi_tape *un); 591 static int st_check_alert_flags(struct scsi_tape *un); 592 static int st_check_sequential_clean_bit(struct scsi_tape *un); 593 static int st_check_sense_clean_bit(struct scsi_tape *un); 594 static int st_clear_unit_attentions(dev_t dev_instance, int max_trys); 595 static void st_calculate_timeouts(struct scsi_tape *un); 596 static writablity st_is_drive_worm(struct scsi_tape *un); 597 static int st_read_attributes(struct scsi_tape *un, uint16_t attribute, 598 void *buf, size_t size, ubufunc_t bufunc); 599 static int st_get_special_inquiry(struct scsi_tape *un, uchar_t size, 600 caddr_t dest, uchar_t page); 601 static int st_update_block_pos(struct scsi_tape *un, bufunc_t bf, 602 int post_space); 603 static int st_interpret_read_pos(struct scsi_tape const *un, tapepos_t *dest, 604 read_p_types type, size_t data_sz, const caddr_t responce, int post_space); 605 static int st_get_read_pos(struct scsi_tape *un, buf_t *bp); 606 static int st_logical_block_locate(struct scsi_tape *un, ubufunc_t ubf, 607 tapepos_t *pos, uint64_t lblk, uchar_t partition); 608 static int st_mtfsf_ioctl(struct scsi_tape *un, int64_t files); 609 static int st_mtfsr_ioctl(struct scsi_tape *un, int64_t count); 610 static int st_mtbsf_ioctl(struct scsi_tape *un, int64_t files); 611 static int st_mtnbsf_ioctl(struct scsi_tape *un, int64_t count); 612 static int st_mtbsr_ioctl(struct scsi_tape *un, int64_t num); 613 static int st_mtfsfm_ioctl(struct scsi_tape *un, int64_t cnt); 614 static int st_mtbsfm_ioctl(struct scsi_tape *un, int64_t cnt); 615 static int st_backward_space_files(struct scsi_tape *un, int64_t count, 616 int infront); 617 static int st_forward_space_files(struct scsi_tape *un, int64_t files); 618 static int st_scenic_route_to_begining_of_file(struct scsi_tape *un, 619 int32_t fileno); 620 static int st_space_to_begining_of_file(struct scsi_tape *un); 621 static int st_space_records(struct scsi_tape *un, int64_t records); 622 static int st_get_media_identification(struct scsi_tape *un, ubufunc_t bufunc); 623 static errstate st_command_recovery(struct scsi_tape *un, struct scsi_pkt *pkt, 624 errstate onentry); 625 static void st_recover(void *arg); 626 static void st_recov_cb(struct scsi_pkt *pkt); 627 static int st_rcmd(struct scsi_tape *un, int com, int64_t count, int wait); 628 static int st_uscsi_rcmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, 629 int flag); 630 static void st_add_recovery_info_to_pkt(struct scsi_tape *un, buf_t *bp, 631 struct scsi_pkt *cmd); 632 static int st_check_mode_for_change(struct scsi_tape *un, ubufunc_t ubf); 633 static int st_test_path_to_device(struct scsi_tape *un); 634 static int st_recovery_read_pos(struct scsi_tape *un, read_p_types type, 635 read_pos_data_t *raw); 636 static int st_recovery_get_position(struct scsi_tape *un, tapepos_t *read, 637 read_pos_data_t *raw); 638 static int st_compare_expected_position(struct scsi_tape *un, st_err_info *ei, 639 cmd_attribute const * cmd_att, tapepos_t *read); 640 static errstate st_recover_reissue_pkt(struct scsi_tape *us, 641 struct scsi_pkt *pkt); 642 static int st_transport(struct scsi_tape *un, struct scsi_pkt *pkt); 643 static buf_t *st_remove_from_queue(buf_t **head, buf_t **tail, buf_t *bp); 644 static void st_add_to_queue(buf_t **head, buf_t **tail, buf_t *end, buf_t *bp); 645 static int st_reset(struct scsi_tape *un, int reset_type); 646 static void st_reset_notification(caddr_t arg); 647 static const cmd_attribute *st_lookup_cmd_attribute(unsigned char cmd); 648 649 static int st_set_target_TLR_mode(struct scsi_tape *un, ubufunc_t ubf); 650 static int st_make_sure_mode_data_is_correct(struct scsi_tape *un, 651 ubufunc_t ubf); 652 653 #ifdef __x86 654 /* 655 * routines for I/O in big block size 656 */ 657 static void st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp); 658 static struct contig_mem *st_get_contig_mem(struct scsi_tape *un, size_t len, 659 int alloc_flags); 660 static int st_bigblk_xfer_done(struct buf *bp); 661 static struct buf *st_get_bigblk_bp(struct buf *bp); 662 #endif 663 static void st_print_position(dev_info_t *dev, char *label, uint_t level, 664 const char *comment, tapepos_t *pos); 665 666 /* 667 * error statistics create/update functions 668 */ 669 static int st_create_errstats(struct scsi_tape *, int); 670 static int st_validate_tapemarks(struct scsi_tape *un, ubufunc_t ubf, 671 tapepos_t *pos); 672 673 #ifdef STDEBUG 674 static void st_debug_cmds(struct scsi_tape *un, int com, int count, int wait); 675 #endif /* STDEBUG */ 676 static char *st_dev_name(dev_t dev); 677 678 #if !defined(lint) 679 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", 680 scsi_pkt buf uio scsi_cdb uscsi_cmd)) 681 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_extended_sense scsi_status)) 682 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", recov_info)) 683 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device)) 684 _NOTE(DATA_READABLE_WITHOUT_LOCK(st_drivetype scsi_address)) 685 #endif 686 687 /* 688 * autoconfiguration routines. 689 */ 690 691 static struct modldrv modldrv = { 692 &mod_driverops, /* Type of module. This one is a driver */ 693 "SCSI tape Driver", /* Name of the module. */ 694 &st_ops /* driver ops */ 695 }; 696 697 static struct modlinkage modlinkage = { 698 MODREV_1, &modldrv, NULL 699 }; 700 701 /* 702 * Notes on Post Reset Behavior in the tape driver: 703 * 704 * When the tape drive is opened, the driver attempts to make sure that 705 * the tape head is positioned exactly where it was left when it was last 706 * closed provided the medium is not changed. If the tape drive is 707 * opened in O_NDELAY mode, the repositioning (if necessary for any loss 708 * of position due to reset) will happen when the first tape operation or 709 * I/O occurs. The repositioning (if required) may not be possible under 710 * certain situations such as when the device firmware not able to report 711 * the medium change in the REQUEST SENSE data because of a reset or a 712 * misbehaving bus not allowing the reposition to happen. In such 713 * extraordinary situations, where the driver fails to position the head 714 * at its original position, it will fail the open the first time, to 715 * save the applications from overwriting the data. All further attempts 716 * to open the tape device will result in the driver attempting to load 717 * the tape at BOT (beginning of tape). Also a warning message to 718 * indicate that further attempts to open the tape device may result in 719 * the tape being loaded at BOT will be printed on the console. If the 720 * tape device is opened in O_NDELAY mode, failure to restore the 721 * original tape head position, will result in the failure of the first 722 * tape operation or I/O, Further, the driver will invalidate its 723 * internal tape position which will necessitate the applications to 724 * validate the position by using either a tape positioning ioctl (such 725 * as MTREW) or closing and reopening the tape device. 726 * 727 */ 728 729 int 730 _init(void) 731 { 732 int e; 733 734 if (((e = ddi_soft_state_init(&st_state, 735 sizeof (struct scsi_tape), ST_MAXUNIT)) != 0)) { 736 return (e); 737 } 738 739 if ((e = mod_install(&modlinkage)) != 0) { 740 ddi_soft_state_fini(&st_state); 741 } else { 742 #ifdef STDEBUG 743 mutex_init(&st_debug_mutex, NULL, MUTEX_DRIVER, NULL); 744 #endif 745 746 #if defined(__x86) 747 /* set the max physical address for iob allocs on x86 */ 748 st_alloc_attr.dma_attr_addr_hi = st_max_phys_addr; 749 750 /* 751 * set the sgllen for iob allocs on x86. If this is set less 752 * than the number of pages the buffer will take 753 * (taking into account alignment), it would force the 754 * allocator to try and allocate contiguous pages. 755 */ 756 st_alloc_attr.dma_attr_sgllen = st_sgl_size; 757 #endif 758 } 759 760 return (e); 761 } 762 763 int 764 _fini(void) 765 { 766 int e; 767 768 if ((e = mod_remove(&modlinkage)) != 0) { 769 return (e); 770 } 771 772 #ifdef STDEBUG 773 mutex_destroy(&st_debug_mutex); 774 #endif 775 776 ddi_soft_state_fini(&st_state); 777 778 return (e); 779 } 780 781 int 782 _info(struct modinfo *modinfop) 783 { 784 return (mod_info(&modlinkage, modinfop)); 785 } 786 787 788 static int 789 st_probe(dev_info_t *devi) 790 { 791 int instance; 792 struct scsi_device *devp; 793 int rval; 794 795 #if !defined(__sparc) 796 char *tape_prop; 797 int tape_prop_len; 798 #endif 799 800 ST_ENTR(devi, st_probe); 801 802 /* If self identifying device */ 803 if (ddi_dev_is_sid(devi) == DDI_SUCCESS) { 804 return (DDI_PROBE_DONTCARE); 805 } 806 807 #if !defined(__sparc) 808 /* 809 * Since some x86 HBAs have devnodes that look like SCSI as 810 * far as we can tell but aren't really SCSI (DADK, like mlx) 811 * we check for the presence of the "tape" property. 812 */ 813 if (ddi_prop_op(DDI_DEV_T_NONE, devi, PROP_LEN_AND_VAL_ALLOC, 814 DDI_PROP_CANSLEEP, "tape", 815 (caddr_t)&tape_prop, &tape_prop_len) != DDI_PROP_SUCCESS) { 816 return (DDI_PROBE_FAILURE); 817 } 818 if (strncmp(tape_prop, "sctp", tape_prop_len) != 0) { 819 kmem_free(tape_prop, tape_prop_len); 820 return (DDI_PROBE_FAILURE); 821 } 822 kmem_free(tape_prop, tape_prop_len); 823 #endif 824 825 devp = ddi_get_driver_private(devi); 826 instance = ddi_get_instance(devi); 827 828 if (ddi_get_soft_state(st_state, instance) != NULL) { 829 return (DDI_PROBE_PARTIAL); 830 } 831 832 833 /* 834 * Turn around and call probe routine to see whether 835 * we actually have a tape at this SCSI nexus. 836 */ 837 if (scsi_probe(devp, NULL_FUNC) == SCSIPROBE_EXISTS) { 838 839 /* 840 * In checking the whole inq_dtype byte we are looking at both 841 * the Peripheral Qualifier and the Peripheral Device Type. 842 * For this driver we are only interested in sequential devices 843 * that are connected or capable if connecting to this logical 844 * unit. 845 */ 846 if (devp->sd_inq->inq_dtype == 847 (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) { 848 ST_DEBUG6(devi, st_label, SCSI_DEBUG, 849 "probe exists\n"); 850 rval = DDI_PROBE_SUCCESS; 851 } else { 852 rval = DDI_PROBE_FAILURE; 853 } 854 } else { 855 ST_DEBUG6(devi, st_label, SCSI_DEBUG, 856 "probe failure: nothing there\n"); 857 rval = DDI_PROBE_FAILURE; 858 } 859 scsi_unprobe(devp); 860 return (rval); 861 } 862 863 static int 864 st_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 865 { 866 int instance; 867 int wide; 868 int dev_instance; 869 int ret_status; 870 struct scsi_device *devp; 871 int node_ix; 872 struct scsi_tape *un; 873 874 ST_ENTR(devi, st_attach); 875 876 devp = ddi_get_driver_private(devi); 877 instance = ddi_get_instance(devi); 878 879 switch (cmd) { 880 case DDI_ATTACH: 881 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 882 "tape-command-recovery-disable", 0) != 0) { 883 st_recov_sz = sizeof (pkt_info); 884 } 885 if (st_doattach(devp, SLEEP_FUNC) == DDI_FAILURE) { 886 return (DDI_FAILURE); 887 } 888 break; 889 case DDI_RESUME: 890 /* 891 * Suspend/Resume 892 * 893 * When the driver suspended, there might be 894 * outstanding cmds and therefore we need to 895 * reset the suspended flag and resume the scsi 896 * watch thread and restart commands and timeouts 897 */ 898 899 if (!(un = ddi_get_soft_state(st_state, instance))) { 900 return (DDI_FAILURE); 901 } 902 dev_instance = ((un->un_dev == 0) ? MTMINOR(instance) : 903 un->un_dev); 904 905 mutex_enter(ST_MUTEX); 906 907 un->un_throttle = un->un_max_throttle; 908 un->un_tids_at_suspend = 0; 909 un->un_pwr_mgmt = ST_PWR_NORMAL; 910 911 if (un->un_swr_token) { 912 scsi_watch_resume(un->un_swr_token); 913 } 914 915 /* 916 * Restart timeouts 917 */ 918 if ((un->un_tids_at_suspend & ST_DELAY_TID) != 0) { 919 mutex_exit(ST_MUTEX); 920 un->un_delay_tid = timeout( 921 st_delayed_cv_broadcast, un, 922 drv_usectohz((clock_t) 923 MEDIA_ACCESS_DELAY)); 924 mutex_enter(ST_MUTEX); 925 } 926 927 if (un->un_tids_at_suspend & ST_HIB_TID) { 928 mutex_exit(ST_MUTEX); 929 un->un_hib_tid = timeout(st_intr_restart, un, 930 ST_STATUS_BUSY_TIMEOUT); 931 mutex_enter(ST_MUTEX); 932 } 933 934 ret_status = st_clear_unit_attentions(dev_instance, 5); 935 936 /* 937 * now check if we need to restore the tape position 938 */ 939 if ((un->un_suspend_pos.pmode != invalid) && 940 ((un->un_suspend_pos.fileno > 0) || 941 (un->un_suspend_pos.blkno > 0)) || 942 (un->un_suspend_pos.lgclblkno > 0)) { 943 if (ret_status != 0) { 944 /* 945 * tape didn't get good TUR 946 * just print out error messages 947 */ 948 scsi_log(ST_DEVINFO, st_label, CE_WARN, 949 "st_attach-RESUME: tape failure " 950 " tape position will be lost"); 951 } else { 952 /* this prints errors */ 953 (void) st_validate_tapemarks(un, 954 st_uscsi_cmd, &un->un_suspend_pos); 955 } 956 /* 957 * there are no retries, if there is an error 958 * we don't know if the tape has changed 959 */ 960 un->un_suspend_pos.pmode = invalid; 961 } 962 963 /* now we are ready to start up any queued I/Os */ 964 if (un->un_ncmds || un->un_quef) { 965 st_start(un); 966 } 967 968 cv_broadcast(&un->un_suspend_cv); 969 mutex_exit(ST_MUTEX); 970 return (DDI_SUCCESS); 971 972 default: 973 return (DDI_FAILURE); 974 } 975 976 un = ddi_get_soft_state(st_state, instance); 977 978 ST_DEBUG(devi, st_label, SCSI_DEBUG, 979 "st_attach: instance=%x\n", instance); 980 981 /* 982 * Add a zero-length attribute to tell the world we support 983 * kernel ioctls (for layered drivers) 984 */ 985 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, 986 DDI_KERNEL_IOCTL, NULL, 0); 987 988 ddi_report_dev((dev_info_t *)devi); 989 990 /* 991 * If it's a SCSI-2 tape drive which supports wide, 992 * tell the host adapter to use wide. 993 */ 994 wide = ((devp->sd_inq->inq_rdf == RDF_SCSI2) && 995 (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) ? 1 : 0; 996 997 if (scsi_ifsetcap(ROUTE, "wide-xfer", wide, 1) == 1) { 998 ST_DEBUG(devi, st_label, SCSI_DEBUG, 999 "Wide Transfer %s\n", wide ? "enabled" : "disabled"); 1000 } 1001 1002 /* 1003 * enable autorequest sense; keep the rq packet around in case 1004 * the autorequest sense fails because of a busy condition 1005 * do a getcap first in case the capability is not variable 1006 */ 1007 if (scsi_ifgetcap(ROUTE, "auto-rqsense", 1) == 1) { 1008 un->un_arq_enabled = 1; 1009 } else { 1010 un->un_arq_enabled = 1011 ((scsi_ifsetcap(ROUTE, "auto-rqsense", 1, 1) == 1) ? 1 : 0); 1012 } 1013 1014 ST_DEBUG(devi, st_label, SCSI_DEBUG, "auto request sense %s\n", 1015 (un->un_arq_enabled ? "enabled" : "disabled")); 1016 1017 un->un_untagged_qing = 1018 (scsi_ifgetcap(ROUTE, "untagged-qing", 0) == 1); 1019 1020 /* 1021 * XXX - This is just for 2.6. to tell users that write buffering 1022 * has gone away. 1023 */ 1024 if (un->un_arq_enabled && un->un_untagged_qing) { 1025 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 1026 "tape-driver-buffering", 0) != 0) { 1027 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1028 "Write Data Buffering has been depricated. Your " 1029 "applications should continue to work normally.\n" 1030 " But, they should ported to use Asynchronous " 1031 " I/O\n" 1032 " For more information, read about " 1033 " tape-driver-buffering " 1034 "property in the st(7d) man page\n"); 1035 } 1036 } 1037 1038 un->un_max_throttle = un->un_throttle = un->un_last_throttle = 1; 1039 un->un_flush_on_errors = 0; 1040 un->un_mkr_pkt = (struct scsi_pkt *)NULL; 1041 1042 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1043 "throttle=%x, max_throttle = %x\n", 1044 un->un_throttle, un->un_max_throttle); 1045 1046 /* initialize persistent errors to nil */ 1047 un->un_persistence = 0; 1048 un->un_persist_errors = 0; 1049 1050 /* 1051 * Get dma-max from HBA driver. If it is not defined, use 64k 1052 */ 1053 un->un_maxdma = scsi_ifgetcap(&devp->sd_address, "dma-max", 1); 1054 if (un->un_maxdma == -1) { 1055 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1056 "Received a value that looked like -1. Using 64k maxdma"); 1057 un->un_maxdma = (64 * ONE_K); 1058 } 1059 1060 #ifdef __x86 1061 /* 1062 * for x86, the device may be able to DMA more than the system will 1063 * allow under some circumstances. We need account for both the HBA's 1064 * and system's contraints. 1065 * 1066 * Get the maximum DMA under worse case conditions. e.g. looking at the 1067 * device constraints, the max copy buffer size, and the worse case 1068 * fragmentation. NOTE: this may differ from dma-max since dma-max 1069 * doesn't take the worse case framentation into account. 1070 * 1071 * e.g. a device may be able to DMA 16MBytes, but can only DMA 1MByte 1072 * if none of the pages are contiguous. Keeping track of both of these 1073 * values allows us to support larger tape block sizes on some devices. 1074 */ 1075 un->un_maxdma_arch = scsi_ifgetcap(&devp->sd_address, "dma-max-arch", 1076 1); 1077 1078 /* 1079 * If the dma-max-arch capability is not implemented, or the value 1080 * comes back higher than what was reported in dma-max, use dma-max. 1081 */ 1082 if ((un->un_maxdma_arch == -1) || 1083 ((uint_t)un->un_maxdma < (uint_t)un->un_maxdma_arch)) { 1084 un->un_maxdma_arch = un->un_maxdma; 1085 } 1086 #endif 1087 1088 /* 1089 * Get the max allowable cdb size 1090 */ 1091 un->un_max_cdb_sz = 1092 scsi_ifgetcap(&devp->sd_address, "max-cdb-length", 1); 1093 if (un->un_max_cdb_sz < CDB_GROUP0) { 1094 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1095 "HBA reported max-cdb-length as %d\n", un->un_max_cdb_sz); 1096 un->un_max_cdb_sz = CDB_GROUP4; /* optimistic default */ 1097 } 1098 1099 if (strcmp(ddi_driver_name(ddi_get_parent(ST_DEVINFO)), "scsi_vhci")) { 1100 un->un_multipath = 0; 1101 } else { 1102 un->un_multipath = 1; 1103 } 1104 1105 un->un_maxbsize = MAXBSIZE_UNKNOWN; 1106 1107 un->un_mediastate = MTIO_NONE; 1108 un->un_HeadClean = TAPE_ALERT_SUPPORT_UNKNOWN; 1109 1110 /* 1111 * initialize kstats 1112 */ 1113 un->un_stats = kstat_create("st", instance, NULL, "tape", 1114 KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT); 1115 if (un->un_stats) { 1116 un->un_stats->ks_lock = ST_MUTEX; 1117 kstat_install(un->un_stats); 1118 } 1119 (void) st_create_errstats(un, instance); 1120 1121 /* 1122 * find the drive type for this target 1123 */ 1124 mutex_enter(ST_MUTEX); 1125 un->un_dev = MTMINOR(instance); 1126 st_known_tape_type(un); 1127 un->un_dev = 0; 1128 mutex_exit(ST_MUTEX); 1129 1130 for (node_ix = 0; node_ix < ST_NUM_MEMBERS(st_minor_data); node_ix++) { 1131 int minor; 1132 char *name; 1133 1134 name = st_minor_data[node_ix].name; 1135 minor = st_minor_data[node_ix].minor; 1136 1137 /* 1138 * For default devices set the density to the 1139 * preferred default density for this device. 1140 */ 1141 if (node_ix <= DEF_BSD_NR) { 1142 minor |= un->un_dp->default_density; 1143 } 1144 minor |= MTMINOR(instance); 1145 1146 if (ddi_create_minor_node(devi, name, S_IFCHR, minor, 1147 DDI_NT_TAPE, NULL) == DDI_SUCCESS) { 1148 continue; 1149 } 1150 1151 ddi_remove_minor_node(devi, NULL); 1152 1153 (void) scsi_reset_notify(ROUTE, SCSI_RESET_CANCEL, 1154 st_reset_notification, (caddr_t)un); 1155 cv_destroy(&un->un_clscv); 1156 cv_destroy(&un->un_sbuf_cv); 1157 cv_destroy(&un->un_queue_cv); 1158 cv_destroy(&un->un_state_cv); 1159 #ifdef __x86 1160 cv_destroy(&un->un_contig_mem_cv); 1161 #endif 1162 cv_destroy(&un->un_suspend_cv); 1163 cv_destroy(&un->un_tape_busy_cv); 1164 cv_destroy(&un->un_recov_buf_cv); 1165 if (un->un_recov_taskq) { 1166 ddi_taskq_destroy(un->un_recov_taskq); 1167 } 1168 if (un->un_sbufp) { 1169 freerbuf(un->un_sbufp); 1170 } 1171 if (un->un_recov_buf) { 1172 freerbuf(un->un_recov_buf); 1173 } 1174 if (un->un_uscsi_rqs_buf) { 1175 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1176 } 1177 if (un->un_mspl) { 1178 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1179 } 1180 if (un->un_dp_size) { 1181 kmem_free(un->un_dp, un->un_dp_size); 1182 } 1183 if (un->un_state) { 1184 kstat_delete(un->un_stats); 1185 } 1186 if (un->un_errstats) { 1187 kstat_delete(un->un_errstats); 1188 } 1189 1190 scsi_destroy_pkt(un->un_rqs); 1191 scsi_free_consistent_buf(un->un_rqs_bp); 1192 ddi_soft_state_free(st_state, instance); 1193 devp->sd_private = NULL; 1194 devp->sd_sense = NULL; 1195 1196 ddi_prop_remove_all(devi); 1197 return (DDI_FAILURE); 1198 } 1199 1200 return (DDI_SUCCESS); 1201 } 1202 1203 /* 1204 * st_detach: 1205 * 1206 * we allow a detach if and only if: 1207 * - no tape is currently inserted 1208 * - tape position is at BOT or unknown 1209 * (if it is not at BOT then a no rewind 1210 * device was opened and we have to preserve state) 1211 * - it must be in a closed state : no timeouts or scsi_watch requests 1212 * will exist if it is closed, so we don't need to check for 1213 * them here. 1214 */ 1215 /*ARGSUSED*/ 1216 static int 1217 st_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) 1218 { 1219 int instance; 1220 int result; 1221 struct scsi_device *devp; 1222 struct scsi_tape *un; 1223 clock_t wait_cmds_complete; 1224 1225 ST_ENTR(devi, st_detach); 1226 1227 instance = ddi_get_instance(devi); 1228 1229 if (!(un = ddi_get_soft_state(st_state, instance))) { 1230 return (DDI_FAILURE); 1231 } 1232 1233 mutex_enter(ST_MUTEX); 1234 1235 /* 1236 * Clear error entry stack 1237 */ 1238 st_empty_error_stack(un); 1239 1240 mutex_exit(ST_MUTEX); 1241 1242 switch (cmd) { 1243 1244 case DDI_DETACH: 1245 /* 1246 * Undo what we did in st_attach & st_doattach, 1247 * freeing resources and removing things we installed. 1248 * The system framework guarantees we are not active 1249 * with this devinfo node in any other entry points at 1250 * this time. 1251 */ 1252 1253 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1254 "st_detach: instance=%x, un=%p\n", instance, 1255 (void *)un); 1256 1257 if (((un->un_dp->options & ST_UNLOADABLE) == 0) || 1258 ((un->un_rsvd_status & ST_APPLICATION_RESERVATIONS) != 0) || 1259 (un->un_ncmds != 0) || (un->un_quef != NULL) || 1260 (un->un_state != ST_STATE_CLOSED)) { 1261 /* 1262 * we cannot unload some targets because the 1263 * inquiry returns junk unless immediately 1264 * after a reset 1265 */ 1266 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 1267 "cannot unload instance %x\n", instance); 1268 un->un_unit_attention_flags |= 4; 1269 return (DDI_FAILURE); 1270 } 1271 1272 /* 1273 * if the tape has been removed then we may unload; 1274 * do a test unit ready and if it returns NOT READY 1275 * then we assume that it is safe to unload. 1276 * as a side effect, pmode may be set to invalid if the 1277 * the test unit ready fails; 1278 * also un_state may be set to non-closed, so reset it 1279 */ 1280 if ((un->un_dev) && /* Been opened since attach */ 1281 ((un->un_pos.pmode == legacy) && 1282 (un->un_pos.fileno > 0) || /* Known position not rewound */ 1283 (un->un_pos.blkno != 0)) || /* Or within first file */ 1284 ((un->un_pos.pmode == logical) && 1285 (un->un_pos.lgclblkno > 0))) { 1286 mutex_enter(ST_MUTEX); 1287 /* 1288 * Send Test Unit Ready in the hopes that if 1289 * the drive is not in the state we think it is. 1290 * And the state will be changed so it can be detached. 1291 * If the command fails to reach the device and 1292 * the drive was not rewound or unloaded we want 1293 * to fail the detach till a user command fails 1294 * where after the detach will succead. 1295 */ 1296 result = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 1297 /* 1298 * After TUR un_state may be set to non-closed, 1299 * so reset it back. 1300 */ 1301 un->un_state = ST_STATE_CLOSED; 1302 mutex_exit(ST_MUTEX); 1303 } 1304 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1305 "un_status=%x, fileno=%x, blkno=%x\n", 1306 un->un_status, un->un_pos.fileno, un->un_pos.blkno); 1307 1308 /* 1309 * check again: 1310 * if we are not at BOT then it is not safe to unload 1311 */ 1312 if ((un->un_dev) && /* Been opened since attach */ 1313 (result != EACCES) && /* drive is use by somebody */ 1314 ((((un->un_pos.pmode == legacy) && 1315 (un->un_pos.fileno > 0) || /* Known position not rewound */ 1316 (un->un_pos.blkno != 0)) || /* Or within first file */ 1317 ((un->un_pos.pmode == logical) && 1318 (un->un_pos.lgclblkno > 0))) && 1319 ((un->un_state == ST_STATE_CLOSED) && 1320 (un->un_laststate == ST_STATE_CLOSING)))) { 1321 1322 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1323 "cannot detach: pmode=%d fileno=0x%x, blkno=0x%x" 1324 " lgclblkno=0x%"PRIx64"\n", un->un_pos.pmode, 1325 un->un_pos.fileno, un->un_pos.blkno, 1326 un->un_pos.lgclblkno); 1327 un->un_unit_attention_flags |= 4; 1328 return (DDI_FAILURE); 1329 } 1330 1331 /* 1332 * Just To make sure that we have released the 1333 * tape unit . 1334 */ 1335 if (un->un_dev && (un->un_rsvd_status & ST_RESERVE) && 1336 !DEVI_IS_DEVICE_REMOVED(devi)) { 1337 mutex_enter(ST_MUTEX); 1338 (void) st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 1339 mutex_exit(ST_MUTEX); 1340 } 1341 1342 /* 1343 * now remove other data structures allocated in st_doattach() 1344 */ 1345 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1346 "destroying/freeing\n"); 1347 1348 (void) scsi_reset_notify(ROUTE, SCSI_RESET_CANCEL, 1349 st_reset_notification, (caddr_t)un); 1350 cv_destroy(&un->un_clscv); 1351 cv_destroy(&un->un_sbuf_cv); 1352 cv_destroy(&un->un_queue_cv); 1353 cv_destroy(&un->un_suspend_cv); 1354 cv_destroy(&un->un_tape_busy_cv); 1355 cv_destroy(&un->un_recov_buf_cv); 1356 1357 if (un->un_recov_taskq) { 1358 ddi_taskq_destroy(un->un_recov_taskq); 1359 } 1360 1361 if (un->un_hib_tid) { 1362 (void) untimeout(un->un_hib_tid); 1363 un->un_hib_tid = 0; 1364 } 1365 1366 if (un->un_delay_tid) { 1367 (void) untimeout(un->un_delay_tid); 1368 un->un_delay_tid = 0; 1369 } 1370 cv_destroy(&un->un_state_cv); 1371 1372 #ifdef __x86 1373 cv_destroy(&un->un_contig_mem_cv); 1374 1375 if (un->un_contig_mem_hdl != NULL) { 1376 ddi_dma_free_handle(&un->un_contig_mem_hdl); 1377 } 1378 #endif 1379 if (un->un_sbufp) { 1380 freerbuf(un->un_sbufp); 1381 } 1382 if (un->un_recov_buf) { 1383 freerbuf(un->un_recov_buf); 1384 } 1385 if (un->un_uscsi_rqs_buf) { 1386 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1387 } 1388 if (un->un_mspl) { 1389 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1390 } 1391 if (un->un_rqs) { 1392 scsi_destroy_pkt(un->un_rqs); 1393 scsi_free_consistent_buf(un->un_rqs_bp); 1394 } 1395 if (un->un_mkr_pkt) { 1396 scsi_destroy_pkt(un->un_mkr_pkt); 1397 } 1398 if (un->un_arq_enabled) { 1399 (void) scsi_ifsetcap(ROUTE, "auto-rqsense", 0, 1); 1400 } 1401 if (un->un_dp_size) { 1402 kmem_free(un->un_dp, un->un_dp_size); 1403 } 1404 if (un->un_stats) { 1405 kstat_delete(un->un_stats); 1406 un->un_stats = (kstat_t *)0; 1407 } 1408 if (un->un_errstats) { 1409 kstat_delete(un->un_errstats); 1410 un->un_errstats = (kstat_t *)0; 1411 } 1412 if (un->un_media_id_len) { 1413 kmem_free(un->un_media_id, un->un_media_id_len); 1414 } 1415 devp = ST_SCSI_DEVP; 1416 ddi_soft_state_free(st_state, instance); 1417 devp->sd_private = NULL; 1418 devp->sd_sense = NULL; 1419 scsi_unprobe(devp); 1420 ddi_prop_remove_all(devi); 1421 ddi_remove_minor_node(devi, NULL); 1422 ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach done\n"); 1423 return (DDI_SUCCESS); 1424 1425 case DDI_SUSPEND: 1426 1427 /* 1428 * Suspend/Resume 1429 * 1430 * To process DDI_SUSPEND, we must do the following: 1431 * 1432 * - check ddi_removing_power to see if power will be turned 1433 * off. if so, return DDI_FAILURE 1434 * - check if we are already suspended, 1435 * if so, return DDI_FAILURE 1436 * - check if device state is CLOSED, 1437 * if not, return DDI_FAILURE. 1438 * - wait until outstanding operations complete 1439 * - save tape state 1440 * - block new operations 1441 * - cancel pending timeouts 1442 * 1443 */ 1444 1445 if (ddi_removing_power(devi)) { 1446 return (DDI_FAILURE); 1447 } 1448 1449 if (un->un_dev == 0) 1450 un->un_dev = MTMINOR(instance); 1451 1452 mutex_enter(ST_MUTEX); 1453 1454 /* 1455 * Shouldn't already be suspended, if so return failure 1456 */ 1457 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 1458 mutex_exit(ST_MUTEX); 1459 return (DDI_FAILURE); 1460 } 1461 if (un->un_state != ST_STATE_CLOSED) { 1462 mutex_exit(ST_MUTEX); 1463 return (DDI_FAILURE); 1464 } 1465 1466 /* 1467 * Wait for all outstanding I/O's to complete 1468 * 1469 * we wait on both ncmds and the wait queue for times 1470 * when we are flushing after persistent errors are 1471 * flagged, which is when ncmds can be 0, and the 1472 * queue can still have I/O's. This way we preserve 1473 * order of biodone's. 1474 */ 1475 wait_cmds_complete = ddi_get_lbolt(); 1476 wait_cmds_complete += 1477 st_wait_cmds_complete * drv_usectohz(1000000); 1478 while (un->un_ncmds || un->un_quef || 1479 (un->un_state == ST_STATE_RESOURCE_WAIT)) { 1480 1481 if (cv_timedwait(&un->un_tape_busy_cv, ST_MUTEX, 1482 wait_cmds_complete) == -1) { 1483 /* 1484 * Time expired then cancel the command 1485 */ 1486 if (st_reset(un, RESET_LUN) == 0) { 1487 if (un->un_last_throttle) { 1488 un->un_throttle = 1489 un->un_last_throttle; 1490 } 1491 mutex_exit(ST_MUTEX); 1492 return (DDI_FAILURE); 1493 } else { 1494 break; 1495 } 1496 } 1497 } 1498 1499 /* 1500 * DDI_SUSPEND says that the system "may" power down, we 1501 * remember the file and block number before rewinding. 1502 * we also need to save state before issuing 1503 * any WRITE_FILE_MARK command. 1504 */ 1505 (void) st_update_block_pos(un, st_cmd, 0); 1506 COPY_POS(&un->un_suspend_pos, &un->un_pos); 1507 1508 1509 /* 1510 * Issue a zero write file fmk command to tell the drive to 1511 * flush any buffered tape marks 1512 */ 1513 (void) st_cmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD); 1514 1515 /* 1516 * Because not all tape drives correctly implement buffer 1517 * flushing with the zero write file fmk command, issue a 1518 * synchronous rewind command to force data flushing. 1519 * st_validate_tapemarks() will do a rewind during DDI_RESUME 1520 * anyway. 1521 */ 1522 (void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 1523 1524 /* stop any new operations */ 1525 un->un_pwr_mgmt = ST_PWR_SUSPENDED; 1526 un->un_throttle = 0; 1527 1528 /* 1529 * cancel any outstanding timeouts 1530 */ 1531 if (un->un_delay_tid) { 1532 timeout_id_t temp_id = un->un_delay_tid; 1533 un->un_delay_tid = 0; 1534 un->un_tids_at_suspend |= ST_DELAY_TID; 1535 mutex_exit(ST_MUTEX); 1536 (void) untimeout(temp_id); 1537 mutex_enter(ST_MUTEX); 1538 } 1539 1540 if (un->un_hib_tid) { 1541 timeout_id_t temp_id = un->un_hib_tid; 1542 un->un_hib_tid = 0; 1543 un->un_tids_at_suspend |= ST_HIB_TID; 1544 mutex_exit(ST_MUTEX); 1545 (void) untimeout(temp_id); 1546 mutex_enter(ST_MUTEX); 1547 } 1548 1549 /* 1550 * Suspend the scsi_watch_thread 1551 */ 1552 if (un->un_swr_token) { 1553 opaque_t temp_token = un->un_swr_token; 1554 mutex_exit(ST_MUTEX); 1555 scsi_watch_suspend(temp_token); 1556 } else { 1557 mutex_exit(ST_MUTEX); 1558 } 1559 1560 return (DDI_SUCCESS); 1561 1562 default: 1563 ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach failed\n"); 1564 return (DDI_FAILURE); 1565 } 1566 } 1567 1568 1569 /* ARGSUSED */ 1570 static int 1571 st_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 1572 { 1573 dev_t dev; 1574 struct scsi_tape *un; 1575 int instance, error; 1576 1577 ST_ENTR(dip, st_info); 1578 1579 switch (infocmd) { 1580 case DDI_INFO_DEVT2DEVINFO: 1581 dev = (dev_t)arg; 1582 instance = MTUNIT(dev); 1583 if ((un = ddi_get_soft_state(st_state, instance)) == NULL) 1584 return (DDI_FAILURE); 1585 *result = (void *) ST_DEVINFO; 1586 error = DDI_SUCCESS; 1587 break; 1588 case DDI_INFO_DEVT2INSTANCE: 1589 dev = (dev_t)arg; 1590 instance = MTUNIT(dev); 1591 *result = (void *)(uintptr_t)instance; 1592 error = DDI_SUCCESS; 1593 break; 1594 default: 1595 error = DDI_FAILURE; 1596 } 1597 return (error); 1598 } 1599 1600 static int 1601 st_doattach(struct scsi_device *devp, int (*canwait)()) 1602 { 1603 struct scsi_tape *un = NULL; 1604 recov_info *ri; 1605 int km_flags = (canwait != NULL_FUNC) ? KM_SLEEP : KM_NOSLEEP; 1606 int instance; 1607 size_t rlen; 1608 1609 ST_FUNC(devp->sd_dev, st_doattach); 1610 /* 1611 * Call the routine scsi_probe to do some of the dirty work. 1612 * If the INQUIRY command succeeds, the field sd_inq in the 1613 * device structure will be filled in. 1614 */ 1615 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1616 "st_doattach(): probing\n"); 1617 1618 if (scsi_probe(devp, canwait) == SCSIPROBE_EXISTS) { 1619 1620 /* 1621 * In checking the whole inq_dtype byte we are looking at both 1622 * the Peripheral Qualifier and the Peripheral Device Type. 1623 * For this driver we are only interested in sequential devices 1624 * that are connected or capable if connecting to this logical 1625 * unit. 1626 */ 1627 if (devp->sd_inq->inq_dtype == 1628 (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) { 1629 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1630 "probe exists\n"); 1631 } else { 1632 /* Something there but not a tape device */ 1633 scsi_unprobe(devp); 1634 return (DDI_FAILURE); 1635 } 1636 } else { 1637 /* Nothing there */ 1638 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1639 "probe failure: nothing there\n"); 1640 scsi_unprobe(devp); 1641 return (DDI_FAILURE); 1642 } 1643 1644 1645 /* 1646 * The actual unit is present. 1647 * Now is the time to fill in the rest of our info.. 1648 */ 1649 instance = ddi_get_instance(devp->sd_dev); 1650 1651 if (ddi_soft_state_zalloc(st_state, instance) != DDI_SUCCESS) { 1652 goto error; 1653 } 1654 un = ddi_get_soft_state(st_state, instance); 1655 1656 ASSERT(un != NULL); 1657 1658 un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL, 1659 MAX_SENSE_LENGTH, B_READ, canwait, NULL); 1660 if (un->un_rqs_bp == NULL) { 1661 goto error; 1662 } 1663 un->un_rqs = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp, 1664 CDB_GROUP0, 1, st_recov_sz, PKT_CONSISTENT, canwait, NULL); 1665 if (!un->un_rqs) { 1666 goto error; 1667 } 1668 ASSERT(un->un_rqs->pkt_resid == 0); 1669 devp->sd_sense = 1670 (struct scsi_extended_sense *)un->un_rqs_bp->b_un.b_addr; 1671 ASSERT(geterror(un->un_rqs_bp) == NULL); 1672 1673 (void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs->pkt_cdbp, 1674 SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0); 1675 FILL_SCSI1_LUN(devp, un->un_rqs); 1676 un->un_rqs->pkt_flags |= (FLAG_SENSING | FLAG_HEAD | FLAG_NODISCON); 1677 un->un_rqs->pkt_time = st_io_time; 1678 un->un_rqs->pkt_comp = st_intr; 1679 ri = (recov_info *)un->un_rqs->pkt_private; 1680 if (st_recov_sz == sizeof (recov_info)) { 1681 ri->privatelen = sizeof (recov_info); 1682 } else { 1683 ri->privatelen = sizeof (pkt_info); 1684 } 1685 1686 un->un_sbufp = getrbuf(km_flags); 1687 un->un_recov_buf = getrbuf(km_flags); 1688 1689 un->un_uscsi_rqs_buf = kmem_alloc(SENSE_LENGTH, KM_SLEEP); 1690 1691 /* 1692 * use i_ddi_mem_alloc() for now until we have an interface to allocate 1693 * memory for DMA which doesn't require a DMA handle. ddi_iopb_alloc() 1694 * is obsolete and we want more flexibility in controlling the DMA 1695 * address constraints. 1696 */ 1697 (void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr, 1698 sizeof (struct seq_mode), ((km_flags == KM_SLEEP) ? 1 : 0), 0, 1699 NULL, (caddr_t *)&un->un_mspl, &rlen, NULL); 1700 1701 (void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr, 1702 sizeof (read_pos_data_t), ((km_flags == KM_SLEEP) ? 1 : 0), 0, 1703 NULL, (caddr_t *)&un->un_read_pos_data, &rlen, NULL); 1704 1705 if (!un->un_sbufp || !un->un_mspl || !un->un_read_pos_data) { 1706 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, 1707 "probe partial failure: no space\n"); 1708 goto error; 1709 } 1710 1711 bzero(un->un_mspl, sizeof (struct seq_mode)); 1712 1713 cv_init(&un->un_sbuf_cv, NULL, CV_DRIVER, NULL); 1714 cv_init(&un->un_queue_cv, NULL, CV_DRIVER, NULL); 1715 cv_init(&un->un_clscv, NULL, CV_DRIVER, NULL); 1716 cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL); 1717 #ifdef __x86 1718 cv_init(&un->un_contig_mem_cv, NULL, CV_DRIVER, NULL); 1719 #endif 1720 1721 /* Initialize power managemnet condition variable */ 1722 cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL); 1723 cv_init(&un->un_tape_busy_cv, NULL, CV_DRIVER, NULL); 1724 cv_init(&un->un_recov_buf_cv, NULL, CV_DRIVER, NULL); 1725 1726 un->un_recov_taskq = ddi_taskq_create(devp->sd_dev, 1727 "un_recov_taskq", 1, TASKQ_DEFAULTPRI, km_flags); 1728 1729 ASSERT(un->un_recov_taskq != NULL); 1730 1731 un->un_pos.pmode = invalid; 1732 un->un_sd = devp; 1733 un->un_swr_token = (opaque_t)NULL; 1734 un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE; 1735 un->un_wormable = st_is_drive_worm; 1736 un->un_media_id_method = st_get_media_identification; 1737 /* 1738 * setting long a initial as it contains logical file info. 1739 * support for long format is mandatory but many drive don't do it. 1740 */ 1741 un->un_read_pos_type = LONG_POS; 1742 1743 un->un_suspend_pos.pmode = invalid; 1744 1745 st_add_recovery_info_to_pkt(un, un->un_rqs_bp, un->un_rqs); 1746 1747 #ifdef __x86 1748 if (ddi_dma_alloc_handle(ST_DEVINFO, &st_contig_mem_dma_attr, 1749 DDI_DMA_SLEEP, NULL, &un->un_contig_mem_hdl) != DDI_SUCCESS) { 1750 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, 1751 "allocation of contiguous memory dma handle failed!"); 1752 un->un_contig_mem_hdl = NULL; 1753 goto error; 1754 } 1755 #endif 1756 1757 /* 1758 * Since this driver manages devices with "remote" hardware, 1759 * i.e. the devices themselves have no "reg" properties, 1760 * the SUSPEND/RESUME commands in detach/attach will not be 1761 * called by the power management framework unless we request 1762 * it by creating a "pm-hardware-state" property and setting it 1763 * to value "needs-suspend-resume". 1764 */ 1765 if (ddi_prop_update_string(DDI_DEV_T_NONE, devp->sd_dev, 1766 "pm-hardware-state", "needs-suspend-resume") != 1767 DDI_PROP_SUCCESS) { 1768 1769 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1770 "ddi_prop_update(\"pm-hardware-state\") failed\n"); 1771 goto error; 1772 } 1773 1774 if (ddi_prop_create(DDI_DEV_T_NONE, devp->sd_dev, DDI_PROP_CANSLEEP, 1775 "no-involuntary-power-cycles", NULL, 0) != DDI_PROP_SUCCESS) { 1776 1777 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1778 "ddi_prop_create(\"no-involuntary-power-cycles\") " 1779 "failed\n"); 1780 goto error; 1781 } 1782 1783 (void) scsi_reset_notify(ROUTE, SCSI_RESET_NOTIFY, 1784 st_reset_notification, (caddr_t)un); 1785 1786 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, "attach success\n"); 1787 return (DDI_SUCCESS); 1788 1789 error: 1790 devp->sd_sense = NULL; 1791 1792 ddi_remove_minor_node(devp->sd_dev, NULL); 1793 if (un) { 1794 if (un->un_mspl) { 1795 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1796 } 1797 if (un->un_read_pos_data) { 1798 i_ddi_mem_free((caddr_t)un->un_read_pos_data, 0); 1799 } 1800 if (un->un_sbufp) { 1801 freerbuf(un->un_sbufp); 1802 } 1803 if (un->un_recov_buf) { 1804 freerbuf(un->un_recov_buf); 1805 } 1806 if (un->un_uscsi_rqs_buf) { 1807 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1808 } 1809 #ifdef __x86 1810 if (un->un_contig_mem_hdl != NULL) { 1811 ddi_dma_free_handle(&un->un_contig_mem_hdl); 1812 } 1813 #endif 1814 if (un->un_rqs) { 1815 scsi_destroy_pkt(un->un_rqs); 1816 } 1817 1818 if (un->un_rqs_bp) { 1819 scsi_free_consistent_buf(un->un_rqs_bp); 1820 } 1821 1822 ddi_soft_state_free(st_state, instance); 1823 devp->sd_private = NULL; 1824 } 1825 1826 if (devp->sd_inq) { 1827 scsi_unprobe(devp); 1828 } 1829 return (DDI_FAILURE); 1830 } 1831 1832 typedef int 1833 (*cfg_functp)(struct scsi_tape *, char *vidpid, struct st_drivetype *); 1834 1835 static cfg_functp config_functs[] = { 1836 st_get_conf_from_st_dot_conf, 1837 st_get_conf_from_st_conf_dot_c, 1838 st_get_conf_from_tape_drive, 1839 st_get_default_conf 1840 }; 1841 1842 1843 /* 1844 * determine tape type, using tape-config-list or built-in table or 1845 * use a generic tape config entry 1846 */ 1847 static void 1848 st_known_tape_type(struct scsi_tape *un) 1849 { 1850 struct st_drivetype *dp; 1851 cfg_functp *config_funct; 1852 uchar_t reserved; 1853 1854 ST_FUNC(ST_DEVINFO, st_known_tape_type); 1855 1856 reserved = (un->un_rsvd_status & ST_RESERVE) ? ST_RESERVE 1857 : ST_RELEASE; 1858 1859 /* 1860 * XXX: Emulex MT-02 (and emulators) predates SCSI-1 and has 1861 * no vid & pid inquiry data. So, we provide one. 1862 */ 1863 if (ST_INQUIRY->inq_len == 0 || 1864 (bcmp("\0\0\0\0\0\0\0\0", ST_INQUIRY->inq_vid, 8) == 0)) { 1865 (void) strcpy((char *)ST_INQUIRY->inq_vid, ST_MT02_NAME); 1866 } 1867 1868 if (un->un_dp_size == 0) { 1869 un->un_dp_size = sizeof (struct st_drivetype); 1870 dp = kmem_zalloc((size_t)un->un_dp_size, KM_SLEEP); 1871 un->un_dp = dp; 1872 } else { 1873 dp = un->un_dp; 1874 } 1875 1876 un->un_dp->non_motion_timeout = st_io_time; 1877 /* 1878 * Loop through the configuration methods till one works. 1879 */ 1880 for (config_funct = &config_functs[0]; ; config_funct++) { 1881 if ((*config_funct)(un, ST_INQUIRY->inq_vid, dp)) { 1882 break; 1883 } 1884 } 1885 1886 /* 1887 * If we didn't just make up this configuration and 1888 * all the density codes are the same.. 1889 * Set Auto Density over ride. 1890 */ 1891 if (*config_funct != st_get_default_conf) { 1892 /* 1893 * If this device is one that is configured and all 1894 * densities are the same, This saves doing gets and set 1895 * that yield nothing. 1896 */ 1897 if ((dp->densities[0]) == (dp->densities[1]) && 1898 (dp->densities[0]) == (dp->densities[2]) && 1899 (dp->densities[0]) == (dp->densities[3])) { 1900 1901 dp->options |= ST_AUTODEN_OVERRIDE; 1902 } 1903 } 1904 1905 1906 /* 1907 * Store tape drive characteristics. 1908 */ 1909 un->un_status = 0; 1910 un->un_attached = 1; 1911 un->un_init_options = dp->options; 1912 1913 /* setup operation time-outs based on options */ 1914 st_calculate_timeouts(un); 1915 1916 /* TLR support */ 1917 if (un->un_dp->type != ST_TYPE_INVALID) { 1918 int result; 1919 1920 /* try and enable TLR */ 1921 un->un_tlr_flag = TLR_SAS_ONE_DEVICE; 1922 result = st_set_target_TLR_mode(un, st_uscsi_cmd); 1923 if (result == EACCES) { 1924 /* 1925 * From attach command failed. 1926 * Set dp type so is run again on open. 1927 */ 1928 un->un_dp->type = ST_TYPE_INVALID; 1929 un->un_tlr_flag = TLR_NOT_KNOWN; 1930 } else if (result == 0) { 1931 if (scsi_ifgetcap(&un->un_sd->sd_address, 1932 "tran-layer-retries", 1) == -1) { 1933 un->un_tlr_flag = TLR_NOT_SUPPORTED; 1934 (void) st_set_target_TLR_mode(un, st_uscsi_cmd); 1935 } else { 1936 un->un_tlr_flag = TLR_SAS_ONE_DEVICE; 1937 } 1938 } else { 1939 un->un_tlr_flag = TLR_NOT_SUPPORTED; 1940 } 1941 } 1942 1943 /* make sure if we are supposed to be variable, make it variable */ 1944 if (dp->options & ST_VARIABLE) { 1945 dp->bsize = 0; 1946 } 1947 1948 if (reserved != ((un->un_rsvd_status & ST_RESERVE) ? ST_RESERVE 1949 : ST_RELEASE)) { 1950 (void) st_reserve_release(un, reserved, st_uscsi_cmd); 1951 } 1952 1953 un->un_unit_attention_flags |= 1; 1954 1955 scsi_log(ST_DEVINFO, st_label, CE_NOTE, "?<%s>\n", dp->name); 1956 1957 } 1958 1959 1960 typedef struct { 1961 int mask; 1962 int bottom; 1963 int top; 1964 char *name; 1965 } conf_limit; 1966 1967 static const conf_limit conf_limits[] = { 1968 1969 -1, 1, 2, "conf version", 1970 -1, MT_ISTS, ST_LAST_TYPE, "drive type", 1971 -1, 0, 0xffffff, "block size", 1972 ST_VALID_OPTS, 0, ST_VALID_OPTS, "options", 1973 -1, 0, 4, "number of densities", 1974 -1, 0, UINT8_MAX, "density code", 1975 -1, 0, 3, "default density", 1976 -1, 0, UINT16_MAX, "non motion timeout", 1977 -1, 0, UINT16_MAX, "I/O timeout", 1978 -1, 0, UINT16_MAX, "space timeout", 1979 -1, 0, UINT16_MAX, "load timeout", 1980 -1, 0, UINT16_MAX, "unload timeout", 1981 -1, 0, UINT16_MAX, "erase timeout", 1982 0, 0, 0, NULL 1983 }; 1984 1985 static int 1986 st_validate_conf_data(struct scsi_tape *un, int *list, int list_len, 1987 const char *conf_name) 1988 { 1989 int dens; 1990 int ndens; 1991 int value; 1992 int type; 1993 int count; 1994 const conf_limit *limit = &conf_limits[0]; 1995 1996 ST_FUNC(ST_DEVINFO, st_validate_conf_data); 1997 1998 ST_DEBUG3(ST_DEVINFO, st_label, CE_NOTE, 1999 "Checking %d entrys total with %d densities\n", list_len, list[4]); 2000 2001 count = list_len; 2002 type = *list; 2003 for (; count && limit->name; count--, list++, limit++) { 2004 2005 value = *list; 2006 if (value & ~limit->mask) { 2007 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2008 "%s %s value invalid bits set: 0x%X\n", 2009 conf_name, limit->name, value & ~limit->mask); 2010 *list &= limit->mask; 2011 } else if (value < limit->bottom) { 2012 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2013 "%s %s value too low: value = %d limit %d\n", 2014 conf_name, limit->name, value, limit->bottom); 2015 } else if (value > limit->top) { 2016 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2017 "%s %s value too high: value = %d limit %d\n", 2018 conf_name, limit->name, value, limit->top); 2019 } else { 2020 ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT, 2021 "%s %s value = 0x%X\n", 2022 conf_name, limit->name, value); 2023 } 2024 2025 /* If not the number of densities continue */ 2026 if (limit != &conf_limits[4]) { 2027 continue; 2028 } 2029 2030 /* If number of densities is not in range can't use config */ 2031 if (value < limit->bottom || value > limit->top) { 2032 return (-1); 2033 } 2034 2035 ndens = min(value, NDENSITIES); 2036 if ((type == 1) && (list_len - ndens) != 6) { 2037 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2038 "%s conf version 1 with %d densities has %d items" 2039 " should have %d", 2040 conf_name, ndens, list_len, 6 + ndens); 2041 } else if ((type == 2) && (list_len - ndens) != 13) { 2042 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2043 "%s conf version 2 with %d densities has %d items" 2044 " should have %d", 2045 conf_name, ndens, list_len, 13 + ndens); 2046 } 2047 2048 limit++; 2049 for (dens = 0; dens < ndens && count; dens++) { 2050 count--; 2051 list++; 2052 value = *list; 2053 if (value < limit->bottom) { 2054 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2055 "%s density[%d] value too low: value =" 2056 " 0x%X limit 0x%X\n", 2057 conf_name, dens, value, limit->bottom); 2058 } else if (value > limit->top) { 2059 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2060 "%s density[%d] value too high: value =" 2061 " 0x%X limit 0x%X\n", 2062 conf_name, dens, value, limit->top); 2063 } else { 2064 ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT, 2065 "%s density[%d] value = 0x%X\n", 2066 conf_name, dens, value); 2067 } 2068 } 2069 } 2070 2071 return (0); 2072 } 2073 2074 static int 2075 st_get_conf_from_st_dot_conf(struct scsi_tape *un, char *vidpid, 2076 struct st_drivetype *dp) 2077 { 2078 caddr_t config_list = NULL; 2079 caddr_t data_list = NULL; 2080 int *data_ptr; 2081 caddr_t vidptr, prettyptr, datanameptr; 2082 size_t vidlen, prettylen, datanamelen, tripletlen = 0; 2083 int config_list_len, data_list_len, len, i; 2084 int version; 2085 int found = 0; 2086 2087 ST_FUNC(ST_DEVINFO, st_get_conf_from_st_dot_conf); 2088 2089 /* 2090 * Determine type of tape controller. Type is determined by 2091 * checking the vendor ids of the earlier inquiry command and 2092 * comparing those with vids in tape-config-list defined in st.conf 2093 */ 2094 if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, DDI_PROP_DONTPASS, 2095 "tape-config-list", (caddr_t)&config_list, &config_list_len) 2096 != DDI_PROP_SUCCESS) { 2097 return (found); 2098 } 2099 2100 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 2101 "st_get_conf_from_st_dot_conf(): st.conf has tape-config-list\n"); 2102 2103 /* 2104 * Compare vids in each triplet - if it matches, get value for 2105 * data_name and contruct a st_drivetype struct 2106 * tripletlen is not set yet! 2107 */ 2108 for (len = config_list_len, vidptr = config_list; 2109 len > 0; 2110 vidptr += tripletlen, len -= tripletlen) { 2111 2112 vidlen = strlen(vidptr); 2113 prettyptr = vidptr + vidlen + 1; 2114 prettylen = strlen(prettyptr); 2115 datanameptr = prettyptr + prettylen + 1; 2116 datanamelen = strlen(datanameptr); 2117 tripletlen = vidlen + prettylen + datanamelen + 3; 2118 2119 if (vidlen == 0) { 2120 continue; 2121 } 2122 2123 /* 2124 * If inquiry vid dosen't match this triplets vid, 2125 * try the next. 2126 */ 2127 if (strncasecmp(vidpid, vidptr, vidlen)) { 2128 continue; 2129 } 2130 2131 /* 2132 * if prettylen is zero then use the vid string 2133 */ 2134 if (prettylen == 0) { 2135 prettyptr = vidptr; 2136 prettylen = vidlen; 2137 } 2138 2139 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2140 "vid = %s, pretty=%s, dataname = %s\n", 2141 vidptr, prettyptr, datanameptr); 2142 2143 /* 2144 * get the data list 2145 */ 2146 if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, 0, 2147 datanameptr, (caddr_t)&data_list, 2148 &data_list_len) != DDI_PROP_SUCCESS) { 2149 /* 2150 * Error in getting property value 2151 * print warning! 2152 */ 2153 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2154 "data property (%s) has no value\n", 2155 datanameptr); 2156 continue; 2157 } 2158 2159 /* 2160 * now initialize the st_drivetype struct 2161 */ 2162 (void) strncpy(dp->name, prettyptr, ST_NAMESIZE - 1); 2163 dp->length = (int)min(vidlen, (VIDPIDLEN - 1)); 2164 (void) strncpy(dp->vid, vidptr, dp->length); 2165 data_ptr = (int *)data_list; 2166 /* 2167 * check if data is enough for version, type, 2168 * bsize, options, # of densities, density1, 2169 * density2, ..., default_density 2170 */ 2171 if ((data_list_len < 5 * sizeof (int)) || 2172 (data_list_len < 6 * sizeof (int) + 2173 *(data_ptr + 4) * sizeof (int))) { 2174 /* 2175 * print warning and skip to next triplet. 2176 */ 2177 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2178 "data property (%s) incomplete\n", 2179 datanameptr); 2180 kmem_free(data_list, data_list_len); 2181 continue; 2182 } 2183 2184 if (st_validate_conf_data(un, data_ptr, 2185 data_list_len / sizeof (int), datanameptr)) { 2186 kmem_free(data_list, data_list_len); 2187 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2188 "data property (%s) rejected\n", 2189 datanameptr); 2190 continue; 2191 } 2192 2193 /* 2194 * check version 2195 */ 2196 version = *data_ptr++; 2197 if (version != 1 && version != 2) { 2198 /* print warning but accept it */ 2199 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2200 "Version # for data property (%s) " 2201 "not set to 1 or 2\n", datanameptr); 2202 } 2203 2204 dp->type = *data_ptr++; 2205 dp->bsize = *data_ptr++; 2206 dp->options = *data_ptr++; 2207 dp->options |= ST_DYNAMIC; 2208 len = *data_ptr++; 2209 for (i = 0; i < NDENSITIES; i++) { 2210 if (i < len) { 2211 dp->densities[i] = *data_ptr++; 2212 } 2213 } 2214 dp->default_density = *data_ptr << 3; 2215 if (version == 2 && 2216 data_list_len >= (13 + len) * sizeof (int)) { 2217 data_ptr++; 2218 dp->non_motion_timeout = *data_ptr++; 2219 dp->io_timeout = *data_ptr++; 2220 dp->rewind_timeout = *data_ptr++; 2221 dp->space_timeout = *data_ptr++; 2222 dp->load_timeout = *data_ptr++; 2223 dp->unload_timeout = *data_ptr++; 2224 dp->erase_timeout = *data_ptr++; 2225 } 2226 kmem_free(data_list, data_list_len); 2227 found = 1; 2228 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2229 "found in st.conf: vid = %s, pretty=%s\n", 2230 dp->vid, dp->name); 2231 break; 2232 } 2233 2234 /* 2235 * free up the memory allocated by ddi_getlongprop 2236 */ 2237 if (config_list) { 2238 kmem_free(config_list, config_list_len); 2239 } 2240 return (found); 2241 } 2242 2243 static int 2244 st_get_conf_from_st_conf_dot_c(struct scsi_tape *un, char *vidpid, 2245 struct st_drivetype *dp) 2246 { 2247 int i; 2248 2249 ST_FUNC(ST_DEVINFO, st_get_conf_from_st_conf_dot_c); 2250 /* 2251 * Determine type of tape controller. Type is determined by 2252 * checking the result of the earlier inquiry command and 2253 * comparing vendor ids with strings in a table declared in st_conf.c. 2254 */ 2255 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2256 "st_get_conf_from_st_conf_dot_c(): looking at st_drivetypes\n"); 2257 2258 for (i = 0; i < st_ndrivetypes; i++) { 2259 if (st_drivetypes[i].length == 0) { 2260 continue; 2261 } 2262 if (strncasecmp(vidpid, st_drivetypes[i].vid, 2263 st_drivetypes[i].length)) { 2264 continue; 2265 } 2266 bcopy(&st_drivetypes[i], dp, sizeof (st_drivetypes[i])); 2267 return (1); 2268 } 2269 return (0); 2270 } 2271 2272 static int 2273 st_get_conf_from_tape_drive(struct scsi_tape *un, char *vidpid, 2274 struct st_drivetype *dp) 2275 { 2276 int bsize; 2277 ulong_t maxbsize; 2278 caddr_t buf; 2279 struct st_drivetype *tem_dp; 2280 struct read_blklim *blklim; 2281 int rval; 2282 int i; 2283 2284 ST_FUNC(ST_DEVINFO, st_get_conf_from_tape_drive); 2285 2286 /* 2287 * Determine the type of tape controller. Type is determined by 2288 * sending SCSI commands to tape drive and deriving the type from 2289 * the returned data. 2290 */ 2291 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2292 "st_get_conf_from_tape_drive(): asking tape drive\n"); 2293 2294 tem_dp = kmem_zalloc(sizeof (struct st_drivetype), KM_SLEEP); 2295 2296 /* 2297 * Make up a name 2298 */ 2299 bcopy(vidpid, tem_dp->name, VIDPIDLEN); 2300 tem_dp->name[VIDPIDLEN] = '\0'; 2301 tem_dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1)); 2302 (void) strncpy(tem_dp->vid, ST_INQUIRY->inq_vid, tem_dp->length); 2303 /* 2304 * 'clean' vendor and product strings of non-printing chars 2305 */ 2306 for (i = 0; i < VIDPIDLEN - 1; i ++) { 2307 if (tem_dp->name[i] < ' ' || tem_dp->name[i] > '~') { 2308 tem_dp->name[i] = '.'; 2309 } 2310 } 2311 2312 /* 2313 * MODE SENSE to determine block size. 2314 */ 2315 un->un_dp->options |= ST_MODE_SEL_COMP | ST_UNLOADABLE; 2316 rval = st_modesense(un); 2317 if (rval) { 2318 if (rval == EACCES) { 2319 un->un_dp->type = ST_TYPE_INVALID; 2320 rval = 1; 2321 } else { 2322 un->un_dp->options &= ~ST_MODE_SEL_COMP; 2323 rval = 0; 2324 } 2325 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2326 "st_get_conf_from_tape_drive(): fail to mode sense\n"); 2327 goto exit; 2328 } 2329 2330 /* Can mode sense page 0x10 or 0xf */ 2331 tem_dp->options |= ST_MODE_SEL_COMP; 2332 bsize = (un->un_mspl->high_bl << 16) | 2333 (un->un_mspl->mid_bl << 8) | 2334 (un->un_mspl->low_bl); 2335 2336 if (bsize == 0) { 2337 tem_dp->options |= ST_VARIABLE; 2338 tem_dp->bsize = 0; 2339 } else if (bsize > ST_MAXRECSIZE_FIXED) { 2340 rval = st_change_block_size(un, 0); 2341 if (rval) { 2342 if (rval == EACCES) { 2343 un->un_dp->type = ST_TYPE_INVALID; 2344 rval = 1; 2345 } else { 2346 rval = 0; 2347 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2348 "st_get_conf_from_tape_drive(): " 2349 "Fixed record size is too large and" 2350 "cannot switch to variable record size"); 2351 } 2352 goto exit; 2353 } 2354 tem_dp->options |= ST_VARIABLE; 2355 } else { 2356 rval = st_change_block_size(un, 0); 2357 if (rval == 0) { 2358 tem_dp->options |= ST_VARIABLE; 2359 tem_dp->bsize = 0; 2360 } else if (rval != EACCES) { 2361 tem_dp->bsize = bsize; 2362 } else { 2363 un->un_dp->type = ST_TYPE_INVALID; 2364 rval = 1; 2365 goto exit; 2366 } 2367 } 2368 2369 /* 2370 * If READ BLOCk LIMITS works and upper block size limit is 2371 * more than 64K, ST_NO_RECSIZE_LIMIT is supported. 2372 */ 2373 blklim = kmem_zalloc(sizeof (struct read_blklim), KM_SLEEP); 2374 rval = st_read_block_limits(un, blklim); 2375 if (rval) { 2376 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2377 "st_get_conf_from_tape_drive(): " 2378 "fail to read block limits.\n"); 2379 rval = 0; 2380 kmem_free(blklim, sizeof (struct read_blklim)); 2381 goto exit; 2382 } 2383 maxbsize = (blklim->max_hi << 16) + 2384 (blklim->max_mid << 8) + blklim->max_lo; 2385 if (maxbsize > ST_MAXRECSIZE_VARIABLE) { 2386 tem_dp->options |= ST_NO_RECSIZE_LIMIT; 2387 } 2388 kmem_free(blklim, sizeof (struct read_blklim)); 2389 2390 /* 2391 * Inquiry VPD page 0xb0 to see if the tape drive supports WORM 2392 */ 2393 buf = kmem_zalloc(6, KM_SLEEP); 2394 rval = st_get_special_inquiry(un, 6, buf, 0xb0); 2395 if (rval) { 2396 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2397 "st_get_conf_from_tape_drive(): " 2398 "fail to read vitial inquiry.\n"); 2399 rval = 0; 2400 kmem_free(buf, 6); 2401 goto exit; 2402 } 2403 if (buf[4] & 1) { 2404 tem_dp->options |= ST_WORMABLE; 2405 } 2406 kmem_free(buf, 6); 2407 2408 /* Assume BSD BSR KNOWS_EOD */ 2409 tem_dp->options |= ST_BSF | ST_BSR | ST_KNOWS_EOD | ST_UNLOADABLE; 2410 tem_dp->max_rretries = -1; 2411 tem_dp->max_wretries = -1; 2412 2413 /* 2414 * Decide the densities supported by tape drive by sending 2415 * REPORT DENSITY SUPPORT command. 2416 */ 2417 if (st_get_densities_from_tape_drive(un, tem_dp) == 0) { 2418 goto exit; 2419 } 2420 2421 /* 2422 * Decide the timeout values for several commands by sending 2423 * REPORT SUPPORTED OPERATION CODES command. 2424 */ 2425 rval = st_get_timeout_values_from_tape_drive(un, tem_dp); 2426 if (rval == 0 || ((rval == 1) && (tem_dp->type == ST_TYPE_INVALID))) { 2427 goto exit; 2428 } 2429 2430 bcopy(tem_dp, dp, sizeof (struct st_drivetype)); 2431 rval = 1; 2432 2433 exit: 2434 un->un_status = KEY_NO_SENSE; 2435 kmem_free(tem_dp, sizeof (struct st_drivetype)); 2436 return (rval); 2437 } 2438 2439 static int 2440 st_get_densities_from_tape_drive(struct scsi_tape *un, 2441 struct st_drivetype *dp) 2442 { 2443 int i, p; 2444 size_t buflen; 2445 ushort_t des_len; 2446 uchar_t *den_header; 2447 uchar_t num_den; 2448 uchar_t den[NDENSITIES]; 2449 uchar_t deflt[NDENSITIES]; 2450 struct report_density_desc *den_desc; 2451 2452 ST_FUNC(ST_DEVINFO, st_get_densities_from_type_drive); 2453 2454 /* 2455 * Since we have no idea how many densitiy support entries 2456 * will be returned, we send the command firstly assuming 2457 * there is only one. Then we can decide the number of 2458 * entries by available density support length. If multiple 2459 * entries exist, we will resend the command with enough 2460 * buffer size. 2461 */ 2462 buflen = sizeof (struct report_density_header) + 2463 sizeof (struct report_density_desc); 2464 den_header = kmem_zalloc(buflen, KM_SLEEP); 2465 if (st_report_density_support(un, den_header, buflen) != 0) { 2466 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2467 "st_get_conf_from_tape_drive(): fail to report density.\n"); 2468 kmem_free(den_header, buflen); 2469 return (0); 2470 } 2471 des_len = 2472 BE_16(((struct report_density_header *)den_header)->ava_dens_len); 2473 num_den = (des_len - 2) / sizeof (struct report_density_desc); 2474 2475 if (num_den > 1) { 2476 kmem_free(den_header, buflen); 2477 buflen = sizeof (struct report_density_header) + 2478 sizeof (struct report_density_desc) * num_den; 2479 den_header = kmem_zalloc(buflen, KM_SLEEP); 2480 if (st_report_density_support(un, den_header, buflen) != 0) { 2481 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2482 "st_get_conf_from_tape_drive(): " 2483 "fail to report density.\n"); 2484 kmem_free(den_header, buflen); 2485 return (0); 2486 } 2487 } 2488 2489 den_desc = (struct report_density_desc *)(den_header 2490 + sizeof (struct report_density_header)); 2491 2492 /* 2493 * Decide the drive type by assigning organization 2494 */ 2495 for (i = 0; i < ST_NUM_MEMBERS(st_vid_dt); i ++) { 2496 if (strncmp(st_vid_dt[i].vid, (char *)(den_desc->ass_org), 2497 8) == 0) { 2498 dp->type = st_vid_dt[i].type; 2499 break; 2500 } 2501 } 2502 if (i == ST_NUM_MEMBERS(st_vid_dt)) { 2503 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2504 "st_get_conf_from_tape_drive(): " 2505 "can't find match of assigned ort.\n"); 2506 kmem_free(den_header, buflen); 2507 return (0); 2508 } 2509 2510 /* 2511 * The tape drive may support many tape formats, but the st driver 2512 * supports only the four highest densities. Since density code 2513 * values are returned by ascending sequence, we start from the 2514 * last entry of density support data block descriptor. 2515 */ 2516 p = 0; 2517 den_desc += num_den - 1; 2518 for (i = 0; i < num_den && p < NDENSITIES; i ++, den_desc --) { 2519 if ((den_desc->pri_den != 0) && (den_desc->wrtok)) { 2520 if (p != 0) { 2521 if (den_desc->pri_den >= den[p - 1]) { 2522 continue; 2523 } 2524 } 2525 den[p] = den_desc->pri_den; 2526 deflt[p] = den_desc->deflt; 2527 p ++; 2528 } 2529 } 2530 2531 switch (p) { 2532 case 0: 2533 bzero(dp->densities, NDENSITIES); 2534 dp->options |= ST_AUTODEN_OVERRIDE; 2535 dp->default_density = MT_DENSITY4; 2536 break; 2537 2538 case 1: 2539 (void) memset(dp->densities, den[0], NDENSITIES); 2540 dp->options |= ST_AUTODEN_OVERRIDE; 2541 dp->default_density = MT_DENSITY4; 2542 break; 2543 2544 case 2: 2545 dp->densities[0] = den[1]; 2546 dp->densities[1] = den[1]; 2547 dp->densities[2] = den[0]; 2548 dp->densities[3] = den[0]; 2549 if (deflt[0]) { 2550 dp->default_density = MT_DENSITY4; 2551 } else { 2552 dp->default_density = MT_DENSITY2; 2553 } 2554 break; 2555 2556 case 3: 2557 dp->densities[0] = den[2]; 2558 dp->densities[1] = den[1]; 2559 dp->densities[2] = den[0]; 2560 dp->densities[3] = den[0]; 2561 if (deflt[0]) { 2562 dp->default_density = MT_DENSITY4; 2563 } else if (deflt[1]) { 2564 dp->default_density = MT_DENSITY2; 2565 } else { 2566 dp->default_density = MT_DENSITY1; 2567 } 2568 break; 2569 2570 default: 2571 for (i = p; i > p - NDENSITIES; i --) { 2572 dp->densities[i - 1] = den[p - i]; 2573 } 2574 if (deflt[0]) { 2575 dp->default_density = MT_DENSITY4; 2576 } else if (deflt[1]) { 2577 dp->default_density = MT_DENSITY3; 2578 } else if (deflt[2]) { 2579 dp->default_density = MT_DENSITY2; 2580 } else { 2581 dp->default_density = MT_DENSITY1; 2582 } 2583 break; 2584 } 2585 2586 bzero(dp->mediatype, NDENSITIES); 2587 2588 kmem_free(den_header, buflen); 2589 return (1); 2590 } 2591 2592 static int 2593 st_get_timeout_values_from_tape_drive(struct scsi_tape *un, 2594 struct st_drivetype *dp) 2595 { 2596 ushort_t timeout; 2597 int rval; 2598 2599 ST_FUNC(ST_DEVINFO, st_get_timeout_values_from_type_drive); 2600 2601 rval = st_get_timeouts_value(un, SCMD_ERASE, &timeout, 0); 2602 if (rval) { 2603 if (rval == EACCES) { 2604 un->un_dp->type = ST_TYPE_INVALID; 2605 dp->type = ST_TYPE_INVALID; 2606 return (1); 2607 } 2608 return (0); 2609 } 2610 dp->erase_timeout = timeout; 2611 2612 rval = st_get_timeouts_value(un, SCMD_READ, &timeout, 0); 2613 if (rval) { 2614 if (rval == EACCES) { 2615 un->un_dp->type = ST_TYPE_INVALID; 2616 dp->type = ST_TYPE_INVALID; 2617 return (1); 2618 } 2619 return (0); 2620 } 2621 dp->io_timeout = timeout; 2622 2623 rval = st_get_timeouts_value(un, SCMD_WRITE, &timeout, 0); 2624 if (rval) { 2625 if (rval == EACCES) { 2626 un->un_dp->type = ST_TYPE_INVALID; 2627 dp->type = ST_TYPE_INVALID; 2628 return (1); 2629 } 2630 return (0); 2631 } 2632 dp->io_timeout = max(dp->io_timeout, timeout); 2633 2634 rval = st_get_timeouts_value(un, SCMD_SPACE, &timeout, 0); 2635 if (rval) { 2636 if (rval == EACCES) { 2637 un->un_dp->type = ST_TYPE_INVALID; 2638 dp->type = ST_TYPE_INVALID; 2639 return (1); 2640 } 2641 return (0); 2642 } 2643 dp->space_timeout = timeout; 2644 2645 rval = st_get_timeouts_value(un, SCMD_LOAD, &timeout, 0); 2646 if (rval) { 2647 if (rval == EACCES) { 2648 un->un_dp->type = ST_TYPE_INVALID; 2649 dp->type = ST_TYPE_INVALID; 2650 return (1); 2651 } 2652 return (0); 2653 } 2654 dp->load_timeout = timeout; 2655 dp->unload_timeout = timeout; 2656 2657 rval = st_get_timeouts_value(un, SCMD_REWIND, &timeout, 0); 2658 if (rval) { 2659 if (rval == EACCES) { 2660 un->un_dp->type = ST_TYPE_INVALID; 2661 dp->type = ST_TYPE_INVALID; 2662 return (1); 2663 } 2664 return (0); 2665 } 2666 dp->rewind_timeout = timeout; 2667 2668 rval = st_get_timeouts_value(un, SCMD_INQUIRY, &timeout, 0); 2669 if (rval) { 2670 if (rval == EACCES) { 2671 un->un_dp->type = ST_TYPE_INVALID; 2672 dp->type = ST_TYPE_INVALID; 2673 return (1); 2674 } 2675 return (0); 2676 } 2677 dp->non_motion_timeout = timeout; 2678 2679 return (1); 2680 } 2681 2682 static int 2683 st_get_timeouts_value(struct scsi_tape *un, uchar_t option_code, 2684 ushort_t *timeout_value, ushort_t service_action) 2685 { 2686 uchar_t *timeouts; 2687 uchar_t *oper; 2688 uchar_t support; 2689 uchar_t cdbsize; 2690 uchar_t ctdp; 2691 size_t buflen; 2692 int rval; 2693 2694 ST_FUNC(ST_DEVINFO, st_get_timeouts_value); 2695 2696 buflen = sizeof (struct one_com_des) + 2697 sizeof (struct com_timeout_des); 2698 oper = kmem_zalloc(buflen, KM_SLEEP); 2699 rval = st_report_supported_operation(un, oper, option_code, 2700 service_action); 2701 2702 if (rval) { 2703 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2704 "st_get_timeouts_value(): " 2705 "fail to timeouts value for command %d.\n", option_code); 2706 kmem_free(oper, buflen); 2707 return (rval); 2708 } 2709 2710 support = ((struct one_com_des *)oper)->support; 2711 if ((support != SUPPORT_VALUES_SUPPORT_SCSI) && 2712 (support != SUPPORT_VALUES_SUPPORT_VENDOR)) { 2713 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2714 "st_get_timeouts_value(): " 2715 "command %d is not supported.\n", option_code); 2716 kmem_free(oper, buflen); 2717 return (ENOTSUP); 2718 } 2719 2720 ctdp = ((struct one_com_des *)oper)->ctdp; 2721 if (!ctdp) { 2722 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2723 "st_get_timeouts_value(): " 2724 "command timeout is not included.\n"); 2725 kmem_free(oper, buflen); 2726 return (ENOTSUP); 2727 } 2728 2729 cdbsize = BE_16(((struct one_com_des *)oper)->cdb_size); 2730 timeouts = (uchar_t *)(oper + cdbsize + 4); 2731 2732 /* 2733 * Timeout value in seconds is 4 bytes, but we only support the lower 2 2734 * bytes. If the higher 2 bytes are not zero, the timeout value is set 2735 * to 0xFFFF. 2736 */ 2737 if (*(timeouts + 8) != 0 || *(timeouts + 9) != 0) { 2738 *timeout_value = USHRT_MAX; 2739 } else { 2740 *timeout_value = ((*(timeouts + 10)) << 8) | 2741 (*(timeouts + 11)); 2742 } 2743 2744 kmem_free(oper, buflen); 2745 return (0); 2746 } 2747 2748 static int 2749 st_get_default_conf(struct scsi_tape *un, char *vidpid, struct st_drivetype *dp) 2750 { 2751 int i; 2752 2753 ST_FUNC(ST_DEVINFO, st_get_default_conf); 2754 2755 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 2756 "st_get_default_conf(): making drivetype from INQ cmd\n"); 2757 2758 /* 2759 * Make up a name 2760 */ 2761 bcopy("Vendor '", dp->name, 8); 2762 bcopy(vidpid, &dp->name[8], VIDLEN); 2763 bcopy("' Product '", &dp->name[16], 11); 2764 bcopy(&vidpid[8], &dp->name[27], PIDLEN); 2765 dp->name[ST_NAMESIZE - 2] = '\''; 2766 dp->name[ST_NAMESIZE - 1] = '\0'; 2767 dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1)); 2768 (void) strncpy(dp->vid, ST_INQUIRY->inq_vid, dp->length); 2769 /* 2770 * 'clean' vendor and product strings of non-printing chars 2771 */ 2772 for (i = 0; i < ST_NAMESIZE - 2; i++) { 2773 if (dp->name[i] < ' ' || dp->name[i] > '~') { 2774 dp->name[i] = '.'; 2775 } 2776 } 2777 dp->type = ST_TYPE_INVALID; 2778 dp->options |= (ST_DYNAMIC | ST_UNLOADABLE | ST_MODE_SEL_COMP); 2779 2780 return (1); /* Can Not Fail */ 2781 } 2782 2783 /* 2784 * Regular Unix Entry points 2785 */ 2786 2787 2788 2789 /* ARGSUSED */ 2790 static int 2791 st_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p) 2792 { 2793 dev_t dev = *dev_p; 2794 int rval = 0; 2795 2796 GET_SOFT_STATE(dev); 2797 2798 ST_ENTR(ST_DEVINFO, st_open); 2799 2800 /* 2801 * validate that we are addressing a sensible unit 2802 */ 2803 mutex_enter(ST_MUTEX); 2804 2805 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2806 "st_open(node = %s dev = 0x%lx, flag = %d, otyp = %d)\n", 2807 st_dev_name(dev), *dev_p, flag, otyp); 2808 2809 /* 2810 * All device accesss go thru st_strategy() where we check 2811 * suspend status 2812 */ 2813 2814 if (!un->un_attached) { 2815 st_known_tape_type(un); 2816 if (!un->un_attached) { 2817 rval = ENXIO; 2818 goto exit; 2819 } 2820 2821 } 2822 2823 /* 2824 * Check for the case of the tape in the middle of closing. 2825 * This isn't simply a check of the current state, because 2826 * we could be in state of sensing with the previous state 2827 * that of closing. 2828 * 2829 * And don't allow multiple opens. 2830 */ 2831 if (!(flag & (FNDELAY | FNONBLOCK)) && IS_CLOSING(un)) { 2832 un->un_laststate = un->un_state; 2833 un->un_state = ST_STATE_CLOSE_PENDING_OPEN; 2834 while (IS_CLOSING(un) || 2835 un->un_state == ST_STATE_CLOSE_PENDING_OPEN) { 2836 if (cv_wait_sig(&un->un_clscv, ST_MUTEX) == 0) { 2837 rval = EINTR; 2838 un->un_state = un->un_laststate; 2839 goto exit; 2840 } 2841 } 2842 } else if (un->un_state != ST_STATE_CLOSED) { 2843 rval = EBUSY; 2844 goto busy; 2845 } 2846 2847 /* 2848 * record current dev 2849 */ 2850 un->un_dev = dev; 2851 un->un_oflags = flag; /* save for use in st_tape_init() */ 2852 un->un_errno = 0; /* no errors yet */ 2853 un->un_restore_pos = 0; 2854 un->un_rqs_state = 0; 2855 2856 /* 2857 * If we are opening O_NDELAY, or O_NONBLOCK, we don't check for 2858 * anything, leave internal states alone, if fileno >= 0 2859 */ 2860 if (flag & (FNDELAY | FNONBLOCK)) { 2861 switch (un->un_pos.pmode) { 2862 2863 case invalid: 2864 un->un_state = ST_STATE_OFFLINE; 2865 break; 2866 2867 case legacy: 2868 /* 2869 * If position is anything other than rewound. 2870 */ 2871 if (un->un_pos.fileno != 0 || un->un_pos.blkno != 0) { 2872 /* 2873 * set un_read_only/write-protect status. 2874 * 2875 * If the tape is not bot we can assume 2876 * that mspl->wp_status is set properly. 2877 * else 2878 * we need to do a mode sense/Tur once 2879 * again to get the actual tape status.(since 2880 * user might have replaced the tape) 2881 * Hence make the st state OFFLINE so that 2882 * we re-intialize the tape once again. 2883 */ 2884 un->un_read_only = 2885 (un->un_oflags & FWRITE) ? RDWR : RDONLY; 2886 un->un_state = ST_STATE_OPEN_PENDING_IO; 2887 } else { 2888 un->un_state = ST_STATE_OFFLINE; 2889 } 2890 break; 2891 case logical: 2892 if (un->un_pos.lgclblkno == 0) { 2893 un->un_state = ST_STATE_OFFLINE; 2894 } else { 2895 un->un_read_only = 2896 (un->un_oflags & FWRITE) ? RDWR : RDONLY; 2897 un->un_state = ST_STATE_OPEN_PENDING_IO; 2898 } 2899 break; 2900 } 2901 rval = 0; 2902 } else { 2903 /* 2904 * Not opening O_NDELAY. 2905 */ 2906 un->un_state = ST_STATE_OPENING; 2907 2908 /* 2909 * Clear error entry stack 2910 */ 2911 st_empty_error_stack(un); 2912 2913 rval = st_tape_init(un); 2914 if ((rval == EACCES) && (un->un_read_only & WORM)) { 2915 un->un_state = ST_STATE_OPEN_PENDING_IO; 2916 rval = 0; /* so open doesn't fail */ 2917 } else if (rval) { 2918 /* 2919 * Release the tape unit, if reserved and not 2920 * preserve reserve. 2921 */ 2922 if ((un->un_rsvd_status & 2923 (ST_RESERVE | ST_PRESERVE_RESERVE)) == ST_RESERVE) { 2924 (void) st_reserve_release(un, ST_RELEASE, 2925 st_uscsi_cmd); 2926 } 2927 } else { 2928 un->un_state = ST_STATE_OPEN_PENDING_IO; 2929 } 2930 } 2931 2932 exit: 2933 /* 2934 * we don't want any uninvited guests scrogging our data when we're 2935 * busy with something, so for successful opens or failed opens 2936 * (except for EBUSY), reset these counters and state appropriately. 2937 */ 2938 if (rval != EBUSY) { 2939 if (rval) { 2940 un->un_state = ST_STATE_CLOSED; 2941 } 2942 un->un_err_resid = 0; 2943 un->un_retry_ct = 0; 2944 } 2945 busy: 2946 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2947 "st_open: return val = %x, state = %d\n", rval, un->un_state); 2948 mutex_exit(ST_MUTEX); 2949 return (rval); 2950 2951 } 2952 2953 static int 2954 st_tape_init(struct scsi_tape *un) 2955 { 2956 int err; 2957 int rval = 0; 2958 2959 ST_FUNC(ST_DEVINFO, st_tape_init); 2960 2961 ASSERT(mutex_owned(ST_MUTEX)); 2962 2963 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2964 "st_tape_init(un = 0x%p, oflags = %d)\n", (void*)un, un->un_oflags); 2965 2966 /* 2967 * Clean up after any errors left by 'last' close. 2968 * This also handles the case of the initial open. 2969 */ 2970 if (un->un_state != ST_STATE_INITIALIZING) { 2971 un->un_laststate = un->un_state; 2972 un->un_state = ST_STATE_OPENING; 2973 } 2974 2975 un->un_kbytes_xferred = 0; 2976 2977 /* 2978 * do a throw away TUR to clear check condition 2979 */ 2980 err = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 2981 2982 /* 2983 * If test unit ready fails because the drive is reserved 2984 * by another host fail the open for no access. 2985 */ 2986 if (err) { 2987 if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) { 2988 un->un_state = ST_STATE_CLOSED; 2989 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2990 "st_tape_init: RESERVATION CONFLICT\n"); 2991 rval = EACCES; 2992 goto exit; 2993 } else if ((un->un_rsvd_status & 2994 ST_APPLICATION_RESERVATIONS) != 0) { 2995 if ((ST_RQSENSE != NULL) && 2996 (ST_RQSENSE->es_add_code == 0x2a && 2997 ST_RQSENSE->es_qual_code == 0x03)) { 2998 un->un_state = ST_STATE_CLOSED; 2999 rval = EACCES; 3000 goto exit; 3001 } 3002 } 3003 } 3004 3005 /* 3006 * Tape self identification could fail if the tape drive is used by 3007 * another host during attach time. We try to get the tape type 3008 * again. This is also applied to any posponed configuration methods. 3009 */ 3010 if (un->un_dp->type == ST_TYPE_INVALID) { 3011 un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE; 3012 st_known_tape_type(un); 3013 } 3014 3015 /* 3016 * If the tape type is still invalid, try to determine the generic 3017 * configuration. 3018 */ 3019 if (un->un_dp->type == ST_TYPE_INVALID) { 3020 rval = st_determine_generic(un); 3021 if (rval) { 3022 if (rval != EACCES) { 3023 rval = EIO; 3024 } 3025 un->un_state = ST_STATE_CLOSED; 3026 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3027 "st_tape_init: %s invalid type\n", 3028 rval == EACCES ? "EACCES" : "EIO"); 3029 goto exit; 3030 } 3031 /* 3032 * If this is a Unknown Type drive, 3033 * Use the READ BLOCK LIMITS to determine if 3034 * allow large xfer is approprate if not globally 3035 * disabled with st_allow_large_xfer. 3036 */ 3037 un->un_allow_large_xfer = (uchar_t)st_allow_large_xfer; 3038 } else { 3039 3040 /* 3041 * If we allow_large_xfer (ie >64k) and have not yet found out 3042 * the max block size supported by the drive, 3043 * find it by issueing a READ_BLKLIM command. 3044 * if READ_BLKLIM cmd fails, assume drive doesn't 3045 * allow_large_xfer and min/max block sizes as 1 byte and 63k. 3046 */ 3047 un->un_allow_large_xfer = st_allow_large_xfer && 3048 (un->un_dp->options & ST_NO_RECSIZE_LIMIT); 3049 } 3050 /* 3051 * if maxbsize is unknown, set the maximum block size. 3052 */ 3053 if (un->un_maxbsize == MAXBSIZE_UNKNOWN) { 3054 3055 /* 3056 * Get the Block limits of the tape drive. 3057 * if un->un_allow_large_xfer = 0 , then make sure 3058 * that maxbsize is <= ST_MAXRECSIZE_FIXED. 3059 */ 3060 un->un_rbl = kmem_zalloc(RBLSIZE, KM_SLEEP); 3061 3062 err = st_cmd(un, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD); 3063 if (err) { 3064 /* Retry */ 3065 err = st_cmd(un, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD); 3066 } 3067 if (!err) { 3068 3069 /* 3070 * if cmd successful, use limit returned 3071 */ 3072 un->un_maxbsize = (un->un_rbl->max_hi << 16) + 3073 (un->un_rbl->max_mid << 8) + 3074 un->un_rbl->max_lo; 3075 un->un_minbsize = (un->un_rbl->min_hi << 8) + 3076 un->un_rbl->min_lo; 3077 un->un_data_mod = 1 << un->un_rbl->granularity; 3078 if ((un->un_maxbsize == 0) || 3079 (un->un_allow_large_xfer == 0 && 3080 un->un_maxbsize > ST_MAXRECSIZE_FIXED)) { 3081 un->un_maxbsize = ST_MAXRECSIZE_FIXED; 3082 3083 } else if (un->un_dp->type == ST_TYPE_DEFAULT) { 3084 /* 3085 * Drive is not one that is configured, But the 3086 * READ BLOCK LIMITS tells us it can do large 3087 * xfers. 3088 */ 3089 if (un->un_maxbsize > ST_MAXRECSIZE_FIXED) { 3090 un->un_dp->options |= 3091 ST_NO_RECSIZE_LIMIT; 3092 } 3093 /* 3094 * If max and mimimum block limits are the 3095 * same this is a fixed block size device. 3096 */ 3097 if (un->un_maxbsize == un->un_minbsize) { 3098 un->un_dp->options &= ~ST_VARIABLE; 3099 } 3100 } 3101 3102 if (un->un_minbsize == 0) { 3103 un->un_minbsize = 1; 3104 } 3105 3106 } else { /* error on read block limits */ 3107 3108 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 3109 "!st_tape_init: Error on READ BLOCK LIMITS," 3110 " errno = %d un_rsvd_status = 0x%X\n", 3111 err, un->un_rsvd_status); 3112 3113 /* 3114 * since read block limits cmd failed, 3115 * do not allow large xfers. 3116 * use old values in st_minphys 3117 */ 3118 if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) { 3119 rval = EACCES; 3120 } else { 3121 un->un_allow_large_xfer = 0; 3122 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 3123 "!Disabling large transfers\n"); 3124 3125 /* 3126 * we guess maxbsize and minbsize 3127 */ 3128 if (un->un_bsize) { 3129 un->un_maxbsize = un->un_minbsize = 3130 un->un_bsize; 3131 } else { 3132 un->un_maxbsize = ST_MAXRECSIZE_FIXED; 3133 un->un_minbsize = 1; 3134 } 3135 /* 3136 * Data Mod must be set, 3137 * Even if read block limits fails. 3138 * Prevents Divide By Zero in st_rw(). 3139 */ 3140 un->un_data_mod = 1; 3141 } 3142 } 3143 if (un->un_rbl) { 3144 kmem_free(un->un_rbl, RBLSIZE); 3145 un->un_rbl = NULL; 3146 } 3147 3148 if (rval) { 3149 goto exit; 3150 } 3151 } 3152 3153 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 3154 "maxdma = %d, maxbsize = %d, minbsize = %d, %s large xfer\n", 3155 un->un_maxdma, un->un_maxbsize, un->un_minbsize, 3156 (un->un_allow_large_xfer ? "ALLOW": "DON'T ALLOW")); 3157 3158 err = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 3159 3160 if (err != 0) { 3161 if (err == EINTR) { 3162 un->un_laststate = un->un_state; 3163 un->un_state = ST_STATE_CLOSED; 3164 rval = EINTR; 3165 goto exit; 3166 } 3167 /* 3168 * Make sure the tape is ready 3169 */ 3170 un->un_pos.pmode = invalid; 3171 if (un->un_status != KEY_UNIT_ATTENTION) { 3172 /* 3173 * allow open no media. Subsequent MTIOCSTATE 3174 * with media present will complete the open 3175 * logic. 3176 */ 3177 un->un_laststate = un->un_state; 3178 if (un->un_oflags & (FNONBLOCK|FNDELAY)) { 3179 un->un_mediastate = MTIO_EJECTED; 3180 un->un_state = ST_STATE_OFFLINE; 3181 rval = 0; 3182 goto exit; 3183 } else { 3184 un->un_state = ST_STATE_CLOSED; 3185 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3186 "st_tape_init EIO no media, not opened " 3187 "O_NONBLOCK|O_EXCL\n"); 3188 rval = EIO; 3189 goto exit; 3190 } 3191 } 3192 } 3193 3194 /* 3195 * On each open, initialize block size from drivetype struct, 3196 * as it could have been changed by MTSRSZ ioctl. 3197 * Now, ST_VARIABLE simply means drive is capable of variable 3198 * mode. All drives are assumed to support fixed records. 3199 * Hence, un_bsize tells what mode the drive is in. 3200 * un_bsize = 0 - variable record length 3201 * = x - fixed record length is x 3202 */ 3203 un->un_bsize = un->un_dp->bsize; 3204 3205 /* 3206 * If saved position is valid go there 3207 */ 3208 if (un->un_restore_pos) { 3209 un->un_restore_pos = 0; 3210 un->un_pos.fileno = un->un_save_fileno; 3211 un->un_pos.blkno = un->un_save_blkno; 3212 rval = st_validate_tapemarks(un, st_uscsi_cmd, &un->un_pos); 3213 if (rval != 0) { 3214 if (rval != EACCES) { 3215 rval = EIO; 3216 } 3217 un->un_laststate = un->un_state; 3218 un->un_state = ST_STATE_CLOSED; 3219 goto exit; 3220 } 3221 } 3222 3223 if (un->un_pos.pmode == invalid) { 3224 rval = st_loadtape(un); 3225 if (rval) { 3226 if (rval != EACCES) { 3227 rval = EIO; 3228 } 3229 un->un_laststate = un->un_state; 3230 un->un_state = ST_STATE_CLOSED; 3231 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3232 "st_tape_init: %s can't open tape\n", 3233 rval == EACCES ? "EACCES" : "EIO"); 3234 goto exit; 3235 } 3236 } 3237 3238 /* 3239 * do a mode sense to pick up state of current write-protect, 3240 * Could cause reserve and fail due to conflict. 3241 */ 3242 if (un->un_unit_attention_flags) { 3243 rval = st_modesense(un); 3244 if (rval == EACCES) { 3245 goto exit; 3246 } 3247 } 3248 3249 /* 3250 * If we are opening the tape for writing, check 3251 * to make sure that the tape can be written. 3252 */ 3253 if (un->un_oflags & FWRITE) { 3254 err = 0; 3255 if (un->un_mspl->wp) { 3256 un->un_status = KEY_WRITE_PROTECT; 3257 un->un_laststate = un->un_state; 3258 un->un_state = ST_STATE_CLOSED; 3259 rval = EACCES; 3260 /* 3261 * STK sets the wp bit if volsafe tape is loaded. 3262 */ 3263 if ((un->un_dp->type == MT_ISSTK9840) && 3264 (un->un_dp->options & ST_WORMABLE)) { 3265 un->un_read_only = RDONLY; 3266 } else { 3267 goto exit; 3268 } 3269 } else { 3270 un->un_read_only = RDWR; 3271 } 3272 } else { 3273 un->un_read_only = RDONLY; 3274 } 3275 3276 if (un->un_dp->options & ST_WORMABLE && 3277 un->un_unit_attention_flags) { 3278 un->un_read_only |= un->un_wormable(un); 3279 3280 if (((un->un_read_only == WORM) || 3281 (un->un_read_only == RDWORM)) && 3282 ((un->un_oflags & FWRITE) == FWRITE)) { 3283 un->un_status = KEY_DATA_PROTECT; 3284 rval = EACCES; 3285 ST_DEBUG4(ST_DEVINFO, st_label, CE_NOTE, 3286 "read_only = %d eof = %d oflag = %d\n", 3287 un->un_read_only, un->un_pos.eof, un->un_oflags); 3288 } 3289 } 3290 3291 /* 3292 * If we're opening the tape write-only, we need to 3293 * write 2 filemarks on the HP 1/2 inch drive, to 3294 * create a null file. 3295 */ 3296 if ((un->un_read_only == RDWR) || 3297 (un->un_read_only == WORM) && (un->un_oflags & FWRITE)) { 3298 if (un->un_dp->options & ST_REEL) { 3299 un->un_fmneeded = 2; 3300 } else { 3301 un->un_fmneeded = 1; 3302 } 3303 } else { 3304 un->un_fmneeded = 0; 3305 } 3306 3307 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 3308 "fmneeded = %x\n", un->un_fmneeded); 3309 3310 /* 3311 * Make sure the density can be selected correctly. 3312 * If WORM can only write at the append point which in most cases 3313 * isn't BOP. st_determine_density() with a B_WRITE only attempts 3314 * to set and try densities if a BOP. 3315 */ 3316 if (st_determine_density(un, 3317 un->un_read_only == RDWR ? B_WRITE : B_READ)) { 3318 un->un_status = KEY_ILLEGAL_REQUEST; 3319 un->un_laststate = un->un_state; 3320 un->un_state = ST_STATE_CLOSED; 3321 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 3322 "st_tape_init: EIO can't determine density\n"); 3323 rval = EIO; 3324 goto exit; 3325 } 3326 3327 /* 3328 * Destroy the knowledge that we have 'determined' 3329 * density so that a later read at BOT comes along 3330 * does the right density determination. 3331 */ 3332 3333 un->un_density_known = 0; 3334 3335 3336 /* 3337 * Okay, the tape is loaded and either at BOT or somewhere past. 3338 * Mark the state such that any I/O or tape space operations 3339 * will get/set the right density, etc.. 3340 */ 3341 un->un_laststate = un->un_state; 3342 un->un_lastop = ST_OP_NIL; 3343 un->un_mediastate = MTIO_INSERTED; 3344 cv_broadcast(&un->un_state_cv); 3345 3346 /* 3347 * Set test append flag if writing. 3348 * First write must check that tape is positioned correctly. 3349 */ 3350 un->un_test_append = (un->un_oflags & FWRITE); 3351 3352 /* 3353 * if there are pending unit attention flags. 3354 * Check that the media has not changed. 3355 */ 3356 if (un->un_unit_attention_flags) { 3357 rval = st_get_media_identification(un, st_uscsi_cmd); 3358 if (rval != 0 && rval != EACCES) { 3359 rval = EIO; 3360 } 3361 un->un_unit_attention_flags = 0; 3362 } 3363 3364 exit: 3365 un->un_err_resid = 0; 3366 un->un_last_resid = 0; 3367 un->un_last_count = 0; 3368 3369 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3370 "st_tape_init: return val = %x\n", rval); 3371 return (rval); 3372 3373 } 3374 3375 3376 3377 /* ARGSUSED */ 3378 static int 3379 st_close(dev_t dev, int flag, int otyp, cred_t *cred_p) 3380 { 3381 int err = 0; 3382 int count, last_state; 3383 minor_t minor = getminor(dev); 3384 #ifdef __x86 3385 struct contig_mem *cp, *cp_temp; 3386 #endif 3387 3388 GET_SOFT_STATE(dev); 3389 3390 ST_ENTR(ST_DEVINFO, st_close); 3391 3392 /* 3393 * wait till all cmds in the pipeline have been completed 3394 */ 3395 mutex_enter(ST_MUTEX); 3396 3397 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3398 "st_close(dev = 0x%lx, flag = %d, otyp = %d)\n", dev, flag, otyp); 3399 3400 st_wait_for_io(un); 3401 3402 /* turn off persistent errors on close, as we want close to succeed */ 3403 st_turn_pe_off(un); 3404 3405 /* 3406 * set state to indicate that we are in process of closing 3407 */ 3408 last_state = un->un_laststate = un->un_state; 3409 un->un_state = ST_STATE_CLOSING; 3410 3411 ST_POS(ST_DEVINFO, "st_close1:", &un->un_pos); 3412 3413 /* 3414 * BSD behavior: 3415 * a close always causes a silent span to the next file if we've hit 3416 * an EOF (but not yet read across it). 3417 */ 3418 if ((minor & MT_BSD) && (un->un_pos.eof == ST_EOF)) { 3419 if (un->un_pos.pmode != invalid) { 3420 un->un_pos.fileno++; 3421 un->un_pos.blkno = 0; 3422 } 3423 un->un_pos.eof = ST_NO_EOF; 3424 } 3425 3426 /* 3427 * SVR4 behavior for skipping to next file: 3428 * 3429 * If we have not seen a filemark, space to the next file 3430 * 3431 * If we have already seen the filemark we are physically in the next 3432 * file and we only increment the filenumber 3433 */ 3434 if (((minor & (MT_BSD | MT_NOREWIND)) == MT_NOREWIND) && 3435 (flag & FREAD) && /* reading or at least asked to */ 3436 (un->un_mediastate == MTIO_INSERTED) && /* tape loaded */ 3437 (un->un_pos.pmode != invalid) && /* XXX position known */ 3438 ((un->un_pos.blkno != 0) && /* inside a file */ 3439 (un->un_lastop != ST_OP_WRITE) && /* Didn't just write */ 3440 (un->un_lastop != ST_OP_WEOF))) { /* or write filemarks */ 3441 switch (un->un_pos.eof) { 3442 case ST_NO_EOF: 3443 /* 3444 * if we were reading and did not read the complete file 3445 * skip to the next file, leaving the tape correctly 3446 * positioned to read the first record of the next file 3447 * Check first for REEL if we are at EOT by trying to 3448 * read a block 3449 */ 3450 if ((un->un_dp->options & ST_REEL) && 3451 (!(un->un_dp->options & ST_READ_IGNORE_EOFS)) && 3452 (un->un_pos.blkno == 0)) { 3453 if (st_cmd(un, SCMD_SPACE, Blk(1), SYNC_CMD)) { 3454 ST_DEBUG2(ST_DEVINFO, st_label, 3455 SCSI_DEBUG, 3456 "st_close : EIO can't space\n"); 3457 err = EIO; 3458 goto error_out; 3459 } 3460 if (un->un_pos.eof >= ST_EOF_PENDING) { 3461 un->un_pos.eof = ST_EOT_PENDING; 3462 un->un_pos.fileno += 1; 3463 un->un_pos.blkno = 0; 3464 break; 3465 } 3466 } 3467 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 3468 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3469 "st_close: EIO can't space #2\n"); 3470 err = EIO; 3471 goto error_out; 3472 } else { 3473 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3474 "st_close2: fileno=%x,blkno=%x,eof=%x\n", 3475 un->un_pos.fileno, un->un_pos.blkno, 3476 un->un_pos.eof); 3477 un->un_pos.eof = ST_NO_EOF; 3478 } 3479 break; 3480 3481 case ST_EOF_PENDING: 3482 case ST_EOF: 3483 un->un_pos.fileno += 1; 3484 un->un_pos.lgclblkno += 1; 3485 un->un_pos.blkno = 0; 3486 un->un_pos.eof = ST_NO_EOF; 3487 break; 3488 3489 case ST_EOT: 3490 case ST_EOT_PENDING: 3491 case ST_EOM: 3492 /* nothing to do */ 3493 break; 3494 default: 3495 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 3496 "Undefined state 0x%x", un->un_pos.eof); 3497 3498 } 3499 } 3500 3501 3502 /* 3503 * For performance reasons (HP 88780), the driver should 3504 * postpone writing the second tape mark until just before a file 3505 * positioning ioctl is issued (e.g., rewind). This means that 3506 * the user must not manually rewind the tape because the tape will 3507 * be missing the second tape mark which marks EOM. 3508 * However, this small performance improvement is not worth the risk. 3509 */ 3510 3511 /* 3512 * We need to back up over the filemark we inadvertently popped 3513 * over doing a read in between the two filemarks that constitute 3514 * logical eot for 1/2" tapes. Note that ST_EOT_PENDING is only 3515 * set while reading. 3516 * 3517 * If we happen to be at physical eot (ST_EOM) (writing case), 3518 * the writing of filemark(s) will clear the ST_EOM state, which 3519 * we don't want, so we save this state and restore it later. 3520 */ 3521 3522 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3523 "flag=%x, fmneeded=%x, lastop=%x, eof=%x\n", 3524 flag, un->un_fmneeded, un->un_lastop, un->un_pos.eof); 3525 3526 if (un->un_pos.eof == ST_EOT_PENDING) { 3527 if (minor & MT_NOREWIND) { 3528 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 3529 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3530 "st_close: EIO can't space #3\n"); 3531 err = EIO; 3532 goto error_out; 3533 } else { 3534 un->un_pos.blkno = 0; 3535 un->un_pos.eof = ST_EOT; 3536 } 3537 } else { 3538 un->un_pos.eof = ST_NO_EOF; 3539 } 3540 3541 /* 3542 * Do we need to write a file mark? 3543 * 3544 * only write filemarks if there are fmks to be written and 3545 * - open for write (possibly read/write) 3546 * - the last operation was a write 3547 * or: 3548 * - opened for wronly 3549 * - no data was written 3550 */ 3551 } else if ((un->un_pos.pmode != invalid) && 3552 (un->un_fmneeded > 0) && 3553 (((flag & FWRITE) && 3554 ((un->un_lastop == ST_OP_WRITE)||(un->un_lastop == ST_OP_WEOF))) || 3555 ((flag == FWRITE) && (un->un_lastop == ST_OP_NIL)))) { 3556 3557 /* save ST_EOM state */ 3558 int was_at_eom = (un->un_pos.eof == ST_EOM) ? 1 : 0; 3559 3560 /* 3561 * Note that we will write a filemark if we had opened 3562 * the tape write only and no data was written, thus 3563 * creating a null file. 3564 * 3565 * If the user already wrote one, we only have to write 1 more. 3566 * If they wrote two, we don't have to write any. 3567 */ 3568 3569 count = un->un_fmneeded; 3570 if (count > 0) { 3571 if (st_cmd(un, SCMD_WRITE_FILE_MARK, count, SYNC_CMD)) { 3572 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3573 "st_close : EIO can't wfm\n"); 3574 err = EIO; 3575 goto error_out; 3576 } 3577 if ((un->un_dp->options & ST_REEL) && 3578 (minor & MT_NOREWIND)) { 3579 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 3580 ST_DEBUG2(ST_DEVINFO, st_label, 3581 SCSI_DEBUG, 3582 "st_close : EIO space fmk(-1)\n"); 3583 err = EIO; 3584 goto error_out; 3585 } 3586 un->un_pos.eof = ST_NO_EOF; 3587 /* fix up block number */ 3588 un->un_pos.blkno = 0; 3589 } 3590 } 3591 3592 /* 3593 * If we aren't going to be rewinding, and we were at 3594 * physical eot, restore the state that indicates we 3595 * are at physical eot. Once you have reached physical 3596 * eot, and you close the tape, the only thing you can 3597 * do on the next open is to rewind. Access to trailer 3598 * records is only allowed without closing the device. 3599 */ 3600 if ((minor & MT_NOREWIND) == 0 && was_at_eom) { 3601 un->un_pos.eof = ST_EOM; 3602 } 3603 } 3604 3605 /* 3606 * report soft errors if enabled and available, if we never accessed 3607 * the drive, don't get errors. This will prevent some DAT error 3608 * messages upon LOG SENSE. 3609 */ 3610 if (st_report_soft_errors_on_close && 3611 (un->un_dp->options & ST_SOFT_ERROR_REPORTING) && 3612 (last_state != ST_STATE_OFFLINE)) { 3613 if (st_report_soft_errors(dev, flag)) { 3614 err = EIO; 3615 goto error_out; 3616 } 3617 } 3618 3619 3620 /* 3621 * Do we need to rewind? Can we rewind? 3622 */ 3623 if ((minor & MT_NOREWIND) == 0 && 3624 un->un_pos.pmode != invalid && err == 0) { 3625 /* 3626 * We'd like to rewind with the 3627 * 'immediate' bit set, but this 3628 * causes problems on some drives 3629 * where subsequent opens get a 3630 * 'NOT READY' error condition 3631 * back while the tape is rewinding, 3632 * which is impossible to distinguish 3633 * from the condition of 'no tape loaded'. 3634 * 3635 * Also, for some targets, if you disconnect 3636 * with the 'immediate' bit set, you don't 3637 * actually return right away, i.e., the 3638 * target ignores your request for immediate 3639 * return. 3640 * 3641 * Instead, we'll fire off an async rewind 3642 * command. We'll mark the device as closed, 3643 * and any subsequent open will stall on 3644 * the first TEST_UNIT_READY until the rewind 3645 * completes. 3646 */ 3647 3648 /* 3649 * Used to be if reserve was not supported we'd send an 3650 * asynchronious rewind. Comments above may be slightly invalid 3651 * as the immediate bit was never set. Doing an immedate rewind 3652 * makes sense, I think fixes to not ready status might handle 3653 * the problems described above. 3654 */ 3655 if (un->un_sd->sd_inq->inq_ansi < 2) { 3656 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 3657 err = EIO; 3658 } 3659 } else { 3660 /* flush data for older drives per scsi spec. */ 3661 if (st_cmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD)) { 3662 err = EIO; 3663 } else { 3664 /* release the drive before rewind immediate */ 3665 if ((un->un_rsvd_status & 3666 (ST_RESERVE | ST_PRESERVE_RESERVE)) == 3667 ST_RESERVE) { 3668 if (st_reserve_release(un, ST_RELEASE, 3669 st_uscsi_cmd)) { 3670 err = EIO; 3671 } 3672 } 3673 3674 /* send rewind with immediate bit set */ 3675 if (st_cmd(un, SCMD_REWIND, 1, ASYNC_CMD)) { 3676 err = EIO; 3677 } 3678 } 3679 } 3680 /* 3681 * Setting positions invalid in case the rewind doesn't 3682 * happen. Drives don't like to rewind if resets happen 3683 * they will tend to move back to where the rewind was 3684 * issued if a reset or something happens so that if a 3685 * write happens the data doesn't get clobbered. 3686 * 3687 * Not a big deal if the position is invalid when the 3688 * open occures it will do a read position. 3689 */ 3690 un->un_pos.pmode = invalid; 3691 un->un_running.pmode = invalid; 3692 3693 if (err == EIO) { 3694 goto error_out; 3695 } 3696 } 3697 3698 /* 3699 * eject tape if necessary 3700 */ 3701 if (un->un_eject_tape_on_failure) { 3702 un->un_eject_tape_on_failure = 0; 3703 if (st_cmd(un, SCMD_LOAD, LD_UNLOAD, SYNC_CMD)) { 3704 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3705 "st_close : can't unload tape\n"); 3706 err = EIO; 3707 goto error_out; 3708 } else { 3709 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3710 "st_close : tape unloaded \n"); 3711 un->un_pos.eof = ST_NO_EOF; 3712 un->un_mediastate = MTIO_EJECTED; 3713 } 3714 } 3715 /* 3716 * Release the tape unit, if default reserve/release 3717 * behaviour. 3718 */ 3719 if ((un->un_rsvd_status & 3720 (ST_RESERVE | ST_PRESERVE_RESERVE | 3721 ST_APPLICATION_RESERVATIONS)) == ST_RESERVE) { 3722 (void) st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 3723 } 3724 error_out: 3725 /* 3726 * clear up state 3727 */ 3728 un->un_laststate = un->un_state; 3729 un->un_state = ST_STATE_CLOSED; 3730 un->un_lastop = ST_OP_NIL; 3731 un->un_throttle = 1; /* assume one request at time, for now */ 3732 un->un_retry_ct = 0; 3733 un->un_errno = 0; 3734 un->un_swr_token = (opaque_t)NULL; 3735 un->un_rsvd_status &= ~(ST_INIT_RESERVE); 3736 3737 /* Restore the options to the init time settings */ 3738 if (un->un_init_options & ST_READ_IGNORE_ILI) { 3739 un->un_dp->options |= ST_READ_IGNORE_ILI; 3740 } else { 3741 un->un_dp->options &= ~ST_READ_IGNORE_ILI; 3742 } 3743 3744 if (un->un_init_options & ST_READ_IGNORE_EOFS) { 3745 un->un_dp->options |= ST_READ_IGNORE_EOFS; 3746 } else { 3747 un->un_dp->options &= ~ST_READ_IGNORE_EOFS; 3748 } 3749 3750 if (un->un_init_options & ST_SHORT_FILEMARKS) { 3751 un->un_dp->options |= ST_SHORT_FILEMARKS; 3752 } else { 3753 un->un_dp->options &= ~ST_SHORT_FILEMARKS; 3754 } 3755 3756 ASSERT(mutex_owned(ST_MUTEX)); 3757 3758 /* 3759 * Signal anyone awaiting a close operation to complete. 3760 */ 3761 cv_signal(&un->un_clscv); 3762 3763 /* 3764 * any kind of error on closing causes all state to be tossed 3765 */ 3766 if (err && un->un_status != KEY_ILLEGAL_REQUEST) { 3767 /* 3768 * note that st_intr has already set 3769 * un_pos.pmode to invalid. 3770 */ 3771 un->un_density_known = 0; 3772 } 3773 3774 #ifdef __x86 3775 /* 3776 * free any contiguous mem alloc'ed for big block I/O 3777 */ 3778 cp = un->un_contig_mem; 3779 while (cp) { 3780 if (cp->cm_addr) { 3781 ddi_dma_mem_free(&cp->cm_acc_hdl); 3782 } 3783 cp_temp = cp; 3784 cp = cp->cm_next; 3785 kmem_free(cp_temp, 3786 sizeof (struct contig_mem) + biosize()); 3787 } 3788 un->un_contig_mem_total_num = 0; 3789 un->un_contig_mem_available_num = 0; 3790 un->un_contig_mem = NULL; 3791 un->un_max_contig_mem_len = 0; 3792 #endif 3793 3794 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 3795 "st_close3: return val = %x, fileno=%x, blkno=%x, eof=%x\n", 3796 err, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 3797 3798 mutex_exit(ST_MUTEX); 3799 return (err); 3800 } 3801 3802 /* 3803 * These routines perform raw i/o operations. 3804 */ 3805 3806 /* ARGSUSED2 */ 3807 static int 3808 st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p) 3809 { 3810 #ifdef STDEBUG 3811 GET_SOFT_STATE(dev); 3812 ST_ENTR(ST_DEVINFO, st_aread); 3813 #endif 3814 return (st_arw(dev, aio, B_READ)); 3815 } 3816 3817 3818 /* ARGSUSED2 */ 3819 static int 3820 st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p) 3821 { 3822 #ifdef STDEBUG 3823 GET_SOFT_STATE(dev); 3824 ST_ENTR(ST_DEVINFO, st_awrite); 3825 #endif 3826 return (st_arw(dev, aio, B_WRITE)); 3827 } 3828 3829 3830 3831 /* ARGSUSED */ 3832 static int 3833 st_read(dev_t dev, struct uio *uiop, cred_t *cred_p) 3834 { 3835 #ifdef STDEBUG 3836 GET_SOFT_STATE(dev); 3837 ST_ENTR(ST_DEVINFO, st_read); 3838 #endif 3839 return (st_rw(dev, uiop, B_READ)); 3840 } 3841 3842 /* ARGSUSED */ 3843 static int 3844 st_write(dev_t dev, struct uio *uiop, cred_t *cred_p) 3845 { 3846 #ifdef STDEBUG 3847 GET_SOFT_STATE(dev); 3848 ST_ENTR(ST_DEVINFO, st_write); 3849 #endif 3850 return (st_rw(dev, uiop, B_WRITE)); 3851 } 3852 3853 /* 3854 * Due to historical reasons, old limits are: For variable-length devices: 3855 * if greater than 64KB - 1 (ST_MAXRECSIZE_VARIABLE), block into 64 KB - 2 3856 * ST_MAXRECSIZE_VARIABLE_LIMIT) requests; otherwise, 3857 * (let it through unmodified. For fixed-length record devices: 3858 * 63K (ST_MAXRECSIZE_FIXED) is max (default minphys). 3859 * 3860 * The new limits used are un_maxdma (retrieved using scsi_ifgetcap() 3861 * from the HBA) and un_maxbsize (retrieved by sending SCMD_READ_BLKLIM 3862 * command to the drive). 3863 * 3864 */ 3865 static void 3866 st_minphys(struct buf *bp) 3867 { 3868 struct scsi_tape *un; 3869 3870 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 3871 3872 ST_FUNC(ST_DEVINFO, st_minphys); 3873 3874 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3875 "st_minphys(bp = 0x%p): b_bcount = 0x%lx\n", (void *)bp, 3876 bp->b_bcount); 3877 3878 if (un->un_allow_large_xfer) { 3879 3880 /* 3881 * check un_maxbsize for variable length devices only 3882 */ 3883 if (un->un_bsize == 0 && bp->b_bcount > un->un_maxbsize) { 3884 bp->b_bcount = un->un_maxbsize; 3885 } 3886 /* 3887 * can't go more that HBA maxdma limit in either fixed-length 3888 * or variable-length tape drives. 3889 */ 3890 if (bp->b_bcount > un->un_maxdma) { 3891 bp->b_bcount = un->un_maxdma; 3892 } 3893 } else { 3894 3895 /* 3896 * use old fixed limits 3897 */ 3898 if (un->un_bsize == 0) { 3899 if (bp->b_bcount > ST_MAXRECSIZE_VARIABLE) { 3900 bp->b_bcount = ST_MAXRECSIZE_VARIABLE_LIMIT; 3901 } 3902 } else { 3903 if (bp->b_bcount > ST_MAXRECSIZE_FIXED) { 3904 bp->b_bcount = ST_MAXRECSIZE_FIXED; 3905 } 3906 } 3907 } 3908 3909 /* 3910 * For regular raw I/O and Fixed Block length devices, make sure 3911 * the adjusted block count is a whole multiple of the device 3912 * block size. 3913 */ 3914 if (bp != un->un_sbufp && un->un_bsize) { 3915 bp->b_bcount -= (bp->b_bcount % un->un_bsize); 3916 } 3917 } 3918 3919 static int 3920 st_rw(dev_t dev, struct uio *uio, int flag) 3921 { 3922 int rval = 0; 3923 long len; 3924 3925 GET_SOFT_STATE(dev); 3926 3927 ST_FUNC(ST_DEVINFO, st_rw); 3928 3929 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3930 "st_rw(dev = 0x%lx, flag = %s)\n", dev, 3931 (flag == B_READ ? rd_str: wr_str)); 3932 3933 /* get local copy of transfer length */ 3934 len = uio->uio_iov->iov_len; 3935 3936 mutex_enter(ST_MUTEX); 3937 3938 /* 3939 * Clear error entry stack 3940 */ 3941 st_empty_error_stack(un); 3942 3943 /* 3944 * If in fixed block size mode and requested read or write 3945 * is not an even multiple of that block size. 3946 */ 3947 if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) { 3948 scsi_log(ST_DEVINFO, st_label, CE_WARN, 3949 "%s: not modulo %d block size\n", 3950 (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize); 3951 rval = EINVAL; 3952 } 3953 3954 /* If device has set granularity in the READ_BLKLIM we honor it. */ 3955 if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) { 3956 scsi_log(ST_DEVINFO, st_label, CE_WARN, 3957 "%s: not modulo %d device granularity\n", 3958 (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod); 3959 rval = EINVAL; 3960 } 3961 3962 if (st_recov_sz != sizeof (recov_info) && un->un_multipath) { 3963 scsi_log(ST_DEVINFO, st_label, CE_WARN, mp_misconf); 3964 rval = EFAULT; 3965 } 3966 3967 if (rval != 0) { 3968 un->un_errno = rval; 3969 mutex_exit(ST_MUTEX); 3970 return (rval); 3971 } 3972 3973 /* 3974 * Reset this so it can be set if Berkeley and read over a filemark. 3975 */ 3976 un->un_silent_skip = 0; 3977 mutex_exit(ST_MUTEX); 3978 3979 len = uio->uio_resid; 3980 3981 rval = physio(st_queued_strategy, (struct buf *)NULL, 3982 dev, flag, st_minphys, uio); 3983 /* 3984 * if we have hit logical EOT during this xfer and there is not a 3985 * full residue, then set eof back to ST_EOM to make sure that 3986 * the user will see at least one zero write 3987 * after this short write 3988 */ 3989 mutex_enter(ST_MUTEX); 3990 if (un->un_pos.eof > ST_NO_EOF) { 3991 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3992 "eof=%d resid=%lx\n", un->un_pos.eof, uio->uio_resid); 3993 } 3994 if (un->un_pos.eof >= ST_EOM && (flag == B_WRITE)) { 3995 if ((uio->uio_resid != len) && (uio->uio_resid != 0)) { 3996 un->un_pos.eof = ST_EOM; 3997 } else if (uio->uio_resid == len) { 3998 un->un_pos.eof = ST_NO_EOF; 3999 } 4000 } 4001 4002 if (un->un_silent_skip && uio->uio_resid != len) { 4003 un->un_pos.eof = ST_EOF; 4004 un->un_pos.blkno = un->un_save_blkno; 4005 un->un_pos.fileno--; 4006 } 4007 4008 un->un_errno = rval; 4009 4010 mutex_exit(ST_MUTEX); 4011 4012 return (rval); 4013 } 4014 4015 static int 4016 st_arw(dev_t dev, struct aio_req *aio, int flag) 4017 { 4018 struct uio *uio = aio->aio_uio; 4019 int rval = 0; 4020 long len; 4021 4022 GET_SOFT_STATE(dev); 4023 4024 ST_FUNC(ST_DEVINFO, st_arw); 4025 4026 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4027 "st_arw(dev = 0x%lx, flag = %s)\n", dev, 4028 (flag == B_READ ? rd_str: wr_str)); 4029 4030 /* get local copy of transfer length */ 4031 len = uio->uio_iov->iov_len; 4032 4033 mutex_enter(ST_MUTEX); 4034 4035 /* 4036 * If in fixed block size mode and requested read or write 4037 * is not an even multiple of that block size. 4038 */ 4039 if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) { 4040 scsi_log(ST_DEVINFO, st_label, CE_WARN, 4041 "%s: not modulo %d block size\n", 4042 (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize); 4043 rval = EINVAL; 4044 } 4045 4046 /* If device has set granularity in the READ_BLKLIM we honor it. */ 4047 if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) { 4048 scsi_log(ST_DEVINFO, st_label, CE_WARN, 4049 "%s: not modulo %d device granularity\n", 4050 (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod); 4051 rval = EINVAL; 4052 } 4053 4054 if (st_recov_sz != sizeof (recov_info) && un->un_multipath) { 4055 scsi_log(ST_DEVINFO, st_label, CE_WARN, mp_misconf); 4056 rval = EFAULT; 4057 } 4058 4059 if (rval != 0) { 4060 un->un_errno = rval; 4061 mutex_exit(ST_MUTEX); 4062 return (rval); 4063 } 4064 4065 mutex_exit(ST_MUTEX); 4066 4067 len = uio->uio_resid; 4068 4069 rval = 4070 aphysio(st_queued_strategy, anocancel, dev, flag, st_minphys, aio); 4071 4072 /* 4073 * if we have hit logical EOT during this xfer and there is not a 4074 * full residue, then set eof back to ST_EOM to make sure that 4075 * the user will see at least one zero write 4076 * after this short write 4077 * 4078 * we keep this here just in case the application is not using 4079 * persistent errors 4080 */ 4081 mutex_enter(ST_MUTEX); 4082 if (un->un_pos.eof > ST_NO_EOF) { 4083 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4084 "eof=%d resid=%lx\n", un->un_pos.eof, uio->uio_resid); 4085 } 4086 if (un->un_pos.eof >= ST_EOM && (flag == B_WRITE)) { 4087 if ((uio->uio_resid != len) && (uio->uio_resid != 0)) { 4088 un->un_pos.eof = ST_EOM; 4089 } else if (uio->uio_resid == len && 4090 !(un->un_persistence && un->un_persist_errors)) { 4091 un->un_pos.eof = ST_NO_EOF; 4092 } 4093 } 4094 un->un_errno = rval; 4095 mutex_exit(ST_MUTEX); 4096 4097 return (rval); 4098 } 4099 4100 4101 4102 static int 4103 st_queued_strategy(buf_t *bp) 4104 { 4105 struct scsi_tape *un; 4106 char reading = bp->b_flags & B_READ; 4107 int wasopening = 0; 4108 4109 /* 4110 * validate arguments 4111 */ 4112 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 4113 if (un == NULL) { 4114 bp->b_resid = bp->b_bcount; 4115 bioerror(bp, ENXIO); 4116 ST_DEBUG6(NULL, st_label, SCSI_DEBUG, 4117 "st_queued_strategy: ENXIO error exit\n"); 4118 biodone(bp); 4119 return (0); 4120 } 4121 4122 ST_ENTR(ST_DEVINFO, st_queued_strategy); 4123 4124 mutex_enter(ST_MUTEX); 4125 4126 while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 4127 cv_wait(&un->un_suspend_cv, ST_MUTEX); 4128 } 4129 4130 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4131 "st_queued_strategy(): bcount=0x%lx, fileno=%d, blkno=%x, eof=%d\n", 4132 bp->b_bcount, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 4133 4134 /* 4135 * If persistent errors have been flagged, just nix this one. We wait 4136 * for any outstanding I/O's below, so we will be in order. 4137 */ 4138 if (un->un_persistence && un->un_persist_errors) { 4139 goto exit; 4140 } 4141 4142 /* 4143 * If last command was non queued, wait till it finishes. 4144 */ 4145 while (un->un_sbuf_busy) { 4146 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 4147 /* woke up because of an error */ 4148 if (un->un_persistence && un->un_persist_errors) { 4149 goto exit; 4150 } 4151 } 4152 4153 /* 4154 * s_buf and recovery commands shouldn't come here. 4155 */ 4156 ASSERT(bp != un->un_recov_buf); 4157 ASSERT(bp != un->un_sbufp); 4158 4159 /* 4160 * If we haven't done/checked reservation on the tape unit 4161 * do it now. 4162 */ 4163 if ((un->un_rsvd_status & 4164 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 4165 if ((un->un_dp->options & ST_NO_RESERVE_RELEASE) == 0) { 4166 if (st_reserve_release(un, ST_RESERVE, st_uscsi_cmd)) { 4167 st_bioerror(bp, un->un_errno); 4168 goto exit; 4169 } 4170 } else if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4171 /* 4172 * Enter here to restore position for possible 4173 * resets when the device was closed and opened 4174 * in O_NDELAY mode subsequently 4175 */ 4176 un->un_state = ST_STATE_INITIALIZING; 4177 (void) st_cmd(un, SCMD_TEST_UNIT_READY, 4178 0, SYNC_CMD); 4179 un->un_state = ST_STATE_OPEN_PENDING_IO; 4180 } 4181 un->un_rsvd_status |= ST_INIT_RESERVE; 4182 } 4183 4184 /* 4185 * If we are offline, we have to initialize everything first. 4186 * This is to handle either when opened with O_NDELAY, or 4187 * we just got a new tape in the drive, after an offline. 4188 * We don't observe O_NDELAY past the open, 4189 * as it will not make sense for tapes. 4190 */ 4191 if (un->un_state == ST_STATE_OFFLINE || un->un_restore_pos) { 4192 /* 4193 * reset state to avoid recursion 4194 */ 4195 un->un_laststate = un->un_state; 4196 un->un_state = ST_STATE_INITIALIZING; 4197 if (st_tape_init(un)) { 4198 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4199 "stioctl : OFFLINE init failure "); 4200 un->un_state = ST_STATE_OFFLINE; 4201 un->un_pos.pmode = invalid; 4202 goto b_done_err; 4203 } 4204 /* un_restore_pos make invalid */ 4205 un->un_state = ST_STATE_OPEN_PENDING_IO; 4206 un->un_restore_pos = 0; 4207 } 4208 /* 4209 * Check for legal operations 4210 */ 4211 if (un->un_pos.pmode == invalid) { 4212 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4213 "strategy with un->un_pos.pmode invalid\n"); 4214 goto b_done_err; 4215 } 4216 4217 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4218 "st_queued_strategy(): regular io\n"); 4219 4220 /* 4221 * Process this first. If we were reading, and we're pending 4222 * logical eot, that means we've bumped one file mark too far. 4223 */ 4224 4225 /* 4226 * Recursion warning: st_cmd will route back through here. 4227 * Not anymore st_cmd will go through st_strategy()! 4228 */ 4229 if (un->un_pos.eof == ST_EOT_PENDING) { 4230 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 4231 un->un_pos.pmode = invalid; 4232 un->un_density_known = 0; 4233 goto b_done_err; 4234 } 4235 un->un_pos.blkno = 0; /* fix up block number.. */ 4236 un->un_pos.eof = ST_EOT; 4237 } 4238 4239 /* 4240 * If we are in the process of opening, we may have to 4241 * determine/set the correct density. We also may have 4242 * to do a test_append (if QIC) to see whether we are 4243 * in a position to append to the end of the tape. 4244 * 4245 * If we're already at logical eot, we transition 4246 * to ST_NO_EOF. If we're at physical eot, we punt 4247 * to the switch statement below to handle. 4248 */ 4249 if ((un->un_state == ST_STATE_OPEN_PENDING_IO) || 4250 (un->un_test_append && (un->un_dp->options & ST_QIC))) { 4251 4252 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4253 if (st_determine_density(un, (int)reading)) { 4254 goto b_done_err; 4255 } 4256 } 4257 4258 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4259 "pending_io@fileno %d rw %d qic %d eof %d\n", 4260 un->un_pos.fileno, (int)reading, 4261 (un->un_dp->options & ST_QIC) ? 1 : 0, 4262 un->un_pos.eof); 4263 4264 if (!reading && un->un_pos.eof != ST_EOM) { 4265 if (un->un_pos.eof == ST_EOT) { 4266 un->un_pos.eof = ST_NO_EOF; 4267 } else if (un->un_pos.pmode != invalid && 4268 (un->un_dp->options & ST_QIC)) { 4269 /* 4270 * st_test_append() will do it all 4271 */ 4272 st_test_append(bp); 4273 mutex_exit(ST_MUTEX); 4274 return (0); 4275 } 4276 } 4277 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4278 wasopening = 1; 4279 } 4280 un->un_laststate = un->un_state; 4281 un->un_state = ST_STATE_OPEN; 4282 } 4283 4284 4285 /* 4286 * Process rest of END OF FILE and END OF TAPE conditions 4287 */ 4288 4289 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4290 "eof=%x, wasopening=%x\n", 4291 un->un_pos.eof, wasopening); 4292 4293 switch (un->un_pos.eof) { 4294 case ST_EOM: 4295 /* 4296 * This allows writes to proceed past physical 4297 * eot. We'll *really* be in trouble if the 4298 * user continues blindly writing data too 4299 * much past this point (unwind the tape). 4300 * Physical eot really means 'early warning 4301 * eot' in this context. 4302 * 4303 * Every other write from now on will succeed 4304 * (if sufficient tape left). 4305 * This write will return with resid == count 4306 * but the next one should be successful 4307 * 4308 * Note that we only transition to logical EOT 4309 * if the last state wasn't the OPENING state. 4310 * We explicitly prohibit running up to physical 4311 * eot, closing the device, and then re-opening 4312 * to proceed. Trailer records may only be gotten 4313 * at by keeping the tape open after hitting eot. 4314 * 4315 * Also note that ST_EOM cannot be set by reading- 4316 * this can only be set during writing. Reading 4317 * up to the end of the tape gets a blank check 4318 * or a double-filemark indication (ST_EOT_PENDING), 4319 * and we prohibit reading after that point. 4320 * 4321 */ 4322 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOM\n"); 4323 if (wasopening == 0) { 4324 /* 4325 * this allows st_rw() to reset it back to 4326 * will see a zero write 4327 */ 4328 un->un_pos.eof = ST_WRITE_AFTER_EOM; 4329 } 4330 un->un_status = SUN_KEY_EOT; 4331 goto b_done; 4332 4333 case ST_WRITE_AFTER_EOM: 4334 case ST_EOT: 4335 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOT\n"); 4336 un->un_status = SUN_KEY_EOT; 4337 if (SVR4_BEHAVIOR && reading) { 4338 goto b_done_err; 4339 } 4340 4341 if (reading) { 4342 goto b_done; 4343 } 4344 un->un_pos.eof = ST_NO_EOF; 4345 break; 4346 4347 case ST_EOF_PENDING: 4348 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4349 "EOF PENDING\n"); 4350 un->un_status = SUN_KEY_EOF; 4351 if (SVR4_BEHAVIOR) { 4352 un->un_pos.eof = ST_EOF; 4353 goto b_done; 4354 } 4355 /* FALLTHROUGH */ 4356 case ST_EOF: 4357 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOF\n"); 4358 un->un_status = SUN_KEY_EOF; 4359 if (SVR4_BEHAVIOR) { 4360 goto b_done_err; 4361 } 4362 4363 if (BSD_BEHAVIOR) { 4364 un->un_pos.eof = ST_NO_EOF; 4365 un->un_pos.fileno += 1; 4366 un->un_pos.blkno = 0; 4367 } 4368 4369 if (reading) { 4370 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4371 "now file %d (read)\n", 4372 un->un_pos.fileno); 4373 goto b_done; 4374 } 4375 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4376 "now file %d (write)\n", un->un_pos.fileno); 4377 break; 4378 default: 4379 un->un_status = 0; 4380 break; 4381 } 4382 4383 bp->b_flags &= ~(B_DONE); 4384 st_bioerror(bp, 0); 4385 bp->av_forw = NULL; 4386 bp->b_resid = 0; 4387 SET_BP_PKT(bp, 0); 4388 4389 4390 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4391 "st_queued_strategy: cmd=0x%p count=%ld resid=%ld flags=0x%x" 4392 " pkt=0x%p\n", 4393 (void *)bp->b_forw, bp->b_bcount, 4394 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 4395 4396 #ifdef __x86 4397 /* 4398 * We will replace bp with a new bp that can do big blk xfer 4399 * if the requested xfer size is bigger than un->un_maxdma_arch 4400 * 4401 * Also, we need to make sure that we're handling real I/O 4402 * by checking group 0/1 SCSI I/O commands, if needed 4403 */ 4404 if (bp->b_bcount > un->un_maxdma_arch && 4405 ((uchar_t)(uintptr_t)bp->b_forw == SCMD_READ || 4406 (uchar_t)(uintptr_t)bp->b_forw == SCMD_READ_G4 || 4407 (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE || 4408 (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE_G4)) { 4409 mutex_exit(ST_MUTEX); 4410 bp = st_get_bigblk_bp(bp); 4411 mutex_enter(ST_MUTEX); 4412 } 4413 #endif 4414 4415 /* put on wait queue */ 4416 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4417 "st_queued_strategy: un->un_quef = 0x%p, bp = 0x%p\n", 4418 (void *)un->un_quef, (void *)bp); 4419 4420 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quel, bp); 4421 4422 ST_DO_KSTATS(bp, kstat_waitq_enter); 4423 4424 st_start(un); 4425 4426 mutex_exit(ST_MUTEX); 4427 return (0); 4428 4429 b_done_err: 4430 st_bioerror(bp, EIO); 4431 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4432 "st_queued_strategy : EIO b_done_err\n"); 4433 4434 b_done: 4435 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4436 "st_queued_strategy: b_done\n"); 4437 4438 exit: 4439 /* 4440 * make sure no commands are outstanding or waiting before closing, 4441 * so we can guarantee order 4442 */ 4443 st_wait_for_io(un); 4444 un->un_err_resid = bp->b_resid = bp->b_bcount; 4445 4446 /* override errno here, if persistent errors were flagged */ 4447 if (un->un_persistence && un->un_persist_errors) 4448 bioerror(bp, un->un_errno); 4449 4450 mutex_exit(ST_MUTEX); 4451 4452 biodone(bp); 4453 ASSERT(mutex_owned(ST_MUTEX) == 0); 4454 return (0); 4455 } 4456 4457 4458 static int 4459 st_strategy(struct buf *bp) 4460 { 4461 struct scsi_tape *un; 4462 4463 /* 4464 * validate arguments 4465 */ 4466 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 4467 if (un == NULL) { 4468 bp->b_resid = bp->b_bcount; 4469 bioerror(bp, ENXIO); 4470 ST_DEBUG6(NULL, st_label, SCSI_DEBUG, 4471 "st_strategy: ENXIO error exit\n"); 4472 4473 biodone(bp); 4474 return (0); 4475 4476 } 4477 4478 ST_ENTR(ST_DEVINFO, st_strategy); 4479 4480 mutex_enter(ST_MUTEX); 4481 4482 while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 4483 cv_wait(&un->un_suspend_cv, ST_MUTEX); 4484 } 4485 4486 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4487 "st_strategy(): bcount=0x%lx, fileno=%d, blkno=%x, eof=%d\n", 4488 bp->b_bcount, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 4489 4490 ASSERT((bp == un->un_recov_buf) || (bp == un->un_sbufp)); 4491 4492 bp->b_flags &= ~(B_DONE); 4493 st_bioerror(bp, 0); 4494 bp->av_forw = NULL; 4495 bp->b_resid = 0; 4496 SET_BP_PKT(bp, 0); 4497 4498 4499 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4500 "st_strategy: cmd=0x%x count=%ld resid=%ld flags=0x%x" 4501 " pkt=0x%p\n", 4502 (unsigned char)(uintptr_t)bp->b_forw, bp->b_bcount, 4503 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 4504 ST_DO_KSTATS(bp, kstat_waitq_enter); 4505 4506 st_start(un); 4507 4508 mutex_exit(ST_MUTEX); 4509 return (0); 4510 } 4511 4512 /* 4513 * this routine spaces forward over filemarks 4514 */ 4515 static int 4516 st_space_fmks(struct scsi_tape *un, int64_t count) 4517 { 4518 int rval = 0; 4519 4520 ST_FUNC(ST_DEVINFO, st_space_fmks); 4521 4522 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4523 "st_space_fmks(dev = 0x%lx, count = %"PRIx64")\n", 4524 un->un_dev, count); 4525 4526 ASSERT(mutex_owned(ST_MUTEX)); 4527 4528 /* 4529 * the risk with doing only one space operation is that we 4530 * may accidentily jump in old data 4531 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD 4532 * because the 8200 does not append a marker; in order not to 4533 * sacrifice the fast file skip, we do a slow skip if the low 4534 * density device has been opened 4535 */ 4536 4537 if ((un->un_dp->options & ST_KNOWS_EOD) && 4538 !((un->un_dp->type == ST_TYPE_EXB8500 && 4539 MT_DENSITY(un->un_dev) == 0))) { 4540 if (st_cmd(un, SCMD_SPACE, Fmk(count), SYNC_CMD)) { 4541 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4542 "space_fmks : EIO can't do space cmd #1\n"); 4543 rval = EIO; 4544 } 4545 } else { 4546 while (count > 0) { 4547 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 4548 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4549 "space_fmks : EIO can't do space cmd #2\n"); 4550 rval = EIO; 4551 break; 4552 } 4553 count -= 1; 4554 /* 4555 * read a block to see if we have reached 4556 * end of medium (double filemark for reel or 4557 * medium error for others) 4558 */ 4559 if (count > 0) { 4560 if (st_cmd(un, SCMD_SPACE, Blk(1), SYNC_CMD)) { 4561 ST_DEBUG2(ST_DEVINFO, st_label, 4562 SCSI_DEBUG, 4563 "space_fmks : EIO can't do " 4564 "space cmd #3\n"); 4565 rval = EIO; 4566 break; 4567 } 4568 if ((un->un_pos.eof >= ST_EOF_PENDING) && 4569 (un->un_dp->options & ST_REEL)) { 4570 un->un_status = SUN_KEY_EOT; 4571 ST_DEBUG2(ST_DEVINFO, st_label, 4572 SCSI_DEBUG, 4573 "space_fmks : EIO ST_REEL\n"); 4574 rval = EIO; 4575 break; 4576 } else if (IN_EOF(un->un_pos)) { 4577 un->un_pos.eof = ST_NO_EOF; 4578 un->un_pos.fileno++; 4579 un->un_pos.blkno = 0; 4580 count--; 4581 } else if (un->un_pos.eof > ST_EOF) { 4582 ST_DEBUG2(ST_DEVINFO, st_label, 4583 SCSI_DEBUG, 4584 "space_fmks, EIO > ST_EOF\n"); 4585 rval = EIO; 4586 break; 4587 } 4588 4589 } 4590 } 4591 un->un_err_resid = count; 4592 COPY_POS(&un->un_pos, &un->un_err_pos); 4593 } 4594 ASSERT(mutex_owned(ST_MUTEX)); 4595 return (rval); 4596 } 4597 4598 /* 4599 * this routine spaces to EOD 4600 * 4601 * it keeps track of the current filenumber and returns the filenumber after 4602 * the last successful space operation, we keep the number high because as 4603 * tapes are getting larger, the possibility of more and more files exist, 4604 * 0x100000 (1 Meg of files) probably will never have to be changed any time 4605 * soon 4606 */ 4607 #define MAX_SKIP 0x100000 /* somewhat arbitrary */ 4608 4609 static int 4610 st_find_eod(struct scsi_tape *un) 4611 { 4612 tapepos_t savepos; 4613 int64_t sp_type; 4614 int result; 4615 4616 if (un == NULL) { 4617 return (-1); 4618 } 4619 4620 ST_FUNC(ST_DEVINFO, st_find_eod); 4621 4622 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4623 "st_find_eod(dev = 0x%lx): fileno = %d\n", un->un_dev, 4624 un->un_pos.fileno); 4625 4626 ASSERT(mutex_owned(ST_MUTEX)); 4627 4628 COPY_POS(&savepos, &un->un_pos); 4629 4630 /* 4631 * see if the drive is smart enough to do the skips in 4632 * one operation; 1/2" use two filemarks 4633 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD 4634 * because the 8200 does not append a marker; in order not to 4635 * sacrifice the fast file skip, we do a slow skip if the low 4636 * density device has been opened 4637 */ 4638 if ((un->un_dp->options & ST_KNOWS_EOD) != 0) { 4639 if ((un->un_dp->type == ST_TYPE_EXB8500) && 4640 (MT_DENSITY(un->un_dev) == 0)) { 4641 sp_type = Fmk(1); 4642 } else if (un->un_pos.pmode == logical) { 4643 sp_type = SPACE(SP_EOD, 0); 4644 } else { 4645 sp_type = Fmk(MAX_SKIP); 4646 } 4647 } else { 4648 sp_type = Fmk(1); 4649 } 4650 4651 for (;;) { 4652 result = st_cmd(un, SCMD_SPACE, sp_type, SYNC_CMD); 4653 4654 if (result == 0) { 4655 COPY_POS(&savepos, &un->un_pos); 4656 } 4657 4658 if (sp_type == SPACE(SP_EOD, 0)) { 4659 if (result != 0) { 4660 sp_type = Fmk(MAX_SKIP); 4661 continue; 4662 } 4663 4664 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4665 "st_find_eod: 0x%"PRIx64"\n", 4666 savepos.lgclblkno); 4667 /* 4668 * What we return will become the current file position. 4669 * After completing the space command with the position 4670 * mode that is not invalid a read position command will 4671 * be automaticly issued. If the drive support the long 4672 * read position format a valid file position can be 4673 * returned. 4674 */ 4675 return (un->un_pos.fileno); 4676 } 4677 4678 if (result != 0) { 4679 break; 4680 } 4681 4682 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4683 "count=%"PRIx64", eof=%x, status=%x\n", 4684 SPACE_CNT(sp_type), un->un_pos.eof, un->un_status); 4685 4686 /* 4687 * If we're not EOM smart, space a record 4688 * to see whether we're now in the slot between 4689 * the two sequential filemarks that logical 4690 * EOM consists of (REEL) or hit nowhere land 4691 * (8mm). 4692 */ 4693 if (sp_type == Fmk(1)) { 4694 /* 4695 * no fast skipping, check a record 4696 */ 4697 if (st_cmd(un, SCMD_SPACE, Blk((1)), SYNC_CMD)) { 4698 break; 4699 } 4700 if ((un->un_pos.eof >= ST_EOF_PENDING) && 4701 (un->un_dp->options & ST_REEL)) { 4702 un->un_status = KEY_BLANK_CHECK; 4703 un->un_pos.fileno++; 4704 un->un_pos.blkno = 0; 4705 break; 4706 } 4707 if (IN_EOF(un->un_pos)) { 4708 un->un_pos.eof = ST_NO_EOF; 4709 un->un_pos.fileno++; 4710 un->un_pos.blkno = 0; 4711 } 4712 if (un->un_pos.eof > ST_EOF) { 4713 break; 4714 } 4715 } else { 4716 if (un->un_pos.eof > ST_EOF) { 4717 break; 4718 } 4719 } 4720 } 4721 4722 if (un->un_dp->options & ST_KNOWS_EOD) { 4723 COPY_POS(&savepos, &un->un_pos); 4724 } 4725 4726 ASSERT(mutex_owned(ST_MUTEX)); 4727 4728 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4729 "st_find_eod: %x\n", savepos.fileno); 4730 return (savepos.fileno); 4731 } 4732 4733 4734 /* 4735 * this routine is frequently used in ioctls below; 4736 * it determines whether we know the density and if not will 4737 * determine it 4738 * if we have written the tape before, one or more filemarks are written 4739 * 4740 * depending on the stepflag, the head is repositioned to where it was before 4741 * the filemarks were written in order not to confuse step counts 4742 */ 4743 #define STEPBACK 0 4744 #define NO_STEPBACK 1 4745 4746 static int 4747 st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag) 4748 { 4749 4750 GET_SOFT_STATE(dev); 4751 4752 ST_FUNC(ST_DEVINFO, st_check_density_or_wfm); 4753 4754 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4755 "st_check_density_or_wfm(dev= 0x%lx, wfm= %d, mode= %d, stpflg= %d)" 4756 "\n", dev, wfm, mode, stepflag); 4757 4758 ASSERT(mutex_owned(ST_MUTEX)); 4759 4760 /* 4761 * If we don't yet know the density of the tape we have inserted, 4762 * we have to either unconditionally set it (if we're 'writing'), 4763 * or we have to determine it. As side effects, check for any 4764 * write-protect errors, and for the need to put out any file-marks 4765 * before positioning a tape. 4766 * 4767 * If we are going to be spacing forward, and we haven't determined 4768 * the tape density yet, we have to do so now... 4769 */ 4770 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4771 if (st_determine_density(un, mode)) { 4772 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4773 "check_density_or_wfm : EIO can't determine " 4774 "density\n"); 4775 un->un_errno = EIO; 4776 return (EIO); 4777 } 4778 /* 4779 * Presumably we are at BOT. If we attempt to write, it will 4780 * either work okay, or bomb. We don't do a st_test_append 4781 * unless we're past BOT. 4782 */ 4783 un->un_laststate = un->un_state; 4784 un->un_state = ST_STATE_OPEN; 4785 4786 } else if (un->un_pos.pmode != invalid && un->un_fmneeded > 0 && 4787 ((un->un_lastop == ST_OP_WEOF && wfm) || 4788 (un->un_lastop == ST_OP_WRITE && wfm))) { 4789 4790 tapepos_t spos; 4791 4792 COPY_POS(&spos, &un->un_pos); 4793 4794 /* 4795 * We need to write one or two filemarks. 4796 * In the case of the HP, we need to 4797 * position the head between the two 4798 * marks. 4799 */ 4800 if ((un->un_fmneeded > 0) || (un->un_lastop == ST_OP_WEOF)) { 4801 wfm = un->un_fmneeded; 4802 un->un_fmneeded = 0; 4803 } 4804 4805 if (st_write_fm(dev, wfm)) { 4806 un->un_pos.pmode = invalid; 4807 un->un_density_known = 0; 4808 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4809 "check_density_or_wfm : EIO can't write fm\n"); 4810 un->un_errno = EIO; 4811 return (EIO); 4812 } 4813 4814 if (stepflag == STEPBACK) { 4815 if (st_cmd(un, SCMD_SPACE, Fmk(-wfm), SYNC_CMD)) { 4816 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4817 "check_density_or_wfm : EIO can't space " 4818 "(-wfm)\n"); 4819 un->un_errno = EIO; 4820 return (EIO); 4821 } 4822 COPY_POS(&un->un_pos, &spos); 4823 } 4824 } 4825 4826 /* 4827 * Whatever we do at this point clears the state of the eof flag. 4828 */ 4829 4830 un->un_pos.eof = ST_NO_EOF; 4831 4832 /* 4833 * If writing, let's check that we're positioned correctly 4834 * at the end of tape before issuing the next write. 4835 */ 4836 if (un->un_read_only == RDWR) { 4837 un->un_test_append = 1; 4838 } 4839 4840 ASSERT(mutex_owned(ST_MUTEX)); 4841 return (0); 4842 } 4843 4844 4845 /* 4846 * Wait for all outstaning I/O's to complete 4847 * 4848 * we wait on both ncmds and the wait queue for times when we are flushing 4849 * after persistent errors are flagged, which is when ncmds can be 0, and the 4850 * queue can still have I/O's. This way we preserve order of biodone's. 4851 */ 4852 static void 4853 st_wait_for_io(struct scsi_tape *un) 4854 { 4855 ST_FUNC(ST_DEVINFO, st_wait_for_io); 4856 ASSERT(mutex_owned(ST_MUTEX)); 4857 while ((un->un_ncmds) || (un->un_quef) || (un->un_runqf)) { 4858 cv_wait(&un->un_queue_cv, ST_MUTEX); 4859 } 4860 } 4861 4862 /* 4863 * This routine implements the ioctl calls. It is called 4864 * from the device switch at normal priority. 4865 */ 4866 /*ARGSUSED*/ 4867 static int 4868 st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p, 4869 int *rval_p) 4870 { 4871 int tmp, rval = 0; 4872 4873 GET_SOFT_STATE(dev); 4874 4875 ST_ENTR(ST_DEVINFO, st_ioctl); 4876 4877 mutex_enter(ST_MUTEX); 4878 4879 ASSERT(un->un_recov_buf_busy == 0); 4880 4881 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4882 "st_ioctl(): fileno=%x, blkno=%x, eof=%x, state = %d, " 4883 "pe_flag = %d\n", 4884 un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof, un->un_state, 4885 un->un_persistence && un->un_persist_errors); 4886 4887 /* 4888 * We don't want to block on these, so let them through 4889 * and we don't care about setting driver states here. 4890 */ 4891 if ((cmd == MTIOCGETDRIVETYPE) || 4892 (cmd == MTIOCGUARANTEEDORDER) || 4893 (cmd == MTIOCPERSISTENTSTATUS)) { 4894 goto check_commands; 4895 } 4896 4897 /* 4898 * We clear error entry stack except command 4899 * MTIOCGETERROR and MTIOCGET 4900 */ 4901 if ((cmd != MTIOCGETERROR) && 4902 (cmd != MTIOCGET)) { 4903 st_empty_error_stack(un); 4904 } 4905 4906 /* 4907 * wait for all outstanding commands to complete, or be dequeued. 4908 * And because ioctl's are synchronous commands, any return value 4909 * after this, will be in order 4910 */ 4911 st_wait_for_io(un); 4912 4913 /* 4914 * allow only a through clear errors and persistent status, and 4915 * status 4916 */ 4917 if (un->un_persistence && un->un_persist_errors) { 4918 if ((cmd == MTIOCLRERR) || 4919 (cmd == MTIOCPERSISTENT) || 4920 (cmd == MTIOCGET)) { 4921 goto check_commands; 4922 } else { 4923 rval = un->un_errno; 4924 goto exit; 4925 } 4926 } 4927 4928 ASSERT(un->un_throttle != 0); 4929 un->un_throttle = 1; /* > 1 will never happen here */ 4930 un->un_errno = 0; /* start clean from here */ 4931 4932 /* 4933 * first and foremost, handle any ST_EOT_PENDING cases. 4934 * That is, if a logical eot is pending notice, notice it. 4935 */ 4936 if (un->un_pos.eof == ST_EOT_PENDING) { 4937 int resid = un->un_err_resid; 4938 uchar_t status = un->un_status; 4939 uchar_t lastop = un->un_lastop; 4940 4941 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 4942 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4943 "stioctl : EIO can't space fmk(-1)\n"); 4944 rval = EIO; 4945 goto exit; 4946 } 4947 un->un_lastop = lastop; /* restore last operation */ 4948 if (status == SUN_KEY_EOF) { 4949 un->un_status = SUN_KEY_EOT; 4950 } else { 4951 un->un_status = status; 4952 } 4953 un->un_err_resid = resid; 4954 /* fix up block number */ 4955 un->un_err_pos.blkno = un->un_pos.blkno = 0; 4956 /* now we're at logical eot */ 4957 un->un_pos.eof = ST_EOT; 4958 } 4959 4960 /* 4961 * now, handle the rest of the situations 4962 */ 4963 check_commands: 4964 switch (cmd) { 4965 case MTIOCGET: 4966 { 4967 #ifdef _MULTI_DATAMODEL 4968 /* 4969 * For use when a 32 bit app makes a call into a 4970 * 64 bit ioctl 4971 */ 4972 struct mtget32 mtg_local32; 4973 struct mtget32 *mtget_32 = &mtg_local32; 4974 #endif /* _MULTI_DATAMODEL */ 4975 4976 /* Get tape status */ 4977 struct mtget mtg_local; 4978 struct mtget *mtget = &mtg_local; 4979 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 4980 "st_ioctl: MTIOCGET\n"); 4981 4982 bzero((caddr_t)mtget, sizeof (struct mtget)); 4983 mtget->mt_erreg = un->un_status; 4984 mtget->mt_resid = un->un_err_resid; 4985 mtget->mt_dsreg = un->un_retry_ct; 4986 if (un->un_err_pos.pmode == legacy) { 4987 mtget->mt_fileno = un->un_err_pos.fileno; 4988 } else { 4989 mtget->mt_fileno = -1; 4990 } 4991 /* 4992 * If the value is positive fine. 4993 * If its negative we need to return a value based on the 4994 * old way if counting backwards from INF (1,000,000,000). 4995 */ 4996 if (un->un_err_pos.blkno >= 0) { 4997 mtget->mt_blkno = un->un_err_pos.blkno; 4998 } else { 4999 mtget->mt_blkno = INF + 1 - (-un->un_err_pos.blkno); 5000 } 5001 mtget->mt_type = un->un_dp->type; 5002 mtget->mt_flags = MTF_SCSI | MTF_ASF; 5003 if (un->un_read_pos_type != NO_POS) { 5004 mtget->mt_flags |= MTF_LOGICAL_BLOCK; 5005 } 5006 if (un->un_dp->options & ST_REEL) { 5007 mtget->mt_flags |= MTF_REEL; 5008 mtget->mt_bf = 20; 5009 } else { /* 1/4" cartridges */ 5010 switch (mtget->mt_type) { 5011 /* Emulex cartridge tape */ 5012 case MT_ISMT02: 5013 mtget->mt_bf = 40; 5014 break; 5015 default: 5016 mtget->mt_bf = 126; 5017 break; 5018 } 5019 } 5020 5021 /* 5022 * If large transfers are allowed and drive options 5023 * has no record size limit set. Calculate blocking 5024 * factor from the lesser of maxbsize and maxdma. 5025 */ 5026 if ((un->un_allow_large_xfer) && 5027 (un->un_dp->options & ST_NO_RECSIZE_LIMIT)) { 5028 mtget->mt_bf = min(un->un_maxbsize, 5029 un->un_maxdma) / SECSIZE; 5030 } 5031 5032 if (un->un_read_only == WORM || 5033 un->un_read_only == RDWORM) { 5034 mtget->mt_flags |= MTF_WORM_MEDIA; 5035 } 5036 5037 /* 5038 * In persistent error mode sending a non-queued can hang 5039 * because this ioctl gets to be run without turning off 5040 * persistense. Fake the answer based on previous info. 5041 */ 5042 if (un->un_persistence) { 5043 rval = 0; 5044 } else { 5045 rval = st_check_clean_bit(un); 5046 } 5047 if (rval == 0) { 5048 /* 5049 * If zero is returned or in persistent mode, 5050 * use the old data. 5051 */ 5052 if ((un->un_HeadClean & (TAPE_ALERT_SUPPORTED | 5053 TAPE_SEQUENTIAL_SUPPORTED|TAPE_ALERT_NOT_SUPPORTED)) 5054 != TAPE_ALERT_NOT_SUPPORTED) { 5055 mtget->mt_flags |= MTF_TAPE_CLN_SUPPORTED; 5056 } 5057 if (un->un_HeadClean & (TAPE_PREVIOUSLY_DIRTY | 5058 TAPE_ALERT_STILL_DIRTY)) { 5059 mtget->mt_flags |= MTF_TAPE_HEAD_DIRTY; 5060 } 5061 } else { 5062 mtget->mt_flags |= (ushort_t)rval; 5063 rval = 0; 5064 } 5065 5066 un->un_status = 0; /* Reset status */ 5067 un->un_err_resid = 0; 5068 tmp = sizeof (struct mtget); 5069 5070 #ifdef _MULTI_DATAMODEL 5071 5072 switch (ddi_model_convert_from(flag & FMODELS)) { 5073 case DDI_MODEL_ILP32: 5074 /* 5075 * Convert 64 bit back to 32 bit before doing 5076 * copyout. This is what the ILP32 app expects. 5077 */ 5078 mtget_32->mt_erreg = mtget->mt_erreg; 5079 mtget_32->mt_resid = mtget->mt_resid; 5080 mtget_32->mt_dsreg = mtget->mt_dsreg; 5081 mtget_32->mt_fileno = (daddr32_t)mtget->mt_fileno; 5082 mtget_32->mt_blkno = (daddr32_t)mtget->mt_blkno; 5083 mtget_32->mt_type = mtget->mt_type; 5084 mtget_32->mt_flags = mtget->mt_flags; 5085 mtget_32->mt_bf = mtget->mt_bf; 5086 5087 if (ddi_copyout(mtget_32, (void *)arg, 5088 sizeof (struct mtget32), flag)) { 5089 rval = EFAULT; 5090 } 5091 break; 5092 5093 case DDI_MODEL_NONE: 5094 if (ddi_copyout(mtget, (void *)arg, tmp, flag)) { 5095 rval = EFAULT; 5096 } 5097 break; 5098 } 5099 #else /* ! _MULTI_DATAMODE */ 5100 if (ddi_copyout(mtget, (void *)arg, tmp, flag)) { 5101 rval = EFAULT; 5102 } 5103 #endif /* _MULTI_DATAMODE */ 5104 5105 break; 5106 } 5107 case MTIOCGETERROR: 5108 /* 5109 * get error entry from error stack 5110 */ 5111 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5112 "st_ioctl: MTIOCGETERROR\n"); 5113 5114 rval = st_get_error_entry(un, arg, flag); 5115 5116 break; 5117 5118 case MTIOCSTATE: 5119 { 5120 /* 5121 * return when media presence matches state 5122 */ 5123 enum mtio_state state; 5124 5125 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5126 "st_ioctl: MTIOCSTATE\n"); 5127 5128 if (ddi_copyin((void *)arg, &state, sizeof (int), flag)) 5129 rval = EFAULT; 5130 5131 mutex_exit(ST_MUTEX); 5132 5133 rval = st_check_media(dev, state); 5134 5135 mutex_enter(ST_MUTEX); 5136 5137 if (rval != 0) { 5138 break; 5139 } 5140 5141 if (ddi_copyout(&un->un_mediastate, (void *)arg, 5142 sizeof (int), flag)) 5143 rval = EFAULT; 5144 break; 5145 5146 } 5147 5148 case MTIOCGETDRIVETYPE: 5149 { 5150 #ifdef _MULTI_DATAMODEL 5151 /* 5152 * For use when a 32 bit app makes a call into a 5153 * 64 bit ioctl 5154 */ 5155 struct mtdrivetype_request32 mtdtrq32; 5156 #endif /* _MULTI_DATAMODEL */ 5157 5158 /* 5159 * return mtdrivetype 5160 */ 5161 struct mtdrivetype_request mtdtrq; 5162 struct mtdrivetype mtdrtyp; 5163 struct mtdrivetype *mtdt = &mtdrtyp; 5164 struct st_drivetype *stdt = un->un_dp; 5165 5166 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5167 "st_ioctl: MTIOCGETDRIVETYPE\n"); 5168 5169 #ifdef _MULTI_DATAMODEL 5170 switch (ddi_model_convert_from(flag & FMODELS)) { 5171 case DDI_MODEL_ILP32: 5172 { 5173 if (ddi_copyin((void *)arg, &mtdtrq32, 5174 sizeof (struct mtdrivetype_request32), flag)) { 5175 rval = EFAULT; 5176 break; 5177 } 5178 mtdtrq.size = mtdtrq32.size; 5179 mtdtrq.mtdtp = 5180 (struct mtdrivetype *)(uintptr_t)mtdtrq32.mtdtp; 5181 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5182 "st_ioctl: size 0x%x\n", mtdtrq.size); 5183 break; 5184 } 5185 case DDI_MODEL_NONE: 5186 if (ddi_copyin((void *)arg, &mtdtrq, 5187 sizeof (struct mtdrivetype_request), flag)) { 5188 rval = EFAULT; 5189 break; 5190 } 5191 break; 5192 } 5193 5194 #else /* ! _MULTI_DATAMODEL */ 5195 if (ddi_copyin((void *)arg, &mtdtrq, 5196 sizeof (struct mtdrivetype_request), flag)) { 5197 rval = EFAULT; 5198 break; 5199 } 5200 #endif /* _MULTI_DATAMODEL */ 5201 5202 /* 5203 * if requested size is < 0 then return 5204 * error. 5205 */ 5206 if (mtdtrq.size < 0) { 5207 rval = EINVAL; 5208 break; 5209 } 5210 bzero(mtdt, sizeof (struct mtdrivetype)); 5211 (void) strncpy(mtdt->name, stdt->name, ST_NAMESIZE); 5212 (void) strncpy(mtdt->vid, stdt->vid, VIDPIDLEN - 1); 5213 mtdt->type = stdt->type; 5214 mtdt->bsize = stdt->bsize; 5215 mtdt->options = stdt->options; 5216 mtdt->max_rretries = stdt->max_rretries; 5217 mtdt->max_wretries = stdt->max_wretries; 5218 for (tmp = 0; tmp < NDENSITIES; tmp++) { 5219 mtdt->densities[tmp] = stdt->densities[tmp]; 5220 } 5221 mtdt->default_density = stdt->default_density; 5222 /* 5223 * Speed hasn't been used since the hayday of reel tape. 5224 * For all drives not setting the option ST_KNOWS_MEDIA 5225 * the speed member renamed to mediatype are zeros. 5226 * Those drives that have ST_KNOWS_MEDIA set use the 5227 * new mediatype member which is used to figure the 5228 * type of media loaded. 5229 * 5230 * So as to not break applications speed in the 5231 * mtdrivetype structure is not renamed. 5232 */ 5233 for (tmp = 0; tmp < NDENSITIES; tmp++) { 5234 mtdt->speeds[tmp] = stdt->mediatype[tmp]; 5235 } 5236 mtdt->non_motion_timeout = stdt->non_motion_timeout; 5237 mtdt->io_timeout = stdt->io_timeout; 5238 mtdt->rewind_timeout = stdt->rewind_timeout; 5239 mtdt->space_timeout = stdt->space_timeout; 5240 mtdt->load_timeout = stdt->load_timeout; 5241 mtdt->unload_timeout = stdt->unload_timeout; 5242 mtdt->erase_timeout = stdt->erase_timeout; 5243 5244 /* 5245 * Limit the maximum length of the result to 5246 * sizeof (struct mtdrivetype). 5247 */ 5248 tmp = sizeof (struct mtdrivetype); 5249 if (mtdtrq.size < tmp) 5250 tmp = mtdtrq.size; 5251 if (ddi_copyout(mtdt, mtdtrq.mtdtp, tmp, flag)) { 5252 rval = EFAULT; 5253 } 5254 break; 5255 } 5256 case MTIOCPERSISTENT: 5257 5258 if (ddi_copyin((void *)arg, &tmp, sizeof (tmp), flag)) { 5259 rval = EFAULT; 5260 break; 5261 } 5262 5263 if (tmp) { 5264 st_turn_pe_on(un); 5265 } else { 5266 st_turn_pe_off(un); 5267 } 5268 5269 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5270 "st_ioctl: MTIOCPERSISTENT : persistence = %d\n", 5271 un->un_persistence); 5272 5273 break; 5274 5275 case MTIOCPERSISTENTSTATUS: 5276 tmp = (int)un->un_persistence; 5277 5278 if (ddi_copyout(&tmp, (void *)arg, sizeof (tmp), flag)) { 5279 rval = EFAULT; 5280 } 5281 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5282 "st_ioctl: MTIOCPERSISTENTSTATUS:persistence = %d\n", 5283 un->un_persistence); 5284 5285 break; 5286 5287 case MTIOCLRERR: 5288 { 5289 /* clear persistent errors */ 5290 5291 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5292 "st_ioctl: MTIOCLRERR\n"); 5293 5294 st_clear_pe(un); 5295 5296 break; 5297 } 5298 5299 case MTIOCGUARANTEEDORDER: 5300 { 5301 /* 5302 * this is just a holder to make a valid ioctl and 5303 * it won't be in any earlier release 5304 */ 5305 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5306 "st_ioctl: MTIOCGUARANTEEDORDER\n"); 5307 5308 break; 5309 } 5310 5311 case MTIOCRESERVE: 5312 { 5313 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5314 "st_ioctl: MTIOCRESERVE\n"); 5315 5316 /* 5317 * Check if Reserve/Release is supported. 5318 */ 5319 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5320 rval = ENOTTY; 5321 break; 5322 } 5323 5324 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 5325 5326 if (rval == 0) { 5327 un->un_rsvd_status |= ST_PRESERVE_RESERVE; 5328 } 5329 break; 5330 } 5331 5332 case MTIOCRELEASE: 5333 { 5334 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5335 "st_ioctl: MTIOCRELEASE\n"); 5336 5337 /* 5338 * Check if Reserve/Release is supported. 5339 */ 5340 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5341 rval = ENOTTY; 5342 break; 5343 } 5344 5345 /* 5346 * Used to just clear ST_PRESERVE_RESERVE which 5347 * made the reservation release at next close. 5348 * As the user may have opened and then done a 5349 * persistant reservation we now need to drop 5350 * the reservation without closing if the user 5351 * attempts to do this. 5352 */ 5353 rval = st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 5354 5355 un->un_rsvd_status &= ~ST_PRESERVE_RESERVE; 5356 5357 break; 5358 } 5359 5360 case MTIOCFORCERESERVE: 5361 { 5362 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5363 "st_ioctl: MTIOCFORCERESERVE\n"); 5364 5365 /* 5366 * Check if Reserve/Release is supported. 5367 */ 5368 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5369 rval = ENOTTY; 5370 break; 5371 } 5372 /* 5373 * allow only super user to run this. 5374 */ 5375 if (drv_priv(cred_p) != 0) { 5376 rval = EPERM; 5377 break; 5378 } 5379 /* 5380 * Throw away reserve, 5381 * not using test-unit-ready 5382 * since reserve can succeed without tape being 5383 * present in the drive. 5384 */ 5385 (void) st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 5386 5387 rval = st_take_ownership(un, st_uscsi_cmd); 5388 5389 break; 5390 } 5391 5392 case USCSICMD: 5393 { 5394 cred_t *cr; 5395 5396 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5397 "st_ioctl: USCSICMD\n"); 5398 5399 cr = ddi_get_cred(); 5400 if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) { 5401 rval = EPERM; 5402 } else { 5403 rval = st_uscsi_cmd(un, (struct uscsi_cmd *)arg, flag); 5404 } 5405 break; 5406 } 5407 case MTIOCTOP: 5408 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5409 "st_ioctl: MTIOCTOP\n"); 5410 rval = st_mtioctop(un, arg, flag); 5411 break; 5412 5413 case MTIOCLTOP: 5414 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5415 "st_ioctl: MTIOLCTOP\n"); 5416 rval = st_mtiocltop(un, arg, flag); 5417 break; 5418 5419 case MTIOCREADIGNOREILI: 5420 { 5421 int set_ili; 5422 5423 if (ddi_copyin((void *)arg, &set_ili, 5424 sizeof (set_ili), flag)) { 5425 rval = EFAULT; 5426 break; 5427 } 5428 5429 if (un->un_bsize) { 5430 rval = ENOTTY; 5431 break; 5432 } 5433 5434 switch (set_ili) { 5435 case 0: 5436 un->un_dp->options &= ~ST_READ_IGNORE_ILI; 5437 break; 5438 5439 case 1: 5440 un->un_dp->options |= ST_READ_IGNORE_ILI; 5441 break; 5442 5443 default: 5444 rval = EINVAL; 5445 break; 5446 } 5447 break; 5448 } 5449 5450 case MTIOCREADIGNOREEOFS: 5451 { 5452 int ignore_eof; 5453 5454 if (ddi_copyin((void *)arg, &ignore_eof, 5455 sizeof (ignore_eof), flag)) { 5456 rval = EFAULT; 5457 break; 5458 } 5459 5460 if (!(un->un_dp->options & ST_REEL)) { 5461 rval = ENOTTY; 5462 break; 5463 } 5464 5465 switch (ignore_eof) { 5466 case 0: 5467 un->un_dp->options &= ~ST_READ_IGNORE_EOFS; 5468 break; 5469 5470 case 1: 5471 un->un_dp->options |= ST_READ_IGNORE_EOFS; 5472 break; 5473 5474 default: 5475 rval = EINVAL; 5476 break; 5477 } 5478 break; 5479 } 5480 5481 case MTIOCSHORTFMK: 5482 { 5483 int short_fmk; 5484 5485 if (ddi_copyin((void *)arg, &short_fmk, 5486 sizeof (short_fmk), flag)) { 5487 rval = EFAULT; 5488 break; 5489 } 5490 5491 switch (un->un_dp->type) { 5492 case ST_TYPE_EXB8500: 5493 case ST_TYPE_EXABYTE: 5494 if (!short_fmk) { 5495 un->un_dp->options &= ~ST_SHORT_FILEMARKS; 5496 } else if (short_fmk == 1) { 5497 un->un_dp->options |= ST_SHORT_FILEMARKS; 5498 } else { 5499 rval = EINVAL; 5500 } 5501 break; 5502 5503 default: 5504 rval = ENOTTY; 5505 break; 5506 } 5507 break; 5508 } 5509 5510 case MTIOCGETPOS: 5511 rval = st_update_block_pos(un, st_cmd, 0); 5512 if (rval == 0) { 5513 if (ddi_copyout((void *)&un->un_pos, (void *)arg, 5514 sizeof (tapepos_t), flag)) { 5515 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 5516 "MTIOCGETPOS copy out failed\n"); 5517 rval = EFAULT; 5518 } 5519 } 5520 break; 5521 5522 case MTIOCRESTPOS: 5523 { 5524 tapepos_t dest; 5525 5526 if (ddi_copyin((void *)arg, &dest, sizeof (tapepos_t), 5527 flag) != 0) { 5528 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 5529 "MTIOCRESTPOS copy in failed\n"); 5530 rval = EFAULT; 5531 break; 5532 } 5533 rval = st_validate_tapemarks(un, st_uscsi_cmd, &dest); 5534 if (rval != 0) { 5535 rval = EIO; 5536 } 5537 break; 5538 } 5539 default: 5540 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5541 "st_ioctl: unknown ioctl\n"); 5542 rval = ENOTTY; 5543 } 5544 5545 exit: 5546 if (!(un->un_persistence && un->un_persist_errors)) { 5547 un->un_errno = rval; 5548 } 5549 5550 mutex_exit(ST_MUTEX); 5551 5552 return (rval); 5553 } 5554 5555 5556 /* 5557 * do some MTIOCTOP tape operations 5558 */ 5559 static int 5560 st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag) 5561 { 5562 #ifdef _MULTI_DATAMODEL 5563 /* 5564 * For use when a 32 bit app makes a call into a 5565 * 64 bit ioctl 5566 */ 5567 struct mtop32 mtop_32_for_64; 5568 #endif /* _MULTI_DATAMODEL */ 5569 struct mtop passed; 5570 struct mtlop local; 5571 int rval = 0; 5572 5573 ST_FUNC(ST_DEVINFO, st_mtioctop); 5574 5575 ASSERT(mutex_owned(ST_MUTEX)); 5576 5577 #ifdef _MULTI_DATAMODEL 5578 switch (ddi_model_convert_from(flag & FMODELS)) { 5579 case DDI_MODEL_ILP32: 5580 if (ddi_copyin((void *)arg, &mtop_32_for_64, 5581 sizeof (struct mtop32), flag)) { 5582 return (EFAULT); 5583 } 5584 local.mt_op = mtop_32_for_64.mt_op; 5585 local.mt_count = (int64_t)mtop_32_for_64.mt_count; 5586 break; 5587 5588 case DDI_MODEL_NONE: 5589 if (ddi_copyin((void *)arg, &passed, sizeof (passed), flag)) { 5590 return (EFAULT); 5591 } 5592 local.mt_op = passed.mt_op; 5593 /* prevent sign extention */ 5594 local.mt_count = (UINT32_MAX & passed.mt_count); 5595 break; 5596 } 5597 5598 #else /* ! _MULTI_DATAMODEL */ 5599 if (ddi_copyin((void *)arg, &passed, sizeof (passed), flag)) { 5600 return (EFAULT); 5601 } 5602 local.mt_op = passed.mt_op; 5603 /* prevent sign extention */ 5604 local.mt_count = (UINT32_MAX & passed.mt_count); 5605 #endif /* _MULTI_DATAMODEL */ 5606 5607 rval = st_do_mtioctop(un, &local); 5608 5609 #ifdef _MULTI_DATAMODEL 5610 switch (ddi_model_convert_from(flag & FMODELS)) { 5611 case DDI_MODEL_ILP32: 5612 if (((uint64_t)local.mt_count) > UINT32_MAX) { 5613 rval = ERANGE; 5614 break; 5615 } 5616 /* 5617 * Convert 64 bit back to 32 bit before doing 5618 * copyout. This is what the ILP32 app expects. 5619 */ 5620 mtop_32_for_64.mt_op = local.mt_op; 5621 mtop_32_for_64.mt_count = local.mt_count; 5622 5623 if (ddi_copyout(&mtop_32_for_64, (void *)arg, 5624 sizeof (struct mtop32), flag)) { 5625 rval = EFAULT; 5626 } 5627 break; 5628 5629 case DDI_MODEL_NONE: 5630 passed.mt_count = local.mt_count; 5631 passed.mt_op = local.mt_op; 5632 if (ddi_copyout(&passed, (void *)arg, sizeof (passed), flag)) { 5633 rval = EFAULT; 5634 } 5635 break; 5636 } 5637 #else /* ! _MULTI_DATAMODE */ 5638 if (((uint64_t)local.mt_count) > UINT32_MAX) { 5639 rval = ERANGE; 5640 } else { 5641 passed.mt_op = local.mt_op; 5642 passed.mt_count = local.mt_count; 5643 if (ddi_copyout(&passed, (void *)arg, sizeof (passed), flag)) { 5644 rval = EFAULT; 5645 } 5646 } 5647 #endif /* _MULTI_DATAMODE */ 5648 5649 5650 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 5651 "st_ioctl: fileno=%x, blkno=%x, eof=%x\n", un->un_pos.fileno, 5652 un->un_pos.blkno, un->un_pos.eof); 5653 5654 if (un->un_pos.pmode == invalid) { 5655 un->un_density_known = 0; 5656 } 5657 5658 ASSERT(mutex_owned(ST_MUTEX)); 5659 return (rval); 5660 } 5661 5662 static int 5663 st_mtiocltop(struct scsi_tape *un, intptr_t arg, int flag) 5664 { 5665 struct mtlop local; 5666 int rval; 5667 5668 ST_FUNC(ST_DEVINFO, st_mtiocltop); 5669 if (ddi_copyin((void *)arg, &local, sizeof (local), flag)) { 5670 return (EFAULT); 5671 } 5672 5673 rval = st_do_mtioctop(un, &local); 5674 5675 if (ddi_copyout(&local, (void *)arg, sizeof (local), flag)) { 5676 rval = EFAULT; 5677 } 5678 return (rval); 5679 } 5680 5681 5682 static int 5683 st_do_mtioctop(struct scsi_tape *un, struct mtlop *mtop) 5684 { 5685 dev_t dev = un->un_dev; 5686 int savefile; 5687 int rval = 0; 5688 5689 ST_FUNC(ST_DEVINFO, st_do_mtioctop); 5690 5691 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5692 "st_do_mtioctop(): mt_op=%x\n", mtop->mt_op); 5693 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5694 "fileno=%x, blkno=%x, eof=%x\n", 5695 un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 5696 5697 un->un_status = 0; 5698 5699 /* 5700 * if we are going to mess with a tape, we have to make sure we have 5701 * one and are not offline (i.e. no tape is initialized). We let 5702 * commands pass here that don't actually touch the tape, except for 5703 * loading and initialization (rewinding). 5704 */ 5705 if (un->un_state == ST_STATE_OFFLINE) { 5706 switch (mtop->mt_op) { 5707 case MTLOAD: 5708 case MTNOP: 5709 /* 5710 * We don't want strategy calling st_tape_init here, 5711 * so, change state 5712 */ 5713 un->un_state = ST_STATE_INITIALIZING; 5714 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5715 "st_do_mtioctop : OFFLINE state = %d\n", 5716 un->un_state); 5717 break; 5718 default: 5719 /* 5720 * reinitialize by normal means 5721 */ 5722 rval = st_tape_init(un); 5723 if (rval) { 5724 un->un_state = ST_STATE_INITIALIZING; 5725 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5726 "st_do_mtioctop : OFFLINE init failure "); 5727 un->un_state = ST_STATE_OFFLINE; 5728 un->un_pos.pmode = invalid; 5729 if (rval != EACCES) { 5730 rval = EIO; 5731 } 5732 return (rval); 5733 } 5734 un->un_state = ST_STATE_OPEN_PENDING_IO; 5735 break; 5736 } 5737 } 5738 5739 /* 5740 * If the file position is invalid, allow only those 5741 * commands that properly position the tape and fail 5742 * the rest with EIO 5743 */ 5744 if (un->un_pos.pmode == invalid) { 5745 switch (mtop->mt_op) { 5746 case MTWEOF: 5747 case MTRETEN: 5748 case MTERASE: 5749 case MTEOM: 5750 case MTFSF: 5751 case MTFSR: 5752 case MTBSF: 5753 case MTNBSF: 5754 case MTBSR: 5755 case MTSRSZ: 5756 case MTGRSZ: 5757 case MTSEEK: 5758 case MTBSSF: 5759 case MTFSSF: 5760 return (EIO); 5761 /* NOTREACHED */ 5762 case MTREW: 5763 case MTLOAD: 5764 case MTOFFL: 5765 case MTNOP: 5766 case MTTELL: 5767 case MTLOCK: 5768 case MTUNLOCK: 5769 break; 5770 5771 default: 5772 return (ENOTTY); 5773 /* NOTREACHED */ 5774 } 5775 } 5776 5777 switch (mtop->mt_op) { 5778 case MTERASE: 5779 /* 5780 * MTERASE rewinds the tape, erase it completely, and returns 5781 * to the beginning of the tape 5782 */ 5783 if (un->un_mspl->wp || un->un_read_only & WORM) { 5784 un->un_status = KEY_WRITE_PROTECT; 5785 un->un_err_resid = mtop->mt_count; 5786 COPY_POS(&un->un_err_pos, &un->un_pos); 5787 return (EACCES); 5788 } 5789 if (un->un_dp->options & ST_REEL) { 5790 un->un_fmneeded = 2; 5791 } else { 5792 un->un_fmneeded = 1; 5793 } 5794 mtop->mt_count = mtop->mt_count ? 1 : 0; 5795 if (st_check_density_or_wfm(dev, 1, B_WRITE, NO_STEPBACK) || 5796 st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 5797 st_cmd(un, SCMD_ERASE, mtop->mt_count, SYNC_CMD)) { 5798 un->un_pos.pmode = invalid; 5799 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5800 "st_do_mtioctop : EIO space or erase or " 5801 "check den)\n"); 5802 rval = EIO; 5803 } else { 5804 /* QIC and helical scan rewind after erase */ 5805 if (un->un_dp->options & ST_REEL) { 5806 (void) st_cmd(un, SCMD_REWIND, 0, ASYNC_CMD); 5807 } 5808 } 5809 break; 5810 5811 case MTWEOF: 5812 /* 5813 * write an end-of-file record 5814 */ 5815 if (un->un_mspl->wp || un->un_read_only & RDONLY) { 5816 un->un_status = KEY_WRITE_PROTECT; 5817 un->un_err_resid = mtop->mt_count; 5818 COPY_POS(&un->un_err_pos, &un->un_pos); 5819 return (EACCES); 5820 } 5821 5822 /* 5823 * zero count means just flush buffers 5824 * negative count is not permitted 5825 */ 5826 if (mtop->mt_count < 0) { 5827 return (EINVAL); 5828 } 5829 5830 /* Not on worm */ 5831 if (un->un_read_only == RDWR) { 5832 un->un_test_append = 1; 5833 } 5834 5835 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 5836 if (st_determine_density(un, B_WRITE)) { 5837 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5838 "st_do_mtioctop : EIO : MTWEOF can't " 5839 "determine density"); 5840 return (EIO); 5841 } 5842 } 5843 5844 rval = st_write_fm(dev, (int)mtop->mt_count); 5845 if ((rval != 0) && (rval != EACCES)) { 5846 /* 5847 * Failure due to something other than illegal 5848 * request results in loss of state (st_intr). 5849 */ 5850 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5851 "st_do_mtioctop : EIO : MTWEOF can't write " 5852 "file mark"); 5853 rval = EIO; 5854 } 5855 break; 5856 5857 case MTRETEN: 5858 /* 5859 * retension the tape 5860 */ 5861 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK) || 5862 st_cmd(un, SCMD_LOAD, LD_LOAD | LD_RETEN, SYNC_CMD)) { 5863 un->un_pos.pmode = invalid; 5864 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5865 "st_do_mtioctop : EIO : MTRETEN "); 5866 rval = EIO; 5867 } 5868 break; 5869 5870 case MTREW: 5871 /* 5872 * rewind the tape 5873 */ 5874 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) { 5875 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5876 "st_do_mtioctop : EIO:MTREW check " 5877 "density/wfm failed"); 5878 return (EIO); 5879 } 5880 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 5881 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5882 "st_do_mtioctop : EIO : MTREW "); 5883 rval = EIO; 5884 } 5885 break; 5886 5887 case MTOFFL: 5888 /* 5889 * rewinds, and, if appropriate, takes the device offline by 5890 * unloading the tape 5891 */ 5892 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) { 5893 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5894 "st_do_mtioctop :EIO:MTOFFL check " 5895 "density/wfm failed"); 5896 return (EIO); 5897 } 5898 (void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 5899 if (st_cmd(un, SCMD_LOAD, LD_UNLOAD, SYNC_CMD)) { 5900 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5901 "st_do_mtioctop : EIO : MTOFFL"); 5902 return (EIO); 5903 } 5904 un->un_pos.eof = ST_NO_EOF; 5905 un->un_laststate = un->un_state; 5906 un->un_state = ST_STATE_OFFLINE; 5907 un->un_mediastate = MTIO_EJECTED; 5908 break; 5909 5910 case MTLOAD: 5911 /* 5912 * This is to load a tape into the drive 5913 * Note that if the tape is not loaded, the device will have 5914 * to be opened via O_NDELAY or O_NONBLOCK. 5915 */ 5916 /* 5917 * Let's try and clean things up, if we are not 5918 * initializing, and then send in the load command, no 5919 * matter what. 5920 * 5921 * load after a media change by the user. 5922 */ 5923 5924 if (un->un_state > ST_STATE_INITIALIZING) { 5925 (void) st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK); 5926 } 5927 rval = st_cmd(un, SCMD_LOAD, LD_LOAD, SYNC_CMD); 5928 /* Load command to a drive that doesn't support load */ 5929 if ((rval == EIO) && 5930 ((un->un_status == KEY_NOT_READY) && 5931 /* Medium not present */ 5932 (un->un_uscsi_rqs_buf->es_add_code == 0x3a) || 5933 ((un->un_status == KEY_ILLEGAL_REQUEST) && 5934 (un->un_dp->type == MT_ISSTK9840) && 5935 /* CSL not present */ 5936 (un->un_uscsi_rqs_buf->es_add_code == 0x80)))) { 5937 rval = ENOTTY; 5938 break; 5939 } else if (rval != EACCES && rval != 0) { 5940 rval = EIO; 5941 } 5942 if (rval) { 5943 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5944 "st_do_mtioctop : %s : MTLOAD\n", 5945 rval == EACCES ? "EACCES" : "EIO"); 5946 /* 5947 * If load tape fails, who knows what happened... 5948 */ 5949 un->un_pos.pmode = invalid; 5950 break; 5951 } 5952 5953 /* 5954 * reset all counters appropriately using rewind, as if LOAD 5955 * succeeds, we are at BOT 5956 */ 5957 un->un_state = ST_STATE_INITIALIZING; 5958 5959 rval = st_tape_init(un); 5960 if ((rval == EACCES) && (un->un_read_only & WORM)) { 5961 rval = 0; 5962 break; 5963 } 5964 5965 if (rval != 0) { 5966 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5967 "st_do_mtioctop : EIO : MTLOAD calls " 5968 "st_tape_init\n"); 5969 rval = EIO; 5970 un->un_state = ST_STATE_OFFLINE; 5971 } 5972 5973 break; 5974 5975 case MTNOP: 5976 un->un_status = 0; /* Reset status */ 5977 un->un_err_resid = 0; 5978 mtop->mt_count = MTUNIT(dev); 5979 break; 5980 5981 case MTEOM: 5982 /* 5983 * positions the tape at a location just after the last file 5984 * written on the tape. For cartridge and 8 mm, this after 5985 * the last file mark; for reel, this is inbetween the two 5986 * last 2 file marks 5987 */ 5988 if ((un->un_pos.pmode == legacy && un->un_pos.eof >= ST_EOT) || 5989 (un->un_lastop == ST_OP_WRITE) || 5990 (un->un_lastop == ST_OP_WEOF)) { 5991 /* 5992 * If the command wants to move to logical end 5993 * of media, and we're already there, we're done. 5994 * If we were at logical eot, we reset the state 5995 * to be *not* at logical eot. 5996 * 5997 * If we're at physical or logical eot, we prohibit 5998 * forward space operations (unconditionally). 5999 * 6000 * Also if the last operation was a write of any 6001 * kind the tape is at EOD. 6002 */ 6003 return (0); 6004 } 6005 /* 6006 * physical tape position may not be what we've been 6007 * telling the user; adjust the request accordingly 6008 */ 6009 if (IN_EOF(un->un_pos)) { 6010 un->un_pos.fileno++; 6011 un->un_pos.blkno = 0; 6012 } 6013 6014 if (st_check_density_or_wfm(dev, 1, B_READ, NO_STEPBACK)) { 6015 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6016 "st_do_mtioctop : EIO:MTEOM check density/wfm " 6017 " failed"); 6018 return (EIO); 6019 } 6020 6021 /* 6022 * st_find_eod() returns the last fileno we knew about; 6023 */ 6024 savefile = st_find_eod(un); 6025 6026 if ((un->un_status != KEY_BLANK_CHECK) && 6027 (un->un_status != SUN_KEY_EOT)) { 6028 un->un_pos.pmode = invalid; 6029 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6030 "st_do_mtioctop : EIO : MTEOM status check failed"); 6031 rval = EIO; 6032 } else { 6033 /* 6034 * For 1/2" reel tapes assume logical EOT marked 6035 * by two file marks or we don't care that we may 6036 * be extending the last file on the tape. 6037 */ 6038 if (un->un_dp->options & ST_REEL) { 6039 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 6040 un->un_pos.pmode = invalid; 6041 ST_DEBUG2(ST_DEVINFO, st_label, 6042 SCSI_DEBUG, 6043 "st_do_mtioctop : EIO : MTEOM space" 6044 " cmd failed"); 6045 rval = EIO; 6046 break; 6047 } 6048 /* 6049 * Fix up the block number. 6050 */ 6051 un->un_pos.blkno = 0; 6052 un->un_err_pos.blkno = 0; 6053 } 6054 un->un_err_resid = 0; 6055 un->un_pos.fileno = savefile; 6056 un->un_pos.eof = ST_EOT; 6057 } 6058 un->un_status = 0; 6059 break; 6060 6061 case MTFSF: 6062 MAX_SPACE_CNT(mtop->mt_count); 6063 rval = st_mtfsf_ioctl(un, mtop->mt_count); 6064 break; 6065 6066 case MTFSR: 6067 MAX_SPACE_CNT(mtop->mt_count); 6068 rval = st_mtfsr_ioctl(un, mtop->mt_count); 6069 break; 6070 6071 case MTBSF: 6072 MAX_SPACE_CNT(mtop->mt_count); 6073 rval = st_mtbsf_ioctl(un, mtop->mt_count); 6074 break; 6075 6076 case MTNBSF: 6077 MAX_SPACE_CNT(mtop->mt_count); 6078 rval = st_mtnbsf_ioctl(un, mtop->mt_count); 6079 break; 6080 6081 case MTBSR: 6082 MAX_SPACE_CNT(mtop->mt_count); 6083 rval = st_mtbsr_ioctl(un, mtop->mt_count); 6084 break; 6085 6086 case MTBSSF: 6087 MAX_SPACE_CNT(mtop->mt_count); 6088 rval = st_mtbsfm_ioctl(un, mtop->mt_count); 6089 break; 6090 6091 case MTFSSF: 6092 MAX_SPACE_CNT(mtop->mt_count); 6093 rval = st_mtfsfm_ioctl(un, mtop->mt_count); 6094 break; 6095 6096 case MTSRSZ: 6097 6098 /* 6099 * Set record-size to that sent by user 6100 * Check to see if there is reason that the requested 6101 * block size should not be set. 6102 */ 6103 6104 /* If requesting variable block size is it ok? */ 6105 if ((mtop->mt_count == 0) && 6106 ((un->un_dp->options & ST_VARIABLE) == 0)) { 6107 return (ENOTTY); 6108 } 6109 6110 /* 6111 * If requested block size is not variable "0", 6112 * is it less then minimum. 6113 */ 6114 if ((mtop->mt_count != 0) && 6115 (mtop->mt_count < un->un_minbsize)) { 6116 return (EINVAL); 6117 } 6118 6119 /* Is the requested block size more then maximum */ 6120 if ((mtop->mt_count > min(un->un_maxbsize, un->un_maxdma)) && 6121 (un->un_maxbsize != 0)) { 6122 return (EINVAL); 6123 } 6124 6125 /* Is requested block size a modulus the device likes */ 6126 if ((mtop->mt_count % un->un_data_mod) != 0) { 6127 return (EINVAL); 6128 } 6129 6130 if (st_change_block_size(un, (uint32_t)mtop->mt_count) != 0) { 6131 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6132 "st_ioctl : MTSRSZ : EIO : cant set block size"); 6133 return (EIO); 6134 } 6135 6136 return (0); 6137 6138 case MTGRSZ: 6139 /* 6140 * Get record-size to the user 6141 */ 6142 mtop->mt_count = un->un_bsize; 6143 rval = 0; 6144 break; 6145 6146 case MTTELL: 6147 rval = st_update_block_pos(un, st_cmd, 0); 6148 mtop->mt_count = un->un_pos.lgclblkno; 6149 break; 6150 6151 case MTSEEK: 6152 rval = st_logical_block_locate(un, st_uscsi_cmd, &un->un_pos, 6153 (uint64_t)mtop->mt_count, un->un_pos.partition); 6154 /* 6155 * This bit of magic make mt print the actual position if 6156 * the resulting position was not what was asked for. 6157 */ 6158 if (rval == ESPIPE) { 6159 rval = EIO; 6160 if ((uint64_t)mtop->mt_count != un->un_pos.lgclblkno) { 6161 mtop->mt_op = MTTELL; 6162 mtop->mt_count = un->un_pos.lgclblkno; 6163 } 6164 } 6165 break; 6166 6167 case MTLOCK: 6168 if (st_cmd(un, SCMD_DOORLOCK, MR_LOCK, SYNC_CMD)) { 6169 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6170 "st_do_mtioctop : EIO : MTLOCK"); 6171 rval = EIO; 6172 } 6173 break; 6174 6175 case MTUNLOCK: 6176 if (st_cmd(un, SCMD_DOORLOCK, MR_UNLOCK, SYNC_CMD)) { 6177 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6178 "st_do_mtioctop : EIO : MTUNLOCK"); 6179 rval = EIO; 6180 } 6181 break; 6182 6183 default: 6184 rval = ENOTTY; 6185 } 6186 6187 return (rval); 6188 } 6189 6190 6191 /* 6192 * Run a command for uscsi ioctl. 6193 */ 6194 static int 6195 st_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, int flag) 6196 { 6197 struct uscsi_cmd *uscmd; 6198 struct buf *bp; 6199 enum uio_seg uioseg; 6200 int offline_state = 0; 6201 int err = 0; 6202 dev_t dev = un->un_dev; 6203 6204 ST_FUNC(ST_DEVINFO, st_uscsi_cmd); 6205 6206 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6207 "st_uscsi_cmd(dev = 0x%lx)\n", un->un_dev); 6208 6209 ASSERT(mutex_owned(ST_MUTEX)); 6210 6211 /* 6212 * We really don't know what commands are coming in here and 6213 * we don't want to limit the commands coming in. 6214 * 6215 * If st_tape_init() gets called from st_strategy(), then we 6216 * will hang the process waiting for un->un_sbuf_busy to be cleared, 6217 * which it never will, as we set it below. To prevent 6218 * st_tape_init() from getting called, we have to set state to other 6219 * than ST_STATE_OFFLINE, so we choose ST_STATE_INITIALIZING, which 6220 * achieves this purpose already. 6221 * 6222 * We use offline_state to preserve the OFFLINE state, if it exists, 6223 * so other entry points to the driver might have the chance to call 6224 * st_tape_init(). 6225 */ 6226 if (un->un_state == ST_STATE_OFFLINE) { 6227 un->un_laststate = ST_STATE_OFFLINE; 6228 un->un_state = ST_STATE_INITIALIZING; 6229 offline_state = 1; 6230 } 6231 6232 mutex_exit(ST_MUTEX); 6233 err = scsi_uscsi_alloc_and_copyin((intptr_t)ucmd, flag, ROUTE, &uscmd); 6234 mutex_enter(ST_MUTEX); 6235 if (err != 0) { 6236 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6237 "st_uscsi_cmd: scsi_uscsi_alloc_and_copyin failed\n"); 6238 goto exit; 6239 } 6240 6241 uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE : UIO_USERSPACE; 6242 6243 /* check to see if this command requires the drive to be reserved */ 6244 if (uscmd->uscsi_cdb != NULL) { 6245 err = st_check_cdb_for_need_to_reserve(un, 6246 (uchar_t *)uscmd->uscsi_cdb); 6247 if (err) { 6248 goto exit_free; 6249 } 6250 /* 6251 * If this is a space command we need to save the starting 6252 * point so we can retry from there if the command fails. 6253 */ 6254 if ((uscmd->uscsi_cdb[0] == SCMD_SPACE) || 6255 (uscmd->uscsi_cdb[0] == (char)SCMD_SPACE_G4)) { 6256 (void) st_update_block_pos(un, st_cmd, 0); 6257 } 6258 } 6259 6260 /* 6261 * Forground should not be doing anything while recovery is active. 6262 */ 6263 ASSERT(un->un_recov_buf_busy == 0); 6264 6265 /* 6266 * Get buffer resources... 6267 */ 6268 while (un->un_sbuf_busy) 6269 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 6270 un->un_sbuf_busy = 1; 6271 6272 #ifdef STDEBUG 6273 if ((uscmd->uscsi_cdb != NULL) && (st_debug & 0x7) > 6) { 6274 int rw = (uscmd->uscsi_flags & USCSI_READ) ? B_READ : B_WRITE; 6275 st_print_cdb(ST_DEVINFO, st_label, SCSI_DEBUG, 6276 "uscsi cdb", uscmd->uscsi_cdb); 6277 if (uscmd->uscsi_buflen) { 6278 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6279 "uscsi %s of %ld bytes %s %s space\n", 6280 (rw == B_READ) ? rd_str : wr_str, 6281 uscmd->uscsi_buflen, 6282 (rw == B_READ) ? "to" : "from", 6283 (uioseg == UIO_SYSSPACE) ? "system" : "user"); 6284 } 6285 } 6286 #endif /* STDEBUG */ 6287 6288 /* 6289 * Although st_uscsi_cmd() never makes use of these 6290 * now, we are just being safe and consistent. 6291 */ 6292 uscmd->uscsi_flags &= ~(USCSI_NOINTR | USCSI_NOPARITY | 6293 USCSI_OTAG | USCSI_HTAG | USCSI_HEAD); 6294 6295 un->un_srqbufp = uscmd->uscsi_rqbuf; 6296 bp = un->un_sbufp; 6297 bzero(bp, sizeof (buf_t)); 6298 if (uscmd->uscsi_cdb != NULL) { 6299 bp->b_forw = (struct buf *)(uintptr_t)uscmd->uscsi_cdb[0]; 6300 } 6301 bp->b_back = (struct buf *)uscmd; 6302 6303 mutex_exit(ST_MUTEX); 6304 err = scsi_uscsi_handle_cmd(dev, uioseg, uscmd, st_strategy, bp, NULL); 6305 mutex_enter(ST_MUTEX); 6306 6307 /* 6308 * If scsi reset successful, don't write any filemarks. 6309 */ 6310 if ((err == 0) && (uscmd->uscsi_flags & 6311 (USCSI_RESET_LUN | USCSI_RESET_TARGET | USCSI_RESET_ALL))) { 6312 un->un_fmneeded = 0; 6313 } 6314 6315 exit_free: 6316 /* 6317 * Free resources 6318 */ 6319 un->un_sbuf_busy = 0; 6320 un->un_srqbufp = NULL; 6321 6322 /* 6323 * If was a space command need to update logical block position. 6324 * If the command failed such that positioning is invalid, Don't 6325 * update the position as the user must do this to validate the 6326 * position for data protection. 6327 */ 6328 if ((uscmd->uscsi_cdb != NULL) && 6329 ((uscmd->uscsi_cdb[0] == SCMD_SPACE) || 6330 (uscmd->uscsi_cdb[0] == (char)SCMD_SPACE_G4)) && 6331 (un->un_pos.pmode != invalid)) { 6332 un->un_running.pmode = invalid; 6333 (void) st_update_block_pos(un, st_cmd, 1); 6334 /* 6335 * Set running position to invalid so it updates on the 6336 * next command. 6337 */ 6338 un->un_running.pmode = invalid; 6339 } 6340 cv_signal(&un->un_sbuf_cv); 6341 mutex_exit(ST_MUTEX); 6342 (void) scsi_uscsi_copyout_and_free((intptr_t)ucmd, uscmd); 6343 mutex_enter(ST_MUTEX); 6344 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6345 "st_uscsi_cmd returns 0x%x\n", err); 6346 6347 exit: 6348 /* don't lose offline state */ 6349 if (offline_state) { 6350 un->un_state = ST_STATE_OFFLINE; 6351 } 6352 6353 ASSERT(mutex_owned(ST_MUTEX)); 6354 return (err); 6355 } 6356 6357 static int 6358 st_write_fm(dev_t dev, int wfm) 6359 { 6360 int i; 6361 int rval; 6362 6363 GET_SOFT_STATE(dev); 6364 6365 ST_FUNC(ST_DEVINFO, st_write_fm); 6366 6367 ASSERT(mutex_owned(ST_MUTEX)); 6368 6369 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6370 "st_write_fm(dev = 0x%lx, wfm = %d)\n", dev, wfm); 6371 6372 /* 6373 * write one filemark at the time after EOT 6374 */ 6375 if (un->un_pos.eof >= ST_EOT) { 6376 for (i = 0; i < wfm; i++) { 6377 rval = st_cmd(un, SCMD_WRITE_FILE_MARK, 1, SYNC_CMD); 6378 if (rval == EACCES) { 6379 return (rval); 6380 } 6381 if (rval != 0) { 6382 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6383 "st_write_fm : EIO : write EOT file mark"); 6384 return (EIO); 6385 } 6386 } 6387 } else { 6388 rval = st_cmd(un, SCMD_WRITE_FILE_MARK, wfm, SYNC_CMD); 6389 if (rval == EACCES) { 6390 return (rval); 6391 } 6392 if (rval) { 6393 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6394 "st_write_fm : EIO : write file mark"); 6395 return (EIO); 6396 } 6397 } 6398 6399 ASSERT(mutex_owned(ST_MUTEX)); 6400 return (0); 6401 } 6402 6403 #ifdef STDEBUG 6404 static void 6405 st_start_dump(struct scsi_tape *un, struct buf *bp) 6406 { 6407 struct scsi_pkt *pkt = BP_PKT(bp); 6408 uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp; 6409 6410 ST_FUNC(ST_DEVINFO, st_start_dump); 6411 6412 if ((st_debug & 0x7) < 6) 6413 return; 6414 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6415 "st_start: cmd=0x%p count=%ld resid=%ld flags=0x%x pkt=0x%p\n", 6416 (void *)bp->b_forw, bp->b_bcount, 6417 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 6418 st_print_cdb(ST_DEVINFO, st_label, SCSI_DEBUG, 6419 "st_start: cdb", (caddr_t)cdbp); 6420 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6421 "st_start: fileno=%d, blk=%d\n", 6422 un->un_pos.fileno, un->un_pos.blkno); 6423 } 6424 #endif 6425 6426 6427 /* 6428 * Command start && done functions 6429 */ 6430 6431 /* 6432 * st_start() 6433 * 6434 * Called from: 6435 * st_strategy() to start a command. 6436 * st_runout() to retry when scsi_pkt allocation fails on previous attempt(s). 6437 * st_attach() when resuming from power down state. 6438 * st_start_restart() to retry transport when device was previously busy. 6439 * st_done_and_mutex_exit() to start the next command when previous is done. 6440 * 6441 * On entry: 6442 * scsi_pkt may or may not be allocated. 6443 * 6444 */ 6445 static void 6446 st_start(struct scsi_tape *un) 6447 { 6448 struct buf *bp; 6449 int status; 6450 int queued; 6451 6452 ST_FUNC(ST_DEVINFO, st_start); 6453 ASSERT(mutex_owned(ST_MUTEX)); 6454 6455 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6456 "st_start(): dev = 0x%lx\n", un->un_dev); 6457 6458 if (un->un_recov_buf_busy) { 6459 /* recovery commands can happen anytime */ 6460 bp = un->un_recov_buf; 6461 queued = 0; 6462 } else if (un->un_sbuf_busy) { 6463 /* sbuf commands should only happen with an empty queue. */ 6464 ASSERT(un->un_quef == NULL); 6465 ASSERT(un->un_runqf == NULL); 6466 bp = un->un_sbufp; 6467 queued = 0; 6468 } else if (un->un_quef != NULL) { 6469 if (un->un_persistence && un->un_persist_errors) { 6470 return; 6471 } 6472 bp = un->un_quef; 6473 queued = 1; 6474 } else { 6475 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6476 "st_start() returning no buf found\n"); 6477 return; 6478 } 6479 6480 ASSERT((bp->b_flags & B_DONE) == 0); 6481 6482 /* 6483 * Don't send more than un_throttle commands to the HBA 6484 */ 6485 if ((un->un_throttle <= 0) || (un->un_ncmds >= un->un_throttle)) { 6486 /* 6487 * if doing recovery we know there is outstanding commands. 6488 */ 6489 if (bp != un->un_recov_buf) { 6490 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6491 "st_start returning throttle = %d or ncmds = %d\n", 6492 un->un_throttle, un->un_ncmds); 6493 if (un->un_ncmds == 0) { 6494 typedef void (*func)(); 6495 func fnc = (func)st_runout; 6496 6497 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6498 "Sending delayed start to st_runout()\n"); 6499 mutex_exit(ST_MUTEX); 6500 (void) timeout(fnc, un, drv_usectohz(1000000)); 6501 mutex_enter(ST_MUTEX); 6502 } 6503 return; 6504 } 6505 } 6506 6507 /* 6508 * If the buf has no scsi_pkt call st_make_cmd() to get one and 6509 * build the command. 6510 */ 6511 if (BP_PKT(bp) == NULL) { 6512 ASSERT((bp->b_flags & B_DONE) == 0); 6513 st_make_cmd(un, bp, st_runout); 6514 ASSERT((bp->b_flags & B_DONE) == 0); 6515 status = geterror(bp); 6516 6517 /* 6518 * Some HBA's don't call bioerror() to set an error. 6519 * And geterror() returns zero if B_ERROR is not set. 6520 * So if we get zero we must check b_error. 6521 */ 6522 if (status == 0 && bp->b_error != 0) { 6523 status = bp->b_error; 6524 bioerror(bp, status); 6525 } 6526 6527 /* 6528 * Some HBA's convert DDI_DMA_NORESOURCES into ENOMEM. 6529 * In tape ENOMEM has special meaning so we'll change it. 6530 */ 6531 if (status == ENOMEM) { 6532 status = 0; 6533 bioerror(bp, status); 6534 } 6535 6536 /* 6537 * Did it fail and is it retryable? 6538 * If so return and wait for the callback through st_runout. 6539 * Also looks like scsi_init_pkt() will setup a callback even 6540 * if it isn't retryable. 6541 */ 6542 if (BP_PKT(bp) == NULL) { 6543 if (status == 0) { 6544 /* 6545 * If first attempt save state. 6546 */ 6547 if (un->un_state != ST_STATE_RESOURCE_WAIT) { 6548 un->un_laststate = un->un_state; 6549 un->un_state = ST_STATE_RESOURCE_WAIT; 6550 } 6551 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6552 "temp no resources for pkt\n"); 6553 } else if (status == EINVAL) { 6554 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6555 "scsi_init_pkt rejected pkt as too big\n"); 6556 if (un->un_persistence) { 6557 st_set_pe_flag(un); 6558 } 6559 } else { 6560 /* 6561 * Unlikely that it would be retryable then not. 6562 */ 6563 if (un->un_state == ST_STATE_RESOURCE_WAIT) { 6564 un->un_state = un->un_laststate; 6565 } 6566 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6567 "perm no resources for pkt errno = 0x%x\n", 6568 status); 6569 } 6570 return; 6571 } 6572 /* 6573 * Worked this time set the state back. 6574 */ 6575 if (un->un_state == ST_STATE_RESOURCE_WAIT) { 6576 un->un_state = un->un_laststate; 6577 } 6578 } 6579 6580 if (queued) { 6581 /* 6582 * move from waitq to runq 6583 */ 6584 (void) st_remove_from_queue(&un->un_quef, &un->un_quel, bp); 6585 st_add_to_queue(&un->un_runqf, &un->un_runql, un->un_runql, bp); 6586 } 6587 6588 6589 #ifdef STDEBUG 6590 st_start_dump(un, bp); 6591 #endif 6592 6593 /* could not get here if throttle was zero */ 6594 un->un_last_throttle = un->un_throttle; 6595 un->un_throttle = 0; /* so nothing else will come in here */ 6596 un->un_ncmds++; 6597 6598 ST_DO_KSTATS(bp, kstat_waitq_to_runq); 6599 6600 status = st_transport(un, BP_PKT(bp)); 6601 6602 if (un->un_last_throttle) { 6603 un->un_throttle = un->un_last_throttle; 6604 } 6605 6606 if (status != TRAN_ACCEPT) { 6607 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 6608 ST_DEBUG(ST_DEVINFO, st_label, CE_WARN, 6609 "Unhappy transport packet status 0x%x\n", status); 6610 6611 if (status == TRAN_BUSY) { 6612 pkt_info *pkti = BP_PKT(bp)->pkt_private; 6613 6614 /* 6615 * If command recovery is enabled and this isn't 6616 * a recovery command try command recovery. 6617 */ 6618 if (pkti->privatelen == sizeof (recov_info) && 6619 bp != un->un_recov_buf) { 6620 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 6621 "Command Recovery called on busy send\n"); 6622 if (st_command_recovery(un, BP_PKT(bp), 6623 ATTEMPT_RETRY) == JUST_RETURN) { 6624 return; 6625 } 6626 } else { 6627 mutex_exit(ST_MUTEX); 6628 if (st_handle_start_busy(un, bp, 6629 ST_TRAN_BUSY_TIMEOUT, queued) == 0) { 6630 mutex_enter(ST_MUTEX); 6631 return; 6632 } 6633 /* 6634 * if too many retries, fail the transport 6635 */ 6636 mutex_enter(ST_MUTEX); 6637 } 6638 } 6639 scsi_log(ST_DEVINFO, st_label, CE_WARN, 6640 "transport rejected %d\n", status); 6641 bp->b_resid = bp->b_bcount; 6642 6643 ST_DO_KSTATS(bp, kstat_waitq_exit); 6644 ST_DO_ERRSTATS(un, st_transerrs); 6645 if ((bp == un->un_recov_buf) && (status == TRAN_BUSY)) { 6646 st_bioerror(bp, EBUSY); 6647 } else { 6648 st_bioerror(bp, EIO); 6649 st_set_pe_flag(un); 6650 } 6651 st_done_and_mutex_exit(un, bp); 6652 mutex_enter(ST_MUTEX); 6653 } 6654 6655 ASSERT(mutex_owned(ST_MUTEX)); 6656 } 6657 6658 /* 6659 * if the transport is busy, then put this bp back on the waitq 6660 */ 6661 static int 6662 st_handle_start_busy(struct scsi_tape *un, struct buf *bp, 6663 clock_t timeout_interval, int queued) 6664 { 6665 6666 pkt_info *pktinfo = BP_PKT(bp)->pkt_private; 6667 6668 ST_FUNC(ST_DEVINFO, st_handle_start_busy); 6669 6670 mutex_enter(ST_MUTEX); 6671 6672 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6673 "st_handle_start_busy()\n"); 6674 6675 /* 6676 * Check to see if we hit the retry timeout and one last check for 6677 * making sure this is the last on the runq, if it is not, we have 6678 * to fail 6679 */ 6680 if ((pktinfo->str_retry_cnt++ > st_retry_count) || 6681 ((queued) && (un->un_runql != bp))) { 6682 mutex_exit(ST_MUTEX); 6683 return (-1); 6684 } 6685 6686 if (queued) { 6687 /* put the bp back on the waitq */ 6688 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quef, bp); 6689 } 6690 6691 /* 6692 * Decrement un_ncmds so that this 6693 * gets thru' st_start() again. 6694 */ 6695 un->un_ncmds--; 6696 6697 if (queued) { 6698 /* 6699 * since this is an error case, we won't have to do this list 6700 * walking much. We've already made sure this bp was the 6701 * last on the runq 6702 */ 6703 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 6704 6705 /* 6706 * send a marker pkt, if appropriate 6707 */ 6708 st_hba_unflush(un); 6709 6710 } 6711 /* 6712 * all queues are aligned, we are just waiting to 6713 * transport, don't alloc any more buf p's, when 6714 * st_start is reentered. 6715 */ 6716 (void) timeout(st_start_restart, un, timeout_interval); 6717 6718 mutex_exit(ST_MUTEX); 6719 return (0); 6720 } 6721 6722 6723 /* 6724 * st_runout a callback that is called what a resource allocatation failed 6725 */ 6726 static int 6727 st_runout(caddr_t arg) 6728 { 6729 struct scsi_tape *un = (struct scsi_tape *)arg; 6730 struct buf *bp; 6731 int queued; 6732 6733 ASSERT(un != NULL); 6734 6735 ST_FUNC(ST_DEVINFO, st_runout); 6736 6737 mutex_enter(ST_MUTEX); 6738 6739 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_runout()\n"); 6740 6741 if (un->un_recov_buf_busy != 0) { 6742 bp = un->un_recov_buf; 6743 queued = 0; 6744 } else if (un->un_sbuf_busy != 0) { 6745 /* sbuf commands should only happen with an empty queue. */ 6746 ASSERT(un->un_quef == NULL); 6747 ASSERT(un->un_runqf == NULL); 6748 bp = un->un_sbufp; 6749 queued = 0; 6750 } else if (un->un_quef != NULL) { 6751 bp = un->un_quef; 6752 if (un->un_persistence && un->un_persist_errors) { 6753 mutex_exit(ST_MUTEX); 6754 bp->b_resid = bp->b_bcount; 6755 biodone(bp); 6756 return (1); 6757 } 6758 queued = 1; 6759 } else { 6760 ASSERT(1 == 0); 6761 mutex_exit(ST_MUTEX); 6762 return (1); 6763 } 6764 6765 /* 6766 * failed scsi_init_pkt(). If errno is zero its retryable. 6767 */ 6768 if ((bp != NULL) && (geterror(bp) != 0)) { 6769 6770 scsi_log(ST_DEVINFO, st_label, CE_WARN, 6771 "errors after pkt alloc (b_flags=0x%x, b_error=0x%x)\n", 6772 bp->b_flags, geterror(bp)); 6773 ASSERT((bp->b_flags & B_DONE) == 0); 6774 6775 if (queued) { 6776 (void) st_remove_from_queue(&un->un_quef, &un->un_quel, 6777 bp); 6778 } 6779 mutex_exit(ST_MUTEX); 6780 6781 ASSERT((bp->b_flags & B_DONE) == 0); 6782 6783 /* 6784 * Set resid, Error already set, then unblock calling thread. 6785 */ 6786 bp->b_resid = bp->b_bcount; 6787 biodone(bp); 6788 } else { 6789 /* 6790 * Try Again 6791 */ 6792 st_start(un); 6793 mutex_exit(ST_MUTEX); 6794 } 6795 6796 /* 6797 * Comments courtesy of sd.c 6798 * The scsi_init_pkt routine allows for the callback function to 6799 * return a 0 indicating the callback should be rescheduled or a 1 6800 * indicating not to reschedule. This routine always returns 1 6801 * because the driver always provides a callback function to 6802 * scsi_init_pkt. This results in a callback always being scheduled 6803 * (via the scsi_init_pkt callback implementation) if a resource 6804 * failure occurs. 6805 */ 6806 6807 return (1); 6808 } 6809 6810 /* 6811 * st_done_and_mutex_exit() 6812 * - remove bp from runq 6813 * - start up the next request 6814 * - if this was an asynch bp, clean up 6815 * - exit with released mutex 6816 */ 6817 static void 6818 st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp) 6819 { 6820 int pe_flagged = 0; 6821 struct scsi_pkt *pkt = BP_PKT(bp); 6822 pkt_info *pktinfo = pkt->pkt_private; 6823 6824 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 6825 #if !defined(lint) 6826 _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex)) 6827 #endif 6828 6829 ST_FUNC(ST_DEVINFO, st_done_and_mutex_exit); 6830 6831 ASSERT(mutex_owned(ST_MUTEX)); 6832 6833 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 6834 6835 un->un_ncmds--; 6836 cv_signal(&un->un_queue_cv); 6837 6838 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6839 "st_done_and_mutex_exit(): cmd=0x%x count=%ld resid=%ld flags=" 6840 "0x%x\n", pkt->pkt_cdbp[0], bp->b_bcount, 6841 bp->b_resid, bp->b_flags); 6842 6843 6844 /* 6845 * update kstats with transfer count info 6846 */ 6847 if (un->un_stats && (bp != un->un_sbufp) && IS_RW(bp)) { 6848 uint32_t n_done = bp->b_bcount - bp->b_resid; 6849 if (bp->b_flags & B_READ) { 6850 IOSP->reads++; 6851 IOSP->nread += n_done; 6852 } else { 6853 IOSP->writes++; 6854 IOSP->nwritten += n_done; 6855 } 6856 } 6857 6858 /* 6859 * Start the next one before releasing resources on this one, if 6860 * there is something on the queue and persistent errors has not been 6861 * flagged 6862 */ 6863 6864 if ((pe_flagged = (un->un_persistence && un->un_persist_errors)) != 0) { 6865 un->un_last_resid = bp->b_resid; 6866 un->un_last_count = bp->b_bcount; 6867 } 6868 6869 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 6870 cv_broadcast(&un->un_tape_busy_cv); 6871 } else if (un->un_quef && un->un_throttle && !pe_flagged && 6872 (bp != un->un_recov_buf)) { 6873 st_start(un); 6874 } 6875 6876 un->un_retry_ct = max(pktinfo->pkt_retry_cnt, pktinfo->str_retry_cnt); 6877 6878 if (bp == un->un_sbufp && (bp->b_flags & B_ASYNC)) { 6879 /* 6880 * Since we marked this ourselves as ASYNC, 6881 * there isn't anybody around waiting for 6882 * completion any more. 6883 */ 6884 uchar_t *cmd = pkt->pkt_cdbp; 6885 if (*cmd == SCMD_READ || *cmd == SCMD_WRITE) { 6886 bp->b_un.b_addr = (caddr_t)0; 6887 } 6888 ST_DEBUG(ST_DEVINFO, st_label, CE_NOTE, 6889 "st_done_and_mutex_exit(async): freeing pkt\n"); 6890 st_print_cdb(ST_DEVINFO, st_label, CE_NOTE, 6891 "CDB sent with B_ASYNC", (caddr_t)cmd); 6892 if (pkt) { 6893 scsi_destroy_pkt(pkt); 6894 } 6895 un->un_sbuf_busy = 0; 6896 cv_signal(&un->un_sbuf_cv); 6897 mutex_exit(ST_MUTEX); 6898 return; 6899 } 6900 6901 if (bp == un->un_sbufp && BP_UCMD(bp)) { 6902 /* 6903 * Copy status from scsi_pkt to uscsi_cmd 6904 * since st_uscsi_cmd needs it 6905 */ 6906 BP_UCMD(bp)->uscsi_status = SCBP_C(BP_PKT(bp)); 6907 } 6908 6909 6910 #ifdef STDEBUG 6911 if (((st_debug & 0x7) >= 4) && 6912 (((un->un_pos.blkno % 100) == 0) || 6913 (un->un_persistence && un->un_persist_errors))) { 6914 6915 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6916 "st_d_a_m_exit(): ncmds = %d, thr = %d, " 6917 "un_errno = %d, un_pe = %d\n", 6918 un->un_ncmds, un->un_throttle, un->un_errno, 6919 un->un_persist_errors); 6920 } 6921 6922 #endif 6923 6924 mutex_exit(ST_MUTEX); 6925 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6926 "st_done_and_mutex_exit: freeing pkt\n"); 6927 6928 if (pkt) { 6929 scsi_destroy_pkt(pkt); 6930 } 6931 6932 biodone(bp); 6933 6934 /* 6935 * now that we biodoned that command, if persistent errors have been 6936 * flagged, flush the waitq 6937 */ 6938 if (pe_flagged) 6939 st_flush(un); 6940 } 6941 6942 6943 /* 6944 * Tape error, flush tape driver queue. 6945 */ 6946 static void 6947 st_flush(struct scsi_tape *un) 6948 { 6949 struct buf *bp; 6950 6951 ST_FUNC(ST_DEVINFO, st_flush); 6952 6953 mutex_enter(ST_MUTEX); 6954 6955 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6956 "st_flush(), ncmds = %d, quef = 0x%p\n", 6957 un->un_ncmds, (void *)un->un_quef); 6958 6959 /* 6960 * if we still have commands outstanding, wait for them to come in 6961 * before flushing the queue, and make sure there is a queue 6962 */ 6963 if (un->un_ncmds || !un->un_quef) 6964 goto exit; 6965 6966 /* 6967 * we have no more commands outstanding, so let's deal with special 6968 * cases in the queue for EOM and FM. If we are here, and un_errno 6969 * is 0, then we know there was no error and we return a 0 read or 6970 * write before showing errors 6971 */ 6972 6973 /* Flush the wait queue. */ 6974 while ((bp = un->un_quef) != NULL) { 6975 un->un_quef = bp->b_actf; 6976 6977 bp->b_resid = bp->b_bcount; 6978 6979 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6980 "st_flush() : blkno=%d, err=%d, b_bcount=%ld\n", 6981 un->un_pos.blkno, un->un_errno, bp->b_bcount); 6982 6983 st_set_pe_errno(un); 6984 6985 bioerror(bp, un->un_errno); 6986 6987 mutex_exit(ST_MUTEX); 6988 /* it should have one, but check anyway */ 6989 if (BP_PKT(bp)) { 6990 scsi_destroy_pkt(BP_PKT(bp)); 6991 } 6992 biodone(bp); 6993 mutex_enter(ST_MUTEX); 6994 } 6995 6996 /* 6997 * It's not a bad practice to reset the 6998 * waitq tail pointer to NULL. 6999 */ 7000 un->un_quel = NULL; 7001 7002 exit: 7003 /* we mucked with the queue, so let others know about it */ 7004 cv_signal(&un->un_queue_cv); 7005 mutex_exit(ST_MUTEX); 7006 } 7007 7008 7009 /* 7010 * Utility functions 7011 */ 7012 static int 7013 st_determine_generic(struct scsi_tape *un) 7014 { 7015 int bsize; 7016 static char *cart = "0.25 inch cartridge"; 7017 char *sizestr; 7018 7019 ST_FUNC(ST_DEVINFO, st_determine_generic); 7020 7021 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7022 "st_determine_generic(un = 0x%p)\n", (void*)un); 7023 7024 ASSERT(mutex_owned(ST_MUTEX)); 7025 7026 if (st_modesense(un)) { 7027 return (-1); 7028 } 7029 7030 bsize = (un->un_mspl->high_bl << 16) | 7031 (un->un_mspl->mid_bl << 8) | 7032 (un->un_mspl->low_bl); 7033 7034 if (bsize == 0) { 7035 un->un_dp->options |= ST_VARIABLE; 7036 un->un_dp->bsize = 0; 7037 un->un_bsize = 0; 7038 } else if (bsize > ST_MAXRECSIZE_FIXED) { 7039 /* 7040 * record size of this device too big. 7041 * try and convert it to variable record length. 7042 * 7043 */ 7044 un->un_dp->options |= ST_VARIABLE; 7045 if (st_change_block_size(un, 0) != 0) { 7046 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 7047 "Fixed Record Size %d is too large\n", bsize); 7048 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 7049 "Cannot switch to variable record size\n"); 7050 un->un_dp->options &= ~ST_VARIABLE; 7051 return (-1); 7052 } 7053 } else if (st_change_block_size(un, 0) == 0) { 7054 /* 7055 * If the drive was set to a non zero block size, 7056 * See if it can be set to a zero block size. 7057 * If it works, ST_VARIABLE so user can set it as they want. 7058 */ 7059 un->un_dp->options |= ST_VARIABLE; 7060 un->un_dp->bsize = 0; 7061 un->un_bsize = 0; 7062 } else { 7063 un->un_dp->bsize = bsize; 7064 un->un_bsize = bsize; 7065 } 7066 7067 7068 switch (un->un_mspl->density) { 7069 default: 7070 case 0x0: 7071 /* 7072 * default density, cannot determine any other 7073 * information. 7074 */ 7075 sizestr = "Unknown type- assuming 0.25 inch cartridge"; 7076 un->un_dp->type = ST_TYPE_DEFAULT; 7077 un->un_dp->options |= (ST_AUTODEN_OVERRIDE|ST_QIC); 7078 break; 7079 case 0x1: 7080 case 0x2: 7081 case 0x3: 7082 case 0x6: 7083 /* 7084 * 1/2" reel 7085 */ 7086 sizestr = "0.50 inch reel"; 7087 un->un_dp->type = ST_TYPE_REEL; 7088 un->un_dp->options |= ST_REEL; 7089 un->un_dp->densities[0] = 0x1; 7090 un->un_dp->densities[1] = 0x2; 7091 un->un_dp->densities[2] = 0x6; 7092 un->un_dp->densities[3] = 0x3; 7093 break; 7094 case 0x4: 7095 case 0x5: 7096 case 0x7: 7097 case 0x0b: 7098 7099 /* 7100 * Quarter inch. 7101 */ 7102 sizestr = cart; 7103 un->un_dp->type = ST_TYPE_DEFAULT; 7104 un->un_dp->options |= ST_QIC; 7105 7106 un->un_dp->densities[1] = 0x4; 7107 un->un_dp->densities[2] = 0x5; 7108 un->un_dp->densities[3] = 0x7; 7109 un->un_dp->densities[0] = 0x0b; 7110 break; 7111 7112 case 0x0f: 7113 case 0x10: 7114 case 0x11: 7115 case 0x12: 7116 /* 7117 * QIC-120, QIC-150, QIC-320, QIC-600 7118 */ 7119 sizestr = cart; 7120 un->un_dp->type = ST_TYPE_DEFAULT; 7121 un->un_dp->options |= ST_QIC; 7122 un->un_dp->densities[0] = 0x0f; 7123 un->un_dp->densities[1] = 0x10; 7124 un->un_dp->densities[2] = 0x11; 7125 un->un_dp->densities[3] = 0x12; 7126 break; 7127 7128 case 0x09: 7129 case 0x0a: 7130 case 0x0c: 7131 case 0x0d: 7132 /* 7133 * 1/2" cartridge tapes. Include HI-TC. 7134 */ 7135 sizestr = cart; 7136 sizestr[2] = '5'; 7137 sizestr[3] = '0'; 7138 un->un_dp->type = ST_TYPE_HIC; 7139 un->un_dp->densities[0] = 0x09; 7140 un->un_dp->densities[1] = 0x0a; 7141 un->un_dp->densities[2] = 0x0c; 7142 un->un_dp->densities[3] = 0x0d; 7143 break; 7144 7145 case 0x13: 7146 /* DDS-2/DDS-3 scsi spec densities */ 7147 case 0x24: 7148 case 0x25: 7149 case 0x26: 7150 sizestr = "DAT Data Storage (DDS)"; 7151 un->un_dp->type = ST_TYPE_DAT; 7152 un->un_dp->options |= ST_AUTODEN_OVERRIDE; 7153 break; 7154 7155 case 0x14: 7156 /* 7157 * Helical Scan (Exabyte) devices 7158 */ 7159 sizestr = "8mm helical scan cartridge"; 7160 un->un_dp->type = ST_TYPE_EXABYTE; 7161 un->un_dp->options |= ST_AUTODEN_OVERRIDE; 7162 break; 7163 } 7164 7165 /* 7166 * Assume LONG ERASE, BSF and BSR 7167 */ 7168 7169 un->un_dp->options |= 7170 (ST_LONG_ERASE | ST_UNLOADABLE | ST_BSF | ST_BSR | ST_KNOWS_EOD); 7171 7172 /* 7173 * Only if mode sense data says no buffered write, set NOBUF 7174 */ 7175 if (un->un_mspl->bufm == 0) 7176 un->un_dp->options |= ST_NOBUF; 7177 7178 /* 7179 * set up large read and write retry counts 7180 */ 7181 7182 un->un_dp->max_rretries = un->un_dp->max_wretries = 1000; 7183 7184 /* 7185 * If this is a 0.50 inch reel tape, and 7186 * it is *not* variable mode, try and 7187 * set it to variable record length 7188 * mode. 7189 */ 7190 if ((un->un_dp->options & ST_REEL) && un->un_bsize != 0 && 7191 (un->un_dp->options & ST_VARIABLE)) { 7192 if (st_change_block_size(un, 0) == 0) { 7193 un->un_dp->bsize = 0; 7194 un->un_mspl->high_bl = un->un_mspl->mid_bl = 7195 un->un_mspl->low_bl = 0; 7196 } 7197 } 7198 7199 /* 7200 * Write to console about type of device found 7201 */ 7202 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 7203 "Generic Drive, Vendor=%s\n\t%s", un->un_dp->name, 7204 sizestr); 7205 if (un->un_dp->options & ST_VARIABLE) { 7206 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7207 "!Variable record length I/O\n"); 7208 } else { 7209 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7210 "!Fixed record length (%d byte blocks) I/O\n", 7211 un->un_dp->bsize); 7212 } 7213 ASSERT(mutex_owned(ST_MUTEX)); 7214 return (0); 7215 } 7216 7217 static int 7218 st_determine_density(struct scsi_tape *un, int rw) 7219 { 7220 int rval = 0; 7221 7222 ST_FUNC(ST_DEVINFO, st_determine_density); 7223 7224 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7225 "st_determine_density(un = 0x%p, rw = %s)\n", 7226 (void*)un, (rw == B_WRITE ? wr_str: rd_str)); 7227 7228 ASSERT(mutex_owned(ST_MUTEX)); 7229 7230 /* 7231 * If we're past BOT, density is determined already. 7232 */ 7233 if (un->un_pos.pmode == logical) { 7234 if (un->un_pos.lgclblkno != 0) { 7235 goto exit; 7236 } 7237 } else if (un->un_pos.pmode == legacy) { 7238 if ((un->un_pos.fileno != 0) || (un->un_pos.blkno != 0)) { 7239 /* 7240 * XXX: put in a bitch message about attempting to 7241 * XXX: change density past BOT. 7242 */ 7243 goto exit; 7244 } 7245 } else { 7246 goto exit; 7247 } 7248 if ((un->un_pos.pmode == logical) && 7249 (un->un_pos.lgclblkno != 0)) { 7250 goto exit; 7251 } 7252 7253 7254 /* 7255 * If we're going to be writing, we set the density 7256 */ 7257 if (rw == 0 || rw == B_WRITE) { 7258 /* un_curdens is used as an index into densities table */ 7259 un->un_curdens = MT_DENSITY(un->un_dev); 7260 if (st_set_density(un)) { 7261 rval = -1; 7262 } 7263 goto exit; 7264 } 7265 7266 /* 7267 * If density is known already, 7268 * we don't have to get it again.(?) 7269 */ 7270 if (!un->un_density_known) { 7271 if (st_get_density(un)) { 7272 rval = -1; 7273 } 7274 } 7275 7276 exit: 7277 ASSERT(mutex_owned(ST_MUTEX)); 7278 return (rval); 7279 } 7280 7281 7282 /* 7283 * Try to determine density. We do this by attempting to read the 7284 * first record off the tape, cycling through the available density 7285 * codes as we go. 7286 */ 7287 7288 static int 7289 st_get_density(struct scsi_tape *un) 7290 { 7291 int succes = 0, rval = -1, i; 7292 uint_t size; 7293 uchar_t dens, olddens; 7294 7295 ST_FUNC(ST_DEVINFO, st_get_density); 7296 7297 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7298 "st_get_density(un = 0x%p)\n", (void*)un); 7299 7300 ASSERT(mutex_owned(ST_MUTEX)); 7301 7302 /* 7303 * If Auto Density override is enabled The drive has 7304 * only one density and there is no point in attempting 7305 * find the correct one. 7306 * 7307 * Since most modern drives auto detect the density 7308 * and format of the recorded media before they come 7309 * ready. What this function does is a legacy behavior 7310 * and modern drives not only don't need it, The backup 7311 * utilities that do positioning via uscsi find the un- 7312 * expected rewinds problematic. 7313 * 7314 * The drives that need this are old reel to reel devices. 7315 * I took a swag and said they must be scsi-1 or older. 7316 * I don't beleave there will any of the newer devices 7317 * that need this. There will be some scsi-1 devices that 7318 * don't need this but I don't think they will be using the 7319 * BIG aftermarket backup and restore utilitys. 7320 */ 7321 if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) || 7322 (un->un_sd->sd_inq->inq_ansi > 1)) { 7323 un->un_density_known = 1; 7324 rval = 0; 7325 goto exit; 7326 } 7327 7328 /* 7329 * This will only work on variable record length tapes 7330 * if and only if all variable record length tapes autodensity 7331 * select. 7332 */ 7333 size = (unsigned)(un->un_dp->bsize ? un->un_dp->bsize : SECSIZE); 7334 un->un_tmpbuf = kmem_alloc(size, KM_SLEEP); 7335 7336 /* 7337 * Start at the specified density 7338 */ 7339 7340 dens = olddens = un->un_curdens = MT_DENSITY(un->un_dev); 7341 7342 for (i = 0; i < NDENSITIES; i++, ((un->un_curdens == NDENSITIES - 1) ? 7343 (un->un_curdens = 0) : (un->un_curdens += 1))) { 7344 /* 7345 * If we've done this density before, 7346 * don't bother to do it again. 7347 */ 7348 dens = un->un_dp->densities[un->un_curdens]; 7349 if (i > 0 && dens == olddens) 7350 continue; 7351 olddens = dens; 7352 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7353 "trying density 0x%x\n", dens); 7354 if (st_set_density(un)) { 7355 continue; 7356 } 7357 7358 /* 7359 * XXX - the creates lots of headaches and slowdowns - must 7360 * fix. 7361 */ 7362 succes = (st_cmd(un, SCMD_READ, (int)size, SYNC_CMD) == 0); 7363 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 7364 break; 7365 } 7366 if (succes) { 7367 st_init(un); 7368 rval = 0; 7369 un->un_density_known = 1; 7370 break; 7371 } 7372 } 7373 kmem_free(un->un_tmpbuf, size); 7374 un->un_tmpbuf = 0; 7375 7376 exit: 7377 ASSERT(mutex_owned(ST_MUTEX)); 7378 return (rval); 7379 } 7380 7381 static int 7382 st_set_density(struct scsi_tape *un) 7383 { 7384 int rval = 0; 7385 7386 ST_FUNC(ST_DEVINFO, st_set_density); 7387 7388 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7389 "st_set_density(un = 0x%p): density = 0x%x\n", (void*)un, 7390 un->un_dp->densities[un->un_curdens]); 7391 7392 ASSERT(mutex_owned(ST_MUTEX)); 7393 7394 un->un_mspl->density = un->un_dp->densities[un->un_curdens]; 7395 7396 if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) == 0) { 7397 /* 7398 * If auto density override is not set, Use mode select 7399 * to set density and compression. 7400 */ 7401 if (st_modeselect(un)) { 7402 rval = -1; 7403 } 7404 } else if ((un->un_dp->options & ST_MODE_SEL_COMP) != 0) { 7405 /* 7406 * If auto density and mode select compression are set, 7407 * This is a drive with one density code but compression 7408 * can be enabled or disabled. 7409 * Set compression but no need to set density. 7410 */ 7411 rval = st_set_compression(un); 7412 if ((rval != 0) && (rval != EALREADY)) { 7413 rval = -1; 7414 } else { 7415 rval = 0; 7416 } 7417 } 7418 7419 /* If sucessful set density and/or compression, mark density known */ 7420 if (rval == 0) { 7421 un->un_density_known = 1; 7422 } 7423 7424 ASSERT(mutex_owned(ST_MUTEX)); 7425 return (rval); 7426 } 7427 7428 static int 7429 st_loadtape(struct scsi_tape *un) 7430 { 7431 int rval; 7432 7433 ST_FUNC(ST_DEVINFO, st_loadtape); 7434 7435 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7436 "st_loadtape(un = 0x%p)\n", (void*) un); 7437 7438 ASSERT(mutex_owned(ST_MUTEX)); 7439 7440 rval = st_update_block_pos(un, st_cmd, 0); 7441 if (rval == EACCES) { 7442 return (rval); 7443 } 7444 7445 /* 7446 * 'LOAD' the tape to BOT by rewinding 7447 */ 7448 rval = st_cmd(un, SCMD_REWIND, 1, SYNC_CMD); 7449 if (rval == 0) { 7450 st_init(un); 7451 un->un_density_known = 0; 7452 } 7453 7454 ASSERT(mutex_owned(ST_MUTEX)); 7455 return (rval); 7456 } 7457 7458 7459 /* 7460 * Note: QIC devices aren't so smart. If you try to append 7461 * after EOM, the write can fail because the device doesn't know 7462 * it's at EOM. In that case, issue a read. The read should fail 7463 * because there's no data, but the device knows it's at EOM, 7464 * so a subsequent write should succeed. To further confuse matters, 7465 * the target returns the same error if the tape is positioned 7466 * such that a write would overwrite existing data. That's why 7467 * we have to do the append test. A read in the middle of 7468 * recorded data would succeed, thus indicating we're attempting 7469 * something illegal. 7470 */ 7471 7472 7473 static void 7474 st_test_append(struct buf *bp) 7475 { 7476 dev_t dev = bp->b_edev; 7477 struct scsi_tape *un; 7478 uchar_t status; 7479 unsigned bcount; 7480 7481 un = ddi_get_soft_state(st_state, MTUNIT(dev)); 7482 7483 ST_FUNC(ST_DEVINFO, st_test_append); 7484 7485 ASSERT(mutex_owned(ST_MUTEX)); 7486 7487 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7488 "st_test_append(): fileno %d\n", un->un_pos.fileno); 7489 7490 un->un_laststate = un->un_state; 7491 un->un_state = ST_STATE_APPEND_TESTING; 7492 un->un_test_append = 0; 7493 7494 /* 7495 * first, map in the buffer, because we're doing a double write -- 7496 * first into the kernel, then onto the tape. 7497 */ 7498 bp_mapin(bp); 7499 7500 /* 7501 * get a copy of the data.... 7502 */ 7503 un->un_tmpbuf = kmem_alloc((unsigned)bp->b_bcount, KM_SLEEP); 7504 bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount); 7505 7506 /* 7507 * attempt the write.. 7508 */ 7509 7510 if (st_cmd(un, (int)SCMD_WRITE, (int)bp->b_bcount, SYNC_CMD) == 0) { 7511 success: 7512 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7513 "append write succeeded\n"); 7514 bp->b_resid = un->un_sbufp->b_resid; 7515 mutex_exit(ST_MUTEX); 7516 bcount = (unsigned)bp->b_bcount; 7517 biodone(bp); 7518 mutex_enter(ST_MUTEX); 7519 un->un_laststate = un->un_state; 7520 un->un_state = ST_STATE_OPEN; 7521 kmem_free(un->un_tmpbuf, bcount); 7522 un->un_tmpbuf = NULL; 7523 return; 7524 } 7525 7526 /* 7527 * The append failed. Do a short read. If that fails, we are at EOM 7528 * so we can retry the write command. If that succeeds, than we're 7529 * all screwed up (the controller reported a real error). 7530 * 7531 * XXX: should the dummy read be > SECSIZE? should it be the device's 7532 * XXX: block size? 7533 * 7534 */ 7535 status = un->un_status; 7536 un->un_status = 0; 7537 (void) st_cmd(un, SCMD_READ, SECSIZE, SYNC_CMD); 7538 if (un->un_status == KEY_BLANK_CHECK) { 7539 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7540 "append at EOM\n"); 7541 /* 7542 * Okay- the read failed. We should actually have confused 7543 * the controller enough to allow writing. In any case, the 7544 * i/o is on its own from here on out. 7545 */ 7546 un->un_laststate = un->un_state; 7547 un->un_state = ST_STATE_OPEN; 7548 bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount); 7549 if (st_cmd(un, (int)SCMD_WRITE, (int)bp->b_bcount, 7550 SYNC_CMD) == 0) { 7551 goto success; 7552 } 7553 } 7554 7555 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7556 "append write failed- not at EOM\n"); 7557 bp->b_resid = bp->b_bcount; 7558 st_bioerror(bp, EIO); 7559 7560 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 7561 "st_test_append : EIO : append write failed - not at EOM"); 7562 7563 /* 7564 * backspace one record to get back to where we were 7565 */ 7566 if (st_cmd(un, SCMD_SPACE, Blk(-1), SYNC_CMD)) { 7567 un->un_pos.pmode = invalid; 7568 } 7569 7570 un->un_err_resid = bp->b_resid; 7571 un->un_status = status; 7572 7573 /* 7574 * Note: biodone will do a bp_mapout() 7575 */ 7576 mutex_exit(ST_MUTEX); 7577 bcount = (unsigned)bp->b_bcount; 7578 biodone(bp); 7579 mutex_enter(ST_MUTEX); 7580 un->un_laststate = un->un_state; 7581 un->un_state = ST_STATE_OPEN_PENDING_IO; 7582 kmem_free(un->un_tmpbuf, bcount); 7583 un->un_tmpbuf = NULL; 7584 } 7585 7586 /* 7587 * Special command handler 7588 */ 7589 7590 /* 7591 * common st_cmd code. The fourth parameter states 7592 * whether the caller wishes to await the results 7593 * Note the release of the mutex during most of the function 7594 */ 7595 static int 7596 st_cmd(struct scsi_tape *un, int com, int64_t count, int wait) 7597 { 7598 struct buf *bp; 7599 int err; 7600 uint_t last_err_resid; 7601 7602 ST_FUNC(ST_DEVINFO, st_cmd); 7603 7604 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7605 "st_cmd(dev = 0x%lx, com = 0x%x, count = %"PRIx64", wait = %d)\n", 7606 un->un_dev, com, count, wait); 7607 7608 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 7609 ASSERT(mutex_owned(ST_MUTEX)); 7610 7611 #ifdef STDEBUG 7612 if ((st_debug & 0x7)) { 7613 st_debug_cmds(un, com, count, wait); 7614 } 7615 #endif 7616 7617 st_wait_for_io(un); 7618 7619 /* check to see if this command requires the drive to be reserved */ 7620 err = st_check_cmd_for_need_to_reserve(un, com, count); 7621 7622 if (err) { 7623 return (err); 7624 } 7625 7626 /* 7627 * A space command is not recoverable if we don't know were we 7628 * were when it was issued. 7629 */ 7630 if ((com == SCMD_SPACE) || (com == SCMD_SPACE_G4)) { 7631 (void) st_update_block_pos(un, st_cmd, 0); 7632 } 7633 7634 /* 7635 * Forground should not be doing anything while recovery is active. 7636 */ 7637 ASSERT(un->un_recov_buf_busy == 0); 7638 7639 while (un->un_sbuf_busy) 7640 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 7641 un->un_sbuf_busy = 1; 7642 7643 bp = un->un_sbufp; 7644 bzero(bp, sizeof (buf_t)); 7645 7646 bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC; 7647 7648 err = st_setup_cmd(un, bp, com, count); 7649 7650 un->un_sbuf_busy = 0; 7651 7652 /* 7653 * If was a space command need to update logical block position. 7654 * Only do this if the command was sucessful or it will mask the fact 7655 * that the space command failed by promoting the pmode to logical. 7656 */ 7657 if (((com == SCMD_SPACE) || (com == SCMD_SPACE_G4)) && 7658 (un->un_pos.pmode != invalid)) { 7659 un->un_running.pmode = invalid; 7660 last_err_resid = un->un_err_resid; 7661 (void) st_update_block_pos(un, st_cmd, 1); 7662 /* 7663 * Set running position to invalid so it updates on the 7664 * next command. 7665 */ 7666 un->un_running.pmode = invalid; 7667 un->un_err_resid = last_err_resid; 7668 } 7669 7670 cv_signal(&un->un_sbuf_cv); 7671 7672 return (err); 7673 } 7674 7675 static int 7676 st_setup_cmd(struct scsi_tape *un, buf_t *bp, int com, int64_t count) 7677 { 7678 int err; 7679 dev_t dev = un->un_dev; 7680 7681 ST_FUNC(ST_DEVINFO, st_setup_cmd); 7682 /* 7683 * Set count to the actual size of the data tranfer. 7684 * For commands with no data transfer, set bp->b_bcount 7685 * to the value to be used when constructing the 7686 * cdb in st_make_cmd(). 7687 */ 7688 switch (com) { 7689 case SCMD_READ: 7690 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7691 "special read %"PRId64"\n", count); 7692 bp->b_flags |= B_READ; 7693 bp->b_un.b_addr = un->un_tmpbuf; 7694 break; 7695 7696 case SCMD_WRITE: 7697 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7698 "special write %"PRId64"\n", count); 7699 bp->b_un.b_addr = un->un_tmpbuf; 7700 break; 7701 7702 case SCMD_WRITE_FILE_MARK: 7703 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7704 "write %"PRId64" file marks\n", count); 7705 bp->b_bcount = count; 7706 count = 0; 7707 break; 7708 7709 case SCMD_REWIND: 7710 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "rewind\n"); 7711 bp->b_bcount = count; 7712 count = 0; 7713 break; 7714 7715 case SCMD_SPACE: 7716 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "space\n"); 7717 /* 7718 * If the user could have entered a number that will 7719 * not fit in the 12 bit count field of space(8), 7720 * use space(16). 7721 */ 7722 if (((int64_t)SPACE_CNT(count) > 0x7fffff) || 7723 ((int64_t)SPACE_CNT(count) < -(0x7fffff))) { 7724 com = SCMD_SPACE_G4; 7725 } 7726 bp->b_bcount = count; 7727 count = 0; 7728 break; 7729 7730 case SCMD_RESERVE: 7731 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "reserve"); 7732 bp->b_bcount = 0; 7733 count = 0; 7734 break; 7735 7736 case SCMD_RELEASE: 7737 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "release"); 7738 bp->b_bcount = 0; 7739 count = 0; 7740 break; 7741 7742 case SCMD_LOAD: 7743 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7744 "%s tape\n", (count & LD_LOAD) ? "load" : "unload"); 7745 bp->b_bcount = count; 7746 count = 0; 7747 break; 7748 7749 case SCMD_ERASE: 7750 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7751 "erase tape\n"); 7752 bp->b_bcount = count; 7753 count = 0; 7754 break; 7755 7756 case SCMD_MODE_SENSE: 7757 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7758 "mode sense\n"); 7759 bp->b_flags |= B_READ; 7760 bp->b_un.b_addr = (caddr_t)(un->un_mspl); 7761 break; 7762 7763 case SCMD_MODE_SELECT: 7764 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7765 "mode select\n"); 7766 bp->b_un.b_addr = (caddr_t)(un->un_mspl); 7767 break; 7768 7769 case SCMD_READ_BLKLIM: 7770 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7771 "read block limits\n"); 7772 bp->b_bcount = count; 7773 bp->b_flags |= B_READ; 7774 bp->b_un.b_addr = (caddr_t)(un->un_rbl); 7775 break; 7776 7777 case SCMD_TEST_UNIT_READY: 7778 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7779 "test unit ready\n"); 7780 bp->b_bcount = 0; 7781 count = 0; 7782 break; 7783 7784 case SCMD_DOORLOCK: 7785 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7786 "%s tape\n", (count & MR_LOCK) ? "lock" : "unlock"); 7787 bp->b_bcount = count = 0; 7788 break; 7789 7790 case SCMD_READ_POSITION: 7791 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7792 "read position\n"); 7793 switch (un->un_read_pos_type) { 7794 case LONG_POS: 7795 count = sizeof (tape_position_long_t); 7796 break; 7797 case EXT_POS: 7798 count = min(count, sizeof (tape_position_ext_t)); 7799 break; 7800 case SHORT_POS: 7801 count = sizeof (tape_position_t); 7802 break; 7803 default: 7804 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 7805 "Unknown read position type 0x%x in " 7806 "st_make_cmd()\n", un->un_read_pos_type); 7807 } 7808 bp->b_bcount = count; 7809 bp->b_flags |= B_READ; 7810 bp->b_un.b_addr = (caddr_t)un->un_read_pos_data; 7811 break; 7812 7813 default: 7814 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 7815 "Unhandled scsi command 0x%x in st_setup_cmd()\n", com); 7816 } 7817 7818 mutex_exit(ST_MUTEX); 7819 7820 if (count > 0) { 7821 int flg = (bp->b_flags & B_READ) ? B_READ : B_WRITE; 7822 /* 7823 * We're going to do actual I/O. 7824 * Set things up for physio. 7825 */ 7826 struct iovec aiov; 7827 struct uio auio; 7828 struct uio *uio = &auio; 7829 7830 bzero(&auio, sizeof (struct uio)); 7831 bzero(&aiov, sizeof (struct iovec)); 7832 aiov.iov_base = bp->b_un.b_addr; 7833 aiov.iov_len = count; 7834 7835 uio->uio_iov = &aiov; 7836 uio->uio_iovcnt = 1; 7837 uio->uio_resid = aiov.iov_len; 7838 uio->uio_segflg = UIO_SYSSPACE; 7839 7840 /* 7841 * Let physio do the rest... 7842 */ 7843 bp->b_forw = (struct buf *)(uintptr_t)com; 7844 bp->b_back = NULL; 7845 err = physio(st_strategy, bp, dev, flg, st_minphys, uio); 7846 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7847 "st_setup_cmd: physio returns %d\n", err); 7848 } else { 7849 /* 7850 * Mimic physio 7851 */ 7852 bp->b_forw = (struct buf *)(uintptr_t)com; 7853 bp->b_back = NULL; 7854 bp->b_edev = dev; 7855 bp->b_dev = cmpdev(dev); 7856 bp->b_blkno = 0; 7857 bp->b_resid = 0; 7858 (void) st_strategy(bp); 7859 if (bp->b_flags & B_ASYNC) { 7860 /* 7861 * This is an async command- the caller won't wait 7862 * and doesn't care about errors. 7863 */ 7864 mutex_enter(ST_MUTEX); 7865 return (0); 7866 } 7867 7868 /* 7869 * BugTraq #4260046 7870 * ---------------- 7871 * Restore Solaris 2.5.1 behavior, namely call biowait 7872 * unconditionally. The old comment said... 7873 * 7874 * "if strategy was flagged with persistent errors, we would 7875 * have an error here, and the bp would never be sent, so we 7876 * don't want to wait on a bp that was never sent...or hang" 7877 * 7878 * The new rationale, courtesy of Chitrank... 7879 * 7880 * "we should unconditionally biowait() here because 7881 * st_strategy() will do a biodone() in the persistent error 7882 * case and the following biowait() will return immediately. 7883 * If not, in the case of "errors after pkt alloc" in 7884 * st_start(), we will not biowait here which will cause the 7885 * next biowait() to return immediately which will cause 7886 * us to send out the next command. In the case where both of 7887 * these use the sbuf, when the first command completes we'll 7888 * free the packet attached to sbuf and the same pkt will 7889 * get freed again when we complete the second command. 7890 * see esc 518987. BTW, it is necessary to do biodone() in 7891 * st_start() for the pkt alloc failure case because physio() 7892 * does biowait() and will hang if we don't do biodone()" 7893 */ 7894 7895 err = biowait(bp); 7896 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7897 "st_setup_cmd: biowait returns %d\n", err); 7898 } 7899 7900 mutex_enter(ST_MUTEX); 7901 7902 return (err); 7903 } 7904 7905 static int 7906 st_set_compression(struct scsi_tape *un) 7907 { 7908 int rval; 7909 int turn_compression_on; 7910 minor_t minor; 7911 7912 ST_FUNC(ST_DEVINFO, st_set_compression); 7913 7914 /* 7915 * Drive either dosn't have compression or it is controlled with 7916 * special density codes. Return ENOTTY so caller 7917 * knows nothing was done. 7918 */ 7919 if ((un->un_dp->options & ST_MODE_SEL_COMP) == 0) { 7920 un->un_comp_page = 0; 7921 return (ENOTTY); 7922 } 7923 7924 /* set compression based on minor node opened */ 7925 minor = MT_DENSITY(un->un_dev); 7926 7927 /* 7928 * If this the compression density or 7929 * the drive has two densities and uses mode select for 7930 * control of compression turn on compression for MT_DENSITY2 7931 * as well. 7932 */ 7933 if ((minor == ST_COMPRESSION_DENSITY) || 7934 (minor == MT_DENSITY(MT_DENSITY2)) && 7935 (un->un_dp->densities[0] == un->un_dp->densities[1]) && 7936 (un->un_dp->densities[2] == un->un_dp->densities[3]) && 7937 (un->un_dp->densities[0] != un->un_dp->densities[2])) { 7938 7939 turn_compression_on = 1; 7940 } else { 7941 turn_compression_on = 0; 7942 } 7943 7944 un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16); 7945 un->un_mspl->mid_bl = (uchar_t)(un->un_bsize >> 8); 7946 un->un_mspl->low_bl = (uchar_t)(un->un_bsize); 7947 7948 /* 7949 * Need to determine which page does the device use for compression. 7950 * First try the data compression page. If this fails try the device 7951 * configuration page 7952 */ 7953 7954 if ((un->un_comp_page & ST_DEV_DATACOMP_PAGE) == ST_DEV_DATACOMP_PAGE) { 7955 rval = st_set_datacomp_page(un, turn_compression_on); 7956 if (rval == EALREADY) { 7957 return (rval); 7958 } 7959 if (rval != 0) { 7960 if (un->un_status == KEY_ILLEGAL_REQUEST) { 7961 /* 7962 * This device does not support data 7963 * compression page 7964 */ 7965 un->un_comp_page = ST_DEV_CONFIG_PAGE; 7966 } else if (un->un_state >= ST_STATE_OPEN) { 7967 un->un_pos.pmode = invalid; 7968 rval = EIO; 7969 } else { 7970 rval = -1; 7971 } 7972 } else { 7973 un->un_comp_page = ST_DEV_DATACOMP_PAGE; 7974 } 7975 } 7976 7977 if ((un->un_comp_page & ST_DEV_CONFIG_PAGE) == ST_DEV_CONFIG_PAGE) { 7978 rval = st_set_devconfig_page(un, turn_compression_on); 7979 if (rval == EALREADY) { 7980 return (rval); 7981 } 7982 if (rval != 0) { 7983 if (un->un_status == KEY_ILLEGAL_REQUEST) { 7984 /* 7985 * This device does not support 7986 * compression at all advice the 7987 * user and unset ST_MODE_SEL_COMP 7988 */ 7989 un->un_dp->options &= ~ST_MODE_SEL_COMP; 7990 un->un_comp_page = 0; 7991 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7992 "Device Does Not Support Compression\n"); 7993 } else if (un->un_state >= ST_STATE_OPEN) { 7994 un->un_pos.pmode = invalid; 7995 rval = EIO; 7996 } else { 7997 rval = -1; 7998 } 7999 } 8000 } 8001 8002 return (rval); 8003 } 8004 8005 /* 8006 * set or unset compression thru device configuration page. 8007 */ 8008 static int 8009 st_set_devconfig_page(struct scsi_tape *un, int compression_on) 8010 { 8011 unsigned char cflag; 8012 int rval = 0; 8013 8014 8015 ST_FUNC(ST_DEVINFO, st_set_devconfig_page); 8016 8017 ASSERT(mutex_owned(ST_MUTEX)); 8018 8019 /* 8020 * if the mode sense page is not the correct one, load the correct one. 8021 */ 8022 if (un->un_mspl->page_code != ST_DEV_CONFIG_PAGE) { 8023 rval = st_gen_mode_sense(un, st_uscsi_cmd, ST_DEV_CONFIG_PAGE, 8024 un->un_mspl, sizeof (struct seq_mode)); 8025 if (rval) 8026 return (rval); 8027 } 8028 8029 /* 8030 * Figure what to set compression flag to. 8031 */ 8032 if (compression_on) { 8033 /* They have selected a compression node */ 8034 if (un->un_dp->type == ST_TYPE_FUJI) { 8035 cflag = 0x84; /* use EDRC */ 8036 } else { 8037 cflag = ST_DEV_CONFIG_DEF_COMP; 8038 } 8039 } else { 8040 cflag = ST_DEV_CONFIG_NO_COMP; 8041 } 8042 8043 /* 8044 * If compression is already set the way it was requested. 8045 * And if this not the first time we has tried. 8046 */ 8047 if ((cflag == un->un_mspl->page.dev.comp_alg) && 8048 (un->un_comp_page == ST_DEV_CONFIG_PAGE)) { 8049 return (EALREADY); 8050 } 8051 8052 un->un_mspl->page.dev.comp_alg = cflag; 8053 /* 8054 * need to send mode select even if correct compression is 8055 * already set since need to set density code 8056 */ 8057 8058 #ifdef STDEBUG 8059 if ((st_debug & 0x7) >= 6) { 8060 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 8061 "st_set_devconfig_page: sense data for mode select", 8062 (char *)un->un_mspl, sizeof (struct seq_mode)); 8063 } 8064 #endif 8065 rval = st_gen_mode_select(un, st_uscsi_cmd, un->un_mspl, 8066 sizeof (struct seq_mode)); 8067 8068 return (rval); 8069 } 8070 8071 /* 8072 * set/reset compression bit thru data compression page 8073 */ 8074 static int 8075 st_set_datacomp_page(struct scsi_tape *un, int compression_on) 8076 { 8077 int compression_on_already; 8078 int rval = 0; 8079 8080 8081 ST_FUNC(ST_DEVINFO, st_set_datacomp_page); 8082 8083 ASSERT(mutex_owned(ST_MUTEX)); 8084 8085 /* 8086 * if the mode sense page is not the correct one, load the correct one. 8087 */ 8088 if (un->un_mspl->page_code != ST_DEV_DATACOMP_PAGE) { 8089 rval = st_gen_mode_sense(un, st_uscsi_cmd, ST_DEV_DATACOMP_PAGE, 8090 un->un_mspl, sizeof (struct seq_mode)); 8091 if (rval) 8092 return (rval); 8093 } 8094 8095 /* 8096 * If drive is not capable of compression (at this time) 8097 * return EALREADY so caller doesn't think that this page 8098 * is not supported. This check is for drives that can 8099 * disable compression from the front panel or configuration. 8100 * I doubt that a drive that supports this page is not really 8101 * capable of compression. 8102 */ 8103 if (un->un_mspl->page.comp.dcc == 0) { 8104 return (EALREADY); 8105 } 8106 8107 /* See if compression currently turned on */ 8108 if (un->un_mspl->page.comp.dce) { 8109 compression_on_already = 1; 8110 } else { 8111 compression_on_already = 0; 8112 } 8113 8114 /* 8115 * If compression is already set the way it was requested. 8116 * And if this not the first time we has tried. 8117 */ 8118 if ((compression_on == compression_on_already) && 8119 (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) { 8120 return (EALREADY); 8121 } 8122 8123 /* 8124 * if we are already set to the appropriate compression 8125 * mode, don't set it again 8126 */ 8127 if (compression_on) { 8128 /* compression selected */ 8129 un->un_mspl->page.comp.dce = 1; 8130 } else { 8131 un->un_mspl->page.comp.dce = 0; 8132 } 8133 8134 8135 #ifdef STDEBUG 8136 if ((st_debug & 0x7) >= 6) { 8137 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 8138 "st_set_datacomp_page: sense data for mode select", 8139 (char *)un->un_mspl, sizeof (struct seq_mode)); 8140 } 8141 #endif 8142 rval = st_gen_mode_select(un, st_uscsi_cmd, un->un_mspl, 8143 sizeof (struct seq_mode)); 8144 8145 return (rval); 8146 } 8147 8148 static int 8149 st_modesense(struct scsi_tape *un) 8150 { 8151 int rval; 8152 uchar_t page; 8153 8154 ST_FUNC(ST_DEVINFO, st_modesense); 8155 8156 page = un->un_comp_page; 8157 8158 switch (page) { 8159 case ST_DEV_DATACOMP_PAGE: 8160 case ST_DEV_CONFIG_PAGE: /* FALLTHROUGH */ 8161 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, un->un_mspl, 8162 sizeof (struct seq_mode)); 8163 break; 8164 8165 case ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE: 8166 if (un->un_dp->options & ST_MODE_SEL_COMP) { 8167 page = ST_DEV_DATACOMP_PAGE; 8168 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, 8169 un->un_mspl, sizeof (struct seq_mode)); 8170 if (rval == 0 && un->un_mspl->page_code == page) { 8171 un->un_comp_page = page; 8172 break; 8173 } 8174 page = ST_DEV_CONFIG_PAGE; 8175 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, 8176 un->un_mspl, sizeof (struct seq_mode)); 8177 if (rval == 0 && un->un_mspl->page_code == page) { 8178 un->un_comp_page = page; 8179 break; 8180 } 8181 un->un_dp->options &= ~ST_MODE_SEL_COMP; 8182 un->un_comp_page = 0; 8183 } else { 8184 un->un_comp_page = 0; 8185 } 8186 8187 default: /* FALLTHROUGH */ 8188 rval = st_cmd(un, SCMD_MODE_SENSE, MSIZE, SYNC_CMD); 8189 } 8190 return (rval); 8191 } 8192 8193 static int 8194 st_modeselect(struct scsi_tape *un) 8195 { 8196 int rval = 0; 8197 int ix; 8198 8199 ST_FUNC(ST_DEVINFO, st_modeselect); 8200 8201 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8202 "st_modeselect(dev = 0x%lx): density = 0x%x\n", 8203 un->un_dev, un->un_mspl->density); 8204 8205 ASSERT(mutex_owned(ST_MUTEX)); 8206 8207 /* 8208 * The parameter list should be the same for all of the 8209 * cases that follow so set them here 8210 * 8211 * Try mode select first if if fails set fields manually 8212 */ 8213 rval = st_modesense(un); 8214 if (rval != 0) { 8215 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 8216 "st_modeselect: First mode sense failed\n"); 8217 un->un_mspl->bd_len = 8; 8218 un->un_mspl->high_nb = 0; 8219 un->un_mspl->mid_nb = 0; 8220 un->un_mspl->low_nb = 0; 8221 } 8222 un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16); 8223 un->un_mspl->mid_bl = (uchar_t)(un->un_bsize >> 8); 8224 un->un_mspl->low_bl = (uchar_t)(un->un_bsize); 8225 8226 8227 /* 8228 * If configured to use a specific density code for a media type. 8229 * curdens is previously set by the minor node opened. 8230 * If the media type doesn't match the minor node we change it so it 8231 * looks like the correct one was opened. 8232 */ 8233 if (un->un_dp->options & ST_KNOWS_MEDIA) { 8234 uchar_t best; 8235 8236 for (best = 0xff, ix = 0; ix < NDENSITIES; ix++) { 8237 if (un->un_mspl->media_type == 8238 un->un_dp->mediatype[ix]) { 8239 best = ix; 8240 /* 8241 * It matches but it might not be the only one. 8242 * Use the highest matching media type but not 8243 * to exceed the density selected by the open. 8244 */ 8245 if (ix < un->un_curdens) { 8246 continue; 8247 } 8248 un->un_curdens = ix; 8249 break; 8250 } 8251 } 8252 /* If a match was found best will not be 0xff any more */ 8253 if (best < NDENSITIES) { 8254 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 8255 "found media 0x%X using density 0x%X\n", 8256 un->un_mspl->media_type, 8257 un->un_dp->densities[best]); 8258 un->un_mspl->density = un->un_dp->densities[best]; 8259 } else { 8260 /* Otherwise set density based on minor node opened */ 8261 un->un_mspl->density = 8262 un->un_dp->densities[un->un_curdens]; 8263 } 8264 } else { 8265 un->un_mspl->density = un->un_dp->densities[un->un_curdens]; 8266 } 8267 8268 if (un->un_dp->options & ST_NOBUF) { 8269 un->un_mspl->bufm = 0; 8270 } else { 8271 un->un_mspl->bufm = 1; 8272 } 8273 8274 rval = st_set_compression(un); 8275 8276 /* 8277 * If st_set_compression returned invalid or already it 8278 * found no need to do the mode select. 8279 * So do it here. 8280 */ 8281 if ((rval == ENOTTY) || (rval == EALREADY)) { 8282 8283 /* Zero non-writeable fields */ 8284 un->un_mspl->data_len = 0; 8285 un->un_mspl->media_type = 0; 8286 un->un_mspl->wp = 0; 8287 8288 /* need to set the density code */ 8289 rval = st_cmd(un, SCMD_MODE_SELECT, MSIZE, SYNC_CMD); 8290 if (rval != 0) { 8291 if (un->un_state >= ST_STATE_OPEN) { 8292 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 8293 "unable to set tape mode\n"); 8294 un->un_pos.pmode = invalid; 8295 rval = EIO; 8296 } else { 8297 rval = -1; 8298 } 8299 } 8300 } 8301 8302 /* 8303 * The spec recommends to send a mode sense after a mode select 8304 */ 8305 (void) st_modesense(un); 8306 8307 ASSERT(mutex_owned(ST_MUTEX)); 8308 8309 return (rval); 8310 } 8311 8312 /* 8313 * st_gen_mode_sense 8314 * 8315 * generic mode sense.. it allows for any page 8316 */ 8317 static int 8318 st_gen_mode_sense(struct scsi_tape *un, ubufunc_t ubf, int page, 8319 struct seq_mode *page_data, int page_size) 8320 { 8321 8322 int r; 8323 char cdb[CDB_GROUP0]; 8324 struct uscsi_cmd *com; 8325 struct scsi_arq_status status; 8326 8327 ST_FUNC(ST_DEVINFO, st_gen_mode_sense); 8328 8329 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8330 8331 bzero(cdb, CDB_GROUP0); 8332 cdb[0] = SCMD_MODE_SENSE; 8333 cdb[2] = (char)page; 8334 cdb[4] = (char)page_size; 8335 8336 com->uscsi_cdb = cdb; 8337 com->uscsi_cdblen = CDB_GROUP0; 8338 com->uscsi_bufaddr = (caddr_t)page_data; 8339 com->uscsi_buflen = page_size; 8340 com->uscsi_rqlen = sizeof (status); 8341 com->uscsi_rqbuf = (caddr_t)&status; 8342 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8343 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 8344 8345 r = ubf(un, com, FKIOCTL); 8346 kmem_free(com, sizeof (*com)); 8347 return (r); 8348 } 8349 8350 /* 8351 * st_gen_mode_select 8352 * 8353 * generic mode select.. it allows for any page 8354 */ 8355 static int 8356 st_gen_mode_select(struct scsi_tape *un, ubufunc_t ubf, 8357 struct seq_mode *page_data, int page_size) 8358 { 8359 8360 int r; 8361 char cdb[CDB_GROUP0]; 8362 struct uscsi_cmd *com; 8363 struct scsi_arq_status status; 8364 8365 ST_FUNC(ST_DEVINFO, st_gen_mode_select); 8366 8367 /* Zero non-writeable fields */ 8368 page_data->data_len = 0; 8369 page_data->media_type = 0; 8370 page_data->wp = 0; 8371 8372 /* 8373 * If mode select has any page data, zero the ps (Page Savable) bit. 8374 */ 8375 if (page_size > MSIZE) { 8376 page_data->ps = 0; 8377 } 8378 8379 8380 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8381 8382 /* 8383 * then, do a mode select to set what ever info 8384 */ 8385 bzero(cdb, CDB_GROUP0); 8386 cdb[0] = SCMD_MODE_SELECT; 8387 cdb[1] = 0x10; /* set PF bit for many third party drives */ 8388 cdb[4] = (char)page_size; 8389 8390 com->uscsi_cdb = cdb; 8391 com->uscsi_cdblen = CDB_GROUP0; 8392 com->uscsi_bufaddr = (caddr_t)page_data; 8393 com->uscsi_buflen = page_size; 8394 com->uscsi_rqlen = sizeof (status); 8395 com->uscsi_rqbuf = (caddr_t)&status; 8396 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8397 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_WRITE; 8398 8399 r = ubf(un, com, FKIOCTL); 8400 8401 kmem_free(com, sizeof (*com)); 8402 return (r); 8403 } 8404 8405 static int 8406 st_read_block_limits(struct scsi_tape *un, struct read_blklim *read_blk) 8407 { 8408 int rval; 8409 char cdb[CDB_GROUP0]; 8410 struct uscsi_cmd *com; 8411 struct scsi_arq_status status; 8412 8413 ST_FUNC(ST_DEVINFO, st_read_block_limits); 8414 8415 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8416 8417 bzero(cdb, CDB_GROUP0); 8418 cdb[0] = SCMD_READ_BLKLIM; 8419 8420 com->uscsi_cdb = cdb; 8421 com->uscsi_cdblen = CDB_GROUP0; 8422 com->uscsi_bufaddr = (caddr_t)read_blk; 8423 com->uscsi_buflen = sizeof (struct read_blklim); 8424 com->uscsi_rqlen = sizeof (status); 8425 com->uscsi_rqbuf = (caddr_t)&status; 8426 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8427 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 8428 8429 rval = st_uscsi_cmd(un, com, FKIOCTL); 8430 if (com->uscsi_status || com->uscsi_resid) { 8431 rval = -1; 8432 } 8433 8434 kmem_free(com, sizeof (*com)); 8435 return (rval); 8436 } 8437 8438 static int 8439 st_report_density_support(struct scsi_tape *un, uchar_t *density_data, 8440 size_t buflen) 8441 { 8442 int rval; 8443 char cdb[CDB_GROUP1]; 8444 struct uscsi_cmd *com; 8445 struct scsi_arq_status status; 8446 8447 ST_FUNC(ST_DEVINFO, st_report_density_support); 8448 8449 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8450 8451 bzero(cdb, CDB_GROUP1); 8452 cdb[0] = SCMD_REPORT_DENSITIES; 8453 cdb[7] = (buflen & 0xff00) >> 8; 8454 cdb[8] = buflen & 0xff; 8455 8456 com->uscsi_cdb = cdb; 8457 com->uscsi_cdblen = CDB_GROUP1; 8458 com->uscsi_bufaddr = (caddr_t)density_data; 8459 com->uscsi_buflen = buflen; 8460 com->uscsi_rqlen = sizeof (status); 8461 com->uscsi_rqbuf = (caddr_t)&status; 8462 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8463 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 8464 8465 rval = st_uscsi_cmd(un, com, FKIOCTL); 8466 if (com->uscsi_status || com->uscsi_resid) { 8467 rval = -1; 8468 } 8469 8470 kmem_free(com, sizeof (*com)); 8471 return (rval); 8472 } 8473 8474 static int 8475 st_report_supported_operation(struct scsi_tape *un, uchar_t *oper_data, 8476 uchar_t option_code, ushort_t service_action) 8477 { 8478 int rval; 8479 char cdb[CDB_GROUP5]; 8480 struct uscsi_cmd *com; 8481 struct scsi_arq_status status; 8482 uint32_t allo_length; 8483 8484 ST_FUNC(ST_DEVINFO, st_report_supported_operation); 8485 8486 allo_length = sizeof (struct one_com_des) + 8487 sizeof (struct com_timeout_des); 8488 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8489 8490 bzero(cdb, CDB_GROUP5); 8491 cdb[0] = (char)SCMD_MAINTENANCE_IN; 8492 cdb[1] = SSVC_ACTION_GET_SUPPORTED_OPERATIONS; 8493 if (service_action) { 8494 cdb[2] = (char)(ONE_COMMAND_DATA_FORMAT | 0x80); /* RCTD */ 8495 cdb[4] = (service_action & 0xff00) >> 8; 8496 cdb[5] = service_action & 0xff; 8497 } else { 8498 cdb[2] = (char)(ONE_COMMAND_NO_SERVICE_DATA_FORMAT | 8499 0x80); /* RCTD */ 8500 } 8501 cdb[3] = option_code; 8502 cdb[6] = (allo_length & 0xff000000) >> 24; 8503 cdb[7] = (allo_length & 0xff0000) >> 16; 8504 cdb[8] = (allo_length & 0xff00) >> 8; 8505 cdb[9] = allo_length & 0xff; 8506 8507 com->uscsi_cdb = cdb; 8508 com->uscsi_cdblen = CDB_GROUP5; 8509 com->uscsi_bufaddr = (caddr_t)oper_data; 8510 com->uscsi_buflen = allo_length; 8511 com->uscsi_rqlen = sizeof (status); 8512 com->uscsi_rqbuf = (caddr_t)&status; 8513 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8514 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 8515 8516 rval = st_uscsi_cmd(un, com, FKIOCTL); 8517 if (com->uscsi_status) { 8518 rval = -1; 8519 } 8520 8521 kmem_free(com, sizeof (*com)); 8522 return (rval); 8523 } 8524 8525 /* 8526 * Changes devices blocksize and bsize to requested blocksize nblksz. 8527 * Returns returned value from first failed call or zero on success. 8528 */ 8529 static int 8530 st_change_block_size(struct scsi_tape *un, uint32_t nblksz) 8531 { 8532 struct seq_mode *current; 8533 int rval; 8534 uint32_t oldblksz; 8535 8536 ST_FUNC(ST_DEVINFO, st_change_block_size); 8537 8538 current = kmem_zalloc(MSIZE, KM_SLEEP); 8539 8540 /* 8541 * If we haven't got the compression page yet, do that first. 8542 */ 8543 if (un->un_comp_page == (ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE)) { 8544 (void) st_modesense(un); 8545 } 8546 8547 /* Read current settings */ 8548 rval = st_gen_mode_sense(un, st_uscsi_cmd, 0, current, MSIZE); 8549 if (rval != 0) { 8550 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8551 "mode sense for change block size failed: rval = %d", rval); 8552 goto finish; 8553 } 8554 8555 /* Figure the current block size */ 8556 oldblksz = 8557 (current->high_bl << 16) | 8558 (current->mid_bl << 8) | 8559 (current->low_bl); 8560 8561 /* If current block size is the same as requested were done */ 8562 if (oldblksz == nblksz) { 8563 un->un_bsize = nblksz; 8564 rval = 0; 8565 goto finish; 8566 } 8567 8568 /* Change to requested block size */ 8569 current->high_bl = (uchar_t)(nblksz >> 16); 8570 current->mid_bl = (uchar_t)(nblksz >> 8); 8571 current->low_bl = (uchar_t)(nblksz); 8572 8573 /* Attempt to change block size */ 8574 rval = st_gen_mode_select(un, st_uscsi_cmd, current, MSIZE); 8575 if (rval != 0) { 8576 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8577 "Set new block size failed: rval = %d", rval); 8578 goto finish; 8579 } 8580 8581 /* Read back and verify setting */ 8582 rval = st_modesense(un); 8583 if (rval == 0) { 8584 un->un_bsize = 8585 (un->un_mspl->high_bl << 16) | 8586 (un->un_mspl->mid_bl << 8) | 8587 (un->un_mspl->low_bl); 8588 8589 if (un->un_bsize != nblksz) { 8590 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8591 "Blocksize set does not equal requested blocksize" 8592 "(read: %u requested: %u)\n", nblksz, un->un_bsize); 8593 rval = EIO; 8594 } 8595 } 8596 finish: 8597 kmem_free(current, MSIZE); 8598 return (rval); 8599 } 8600 8601 8602 static void 8603 st_init(struct scsi_tape *un) 8604 { 8605 ST_FUNC(ST_DEVINFO, st_init); 8606 8607 ASSERT(mutex_owned(ST_MUTEX)); 8608 8609 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8610 "st_init(): dev = 0x%lx, will reset fileno, blkno, eof\n", 8611 un->un_dev); 8612 8613 un->un_pos.blkno = 0; 8614 un->un_pos.fileno = 0; 8615 un->un_lastop = ST_OP_NIL; 8616 un->un_pos.eof = ST_NO_EOF; 8617 un->un_pwr_mgmt = ST_PWR_NORMAL; 8618 if (st_error_level != SCSI_ERR_ALL) { 8619 if (DEBUGGING) { 8620 st_error_level = SCSI_ERR_ALL; 8621 } else { 8622 st_error_level = SCSI_ERR_RETRYABLE; 8623 } 8624 } 8625 } 8626 8627 8628 static void 8629 st_make_cmd(struct scsi_tape *un, struct buf *bp, int (*func)(caddr_t)) 8630 { 8631 struct scsi_pkt *pkt; 8632 struct uscsi_cmd *ucmd; 8633 recov_info *ri; 8634 int tval = 0; 8635 int64_t count; 8636 uint32_t additional = 0; 8637 uint32_t address = 0; 8638 union scsi_cdb *ucdb; 8639 int flags = 0; 8640 int cdb_len = CDB_GROUP0; /* default */ 8641 uchar_t com; 8642 char fixbit; 8643 char short_fm = 0; 8644 optype prev_op = un->un_lastop; 8645 int stat_size = 8646 (un->un_arq_enabled ? sizeof (struct scsi_arq_status) : 1); 8647 8648 ST_FUNC(ST_DEVINFO, st_make_cmd); 8649 8650 ASSERT(mutex_owned(ST_MUTEX)); 8651 8652 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8653 "st_make_cmd(): dev = 0x%lx\n", un->un_dev); 8654 8655 8656 /* 8657 * fixbit is for setting the Fixed Mode and Suppress Incorrect 8658 * Length Indicator bits on read/write commands, for setting 8659 * the Long bit on erase commands, and for setting the Code 8660 * Field bits on space commands. 8661 */ 8662 8663 /* regular raw I/O */ 8664 if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) { 8665 pkt = scsi_init_pkt(ROUTE, NULL, bp, 8666 CDB_GROUP0, stat_size, st_recov_sz, 0, func, 8667 (caddr_t)un); 8668 if (pkt == NULL) { 8669 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 8670 "Read Write scsi_init_pkt() failure\n"); 8671 goto exit; 8672 } 8673 ASSERT(pkt->pkt_resid == 0); 8674 #ifdef STDEBUG 8675 bzero(pkt->pkt_private, st_recov_sz); 8676 bzero(pkt->pkt_scbp, stat_size); 8677 #endif 8678 ri = (recov_info *)pkt->pkt_private; 8679 ri->privatelen = st_recov_sz; 8680 if (un->un_bsize == 0) { 8681 count = bp->b_bcount; 8682 fixbit = 0; 8683 } else { 8684 count = bp->b_bcount / un->un_bsize; 8685 fixbit = 1; 8686 } 8687 if (bp->b_flags & B_READ) { 8688 com = SCMD_READ; 8689 un->un_lastop = ST_OP_READ; 8690 if ((un->un_bsize == 0) && /* Not Fixed Block */ 8691 (un->un_dp->options & ST_READ_IGNORE_ILI)) { 8692 fixbit = 2; 8693 } 8694 } else { 8695 com = SCMD_WRITE; 8696 un->un_lastop = ST_OP_WRITE; 8697 } 8698 tval = un->un_dp->io_timeout; 8699 8700 /* 8701 * For really large xfers, increase timeout 8702 */ 8703 if (bp->b_bcount > (10 * ONE_MEG)) 8704 tval *= bp->b_bcount/(10 * ONE_MEG); 8705 8706 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8707 "%s %d amt 0x%lx\n", (com == SCMD_WRITE) ? 8708 wr_str: rd_str, un->un_pos.blkno, bp->b_bcount); 8709 8710 } else if ((ucmd = BP_UCMD(bp)) != NULL) { 8711 /* 8712 * uscsi - build command, allocate scsi resources 8713 */ 8714 st_make_uscsi_cmd(un, ucmd, bp, func); 8715 goto exit; 8716 8717 } else { /* special I/O */ 8718 struct buf *allocbp = NULL; 8719 com = (uchar_t)(uintptr_t)bp->b_forw; 8720 count = bp->b_bcount; 8721 8722 switch (com) { 8723 case SCMD_READ: 8724 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8725 "special read %"PRId64"\n", count); 8726 if (un->un_bsize == 0) { 8727 fixbit = 2; /* suppress SILI */ 8728 } else { 8729 fixbit = 1; /* Fixed Block Mode */ 8730 count /= un->un_bsize; 8731 } 8732 allocbp = bp; 8733 un->un_lastop = ST_OP_READ; 8734 tval = un->un_dp->io_timeout; 8735 break; 8736 8737 case SCMD_WRITE: 8738 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8739 "special write %"PRId64"\n", count); 8740 if (un->un_bsize != 0) { 8741 fixbit = 1; /* Fixed Block Mode */ 8742 count /= un->un_bsize; 8743 } else { 8744 fixbit = 0; 8745 } 8746 allocbp = bp; 8747 un->un_lastop = ST_OP_WRITE; 8748 tval = un->un_dp->io_timeout; 8749 break; 8750 8751 case SCMD_WRITE_FILE_MARK: 8752 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8753 "write %"PRId64" file marks\n", count); 8754 un->un_lastop = ST_OP_WEOF; 8755 fixbit = 0; 8756 tval = un->un_dp->io_timeout; 8757 /* 8758 * If ST_SHORT_FILEMARKS bit is ON for EXABYTE 8759 * device, set the Vendor Unique bit to 8760 * write Short File Mark. 8761 */ 8762 if ((un->un_dp->options & ST_SHORT_FILEMARKS) && 8763 ((un->un_dp->type == ST_TYPE_EXB8500) || 8764 (un->un_dp->type == ST_TYPE_EXABYTE))) { 8765 /* 8766 * Now the Vendor Unique bit 7 in Byte 5 of CDB 8767 * is set to to write Short File Mark 8768 */ 8769 short_fm = 1; 8770 } 8771 break; 8772 8773 case SCMD_REWIND: 8774 /* 8775 * In the case of rewind we're gona do the rewind with 8776 * the immediate bit set so status will be retured when 8777 * the command is accepted by the device. We clear the 8778 * B_ASYNC flag so we wait for that acceptance. 8779 */ 8780 fixbit = 0; 8781 if (bp->b_flags & B_ASYNC) { 8782 allocbp = bp; 8783 if (count) { 8784 fixbit = 1; 8785 bp->b_flags &= ~B_ASYNC; 8786 } 8787 } 8788 count = 0; 8789 bp->b_bcount = 0; 8790 un->un_lastop = ST_OP_CTL; 8791 tval = un->un_dp->rewind_timeout; 8792 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8793 "rewind\n"); 8794 break; 8795 8796 case SCMD_SPACE_G4: 8797 cdb_len = CDB_GROUP4; 8798 fixbit = SPACE_TYPE(bp->b_bcount); 8799 count = SPACE_CNT(bp->b_bcount); 8800 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 8801 " %s space %s %"PRId64" from file %d blk %d\n", 8802 bp->b_bcount & SP_BACKSP ? "backward" : "forward", 8803 space_strs[fixbit & 7], count, 8804 un->un_pos.fileno, un->un_pos.blkno); 8805 address = (count >> 48) & 0x1fff; 8806 additional = (count >> 16) & 0xffffffff; 8807 count &= 0xffff; 8808 count <<= 16; 8809 un->un_lastop = ST_OP_CTL; 8810 tval = un->un_dp->space_timeout; 8811 break; 8812 8813 case SCMD_SPACE: 8814 fixbit = SPACE_TYPE(bp->b_bcount); 8815 count = SPACE_CNT(bp->b_bcount); 8816 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8817 " %s space %s %"PRId64" from file %d blk %d\n", 8818 bp->b_bcount & SP_BACKSP ? "backward" : "forward", 8819 space_strs[fixbit & 7], count, 8820 un->un_pos.fileno, un->un_pos.blkno); 8821 count &= 0xffffffff; 8822 un->un_lastop = ST_OP_CTL; 8823 tval = un->un_dp->space_timeout; 8824 break; 8825 8826 case SCMD_LOAD: 8827 ASSERT(count < 10); 8828 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8829 "%s tape\n", load_strs[count]); 8830 fixbit = 0; 8831 8832 /* Loading or Unloading */ 8833 if (count & LD_LOAD) { 8834 tval = un->un_dp->load_timeout; 8835 } else { 8836 tval = un->un_dp->unload_timeout; 8837 } 8838 /* Is Retension requested */ 8839 if (count & LD_RETEN) { 8840 tval += un->un_dp->rewind_timeout; 8841 } 8842 un->un_lastop = ST_OP_CTL; 8843 break; 8844 8845 case SCMD_ERASE: 8846 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8847 "erase tape\n"); 8848 ASSERT(count == 1); /* mt sets this */ 8849 if (count == 1) { 8850 /* 8851 * do long erase 8852 */ 8853 fixbit = 1; /* Long */ 8854 8855 /* Drive might not honor immidiate bit */ 8856 tval = un->un_dp->erase_timeout; 8857 } else { 8858 /* Short Erase */ 8859 tval = un->un_dp->erase_timeout; 8860 fixbit = 0; 8861 } 8862 un->un_lastop = ST_OP_CTL; 8863 count = 0; 8864 break; 8865 8866 case SCMD_MODE_SENSE: 8867 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8868 "mode sense\n"); 8869 allocbp = bp; 8870 fixbit = 0; 8871 tval = un->un_dp->non_motion_timeout; 8872 un->un_lastop = ST_OP_CTL; 8873 break; 8874 8875 case SCMD_MODE_SELECT: 8876 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8877 "mode select\n"); 8878 allocbp = bp; 8879 fixbit = 0; 8880 tval = un->un_dp->non_motion_timeout; 8881 un->un_lastop = ST_OP_CTL; 8882 break; 8883 8884 case SCMD_RESERVE: 8885 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8886 "reserve\n"); 8887 fixbit = 0; 8888 tval = un->un_dp->non_motion_timeout; 8889 un->un_lastop = ST_OP_CTL; 8890 break; 8891 8892 case SCMD_RELEASE: 8893 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8894 "release\n"); 8895 fixbit = 0; 8896 tval = un->un_dp->non_motion_timeout; 8897 un->un_lastop = ST_OP_CTL; 8898 break; 8899 8900 case SCMD_READ_BLKLIM: 8901 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8902 "read block limits\n"); 8903 allocbp = bp; 8904 fixbit = count = 0; 8905 tval = un->un_dp->non_motion_timeout; 8906 un->un_lastop = ST_OP_CTL; 8907 break; 8908 8909 case SCMD_TEST_UNIT_READY: 8910 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8911 "test unit ready\n"); 8912 fixbit = 0; 8913 tval = un->un_dp->non_motion_timeout; 8914 un->un_lastop = ST_OP_CTL; 8915 break; 8916 8917 case SCMD_DOORLOCK: 8918 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8919 "prevent/allow media removal\n"); 8920 fixbit = 0; 8921 tval = un->un_dp->non_motion_timeout; 8922 un->un_lastop = ST_OP_CTL; 8923 break; 8924 8925 case SCMD_READ_POSITION: 8926 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8927 "read position\n"); 8928 fixbit = un->un_read_pos_type; 8929 cdb_len = CDB_GROUP1; 8930 tval = un->un_dp->non_motion_timeout; 8931 allocbp = bp; 8932 un->un_lastop = ST_OP_CTL; 8933 switch (un->un_read_pos_type) { 8934 case LONG_POS: 8935 count = 0; 8936 break; 8937 case EXT_POS: 8938 count = sizeof (tape_position_ext_t); 8939 break; 8940 case SHORT_POS: 8941 count = 0; 8942 break; 8943 default: 8944 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 8945 "Unknown read position type 0x%x in " 8946 " st_make_cmd()\n", un->un_read_pos_type); 8947 } 8948 break; 8949 8950 default: 8951 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 8952 "Unhandled scsi command 0x%x in st_make_cmd()\n", 8953 com); 8954 } 8955 8956 pkt = scsi_init_pkt(ROUTE, NULL, allocbp, cdb_len, stat_size, 8957 st_recov_sz, 0, func, (caddr_t)un); 8958 if (pkt == NULL) { 8959 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 8960 "generic command scsi_init_pkt() failure\n"); 8961 goto exit; 8962 } 8963 8964 ASSERT(pkt->pkt_resid == 0); 8965 #ifdef STDEBUG 8966 bzero(pkt->pkt_private, st_recov_sz); 8967 bzero(pkt->pkt_scbp, stat_size); 8968 #endif 8969 ri = (recov_info *)pkt->pkt_private; 8970 ri->privatelen = st_recov_sz; 8971 if (allocbp) { 8972 ASSERT(geterror(allocbp) == 0); 8973 } 8974 8975 } 8976 8977 ucdb = (union scsi_cdb *)pkt->pkt_cdbp; 8978 8979 (void) scsi_setup_cdb(ucdb, com, address, (uint_t)count, additional); 8980 FILL_SCSI1_LUN(un->un_sd, pkt); 8981 /* 8982 * Initialize the SILI/Fixed bits of the byte 1 of cdb. 8983 */ 8984 ucdb->t_code = fixbit; 8985 ucdb->g0_vu_1 = short_fm; 8986 pkt->pkt_flags = flags; 8987 8988 ASSERT(tval); 8989 pkt->pkt_time = tval; 8990 if (bp == un->un_recov_buf) { 8991 pkt->pkt_comp = st_recov_cb; 8992 } else { 8993 pkt->pkt_comp = st_intr; 8994 } 8995 8996 st_add_recovery_info_to_pkt(un, bp, pkt); 8997 8998 /* 8999 * If we just write data to tape and did a command that doesn't 9000 * change position, we still need to write a filemark. 9001 */ 9002 if ((prev_op == ST_OP_WRITE) || (prev_op == ST_OP_WEOF)) { 9003 recov_info *rcvi = pkt->pkt_private; 9004 cmd_attribute const *atrib; 9005 9006 if (rcvi->privatelen == sizeof (recov_info)) { 9007 atrib = rcvi->cmd_attrib; 9008 } else { 9009 atrib = st_lookup_cmd_attribute(com); 9010 } 9011 if (atrib->chg_tape_direction == DIR_NONE) { 9012 un->un_lastop = prev_op; 9013 } 9014 } 9015 9016 exit: 9017 ASSERT(mutex_owned(ST_MUTEX)); 9018 } 9019 9020 9021 /* 9022 * Build a command based on a uscsi command; 9023 */ 9024 static void 9025 st_make_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, 9026 struct buf *bp, int (*func)(caddr_t)) 9027 { 9028 struct scsi_pkt *pkt; 9029 recov_info *ri; 9030 caddr_t cdb; 9031 int cdblen; 9032 int stat_size = 1; 9033 int flags = 0; 9034 9035 ST_FUNC(ST_DEVINFO, st_make_uscsi_cmd); 9036 9037 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9038 "st_make_uscsi_cmd(): dev = 0x%lx\n", un->un_dev); 9039 9040 if (ucmd->uscsi_flags & USCSI_RQENABLE) { 9041 if (un->un_arq_enabled) { 9042 if (ucmd->uscsi_rqlen > SENSE_LENGTH) { 9043 stat_size = (int)(ucmd->uscsi_rqlen) + 9044 sizeof (struct scsi_arq_status) - 9045 sizeof (struct scsi_extended_sense); 9046 flags = PKT_XARQ; 9047 } else { 9048 stat_size = sizeof (struct scsi_arq_status); 9049 } 9050 } 9051 } 9052 9053 ASSERT(mutex_owned(ST_MUTEX)); 9054 9055 cdb = ucmd->uscsi_cdb; 9056 cdblen = ucmd->uscsi_cdblen; 9057 9058 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 9059 "st_make_uscsi_cmd: buflen=%ld bcount=%ld\n", 9060 ucmd->uscsi_buflen, bp->b_bcount); 9061 pkt = scsi_init_pkt(ROUTE, NULL, 9062 (bp->b_bcount > 0) ? bp : NULL, 9063 cdblen, stat_size, st_recov_sz, flags, func, (caddr_t)un); 9064 if (pkt == NULL) { 9065 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 9066 "uscsi command scsi_init_pkt() failure\n"); 9067 goto exit; 9068 } 9069 9070 ASSERT(pkt->pkt_resid == 0); 9071 #ifdef STDEBUG 9072 bzero(pkt->pkt_private, st_recov_sz); 9073 bzero(pkt->pkt_scbp, stat_size); 9074 #endif 9075 ri = (recov_info *)pkt->pkt_private; 9076 ri->privatelen = st_recov_sz; 9077 9078 bcopy(cdb, pkt->pkt_cdbp, (uint_t)cdblen); 9079 9080 #ifdef STDEBUG 9081 if ((st_debug & 0x7) >= 6) { 9082 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 9083 "pkt_cdbp", (char *)cdb, cdblen); 9084 } 9085 #endif 9086 9087 if (ucmd->uscsi_flags & USCSI_SILENT) { 9088 pkt->pkt_flags |= FLAG_SILENT; 9089 } 9090 9091 (void) scsi_uscsi_pktinit(ucmd, pkt); 9092 9093 pkt->pkt_time = ucmd->uscsi_timeout; 9094 if (bp == un->un_recov_buf) { 9095 pkt->pkt_comp = st_recov_cb; 9096 } else { 9097 pkt->pkt_comp = st_intr; 9098 } 9099 9100 st_add_recovery_info_to_pkt(un, bp, pkt); 9101 exit: 9102 ASSERT(mutex_owned(ST_MUTEX)); 9103 } 9104 9105 9106 /* 9107 * restart cmd currently at the head of the runq 9108 * 9109 * If scsi_transport() succeeds or the retries 9110 * count exhausted, restore the throttle that was 9111 * zeroed out in st_handle_intr_busy(). 9112 * 9113 */ 9114 static void 9115 st_intr_restart(void *arg) 9116 { 9117 struct scsi_tape *un = arg; 9118 struct buf *bp; 9119 int queued; 9120 int status = TRAN_ACCEPT; 9121 9122 mutex_enter(ST_MUTEX); 9123 9124 ST_FUNC(ST_DEVINFO, st_intr_restart); 9125 9126 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9127 "st_intr_restart(), un = 0x%p\n", (void *)un); 9128 9129 un->un_hib_tid = 0; 9130 9131 if (un->un_recov_buf_busy != 0) { 9132 bp = un->un_recov_buf; 9133 queued = 0; 9134 } else if (un->un_sbuf_busy != 0) { 9135 bp = un->un_sbufp; 9136 queued = 0; 9137 } else if (un->un_quef != NULL) { 9138 bp = un->un_quef; 9139 queued = 1; 9140 } else { 9141 mutex_exit(ST_MUTEX); 9142 return; 9143 } 9144 9145 /* 9146 * Here we know : 9147 * throttle = 0, via st_handle_intr_busy 9148 */ 9149 9150 if (queued) { 9151 /* 9152 * move from waitq to runq, if there is anything on the waitq 9153 */ 9154 (void) st_remove_from_queue(&un->un_quef, &un->un_quef, bp); 9155 9156 if (un->un_runqf) { 9157 /* 9158 * not good, we don't want to requeue something after 9159 * another. 9160 */ 9161 goto done_error; 9162 } else { 9163 un->un_runqf = bp; 9164 un->un_runql = bp; 9165 } 9166 } 9167 9168 ST_CDB(ST_DEVINFO, "Interrupt restart CDB", 9169 (char *)BP_PKT(bp)->pkt_cdbp); 9170 9171 ST_DO_KSTATS(bp, kstat_waitq_to_runq); 9172 9173 status = st_transport(un, BP_PKT(bp)); 9174 9175 if (status != TRAN_ACCEPT) { 9176 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 9177 9178 if (status == TRAN_BUSY) { 9179 pkt_info *pkti = BP_PKT(bp)->pkt_private; 9180 9181 if (pkti->privatelen == sizeof (recov_info) && 9182 un->un_unit_attention_flags && 9183 bp != un->un_recov_buf) { 9184 un->un_unit_attention_flags = 0; 9185 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 9186 "Command Recovery called on busy resend\n"); 9187 if (st_command_recovery(un, BP_PKT(bp), 9188 ATTEMPT_RETRY) == JUST_RETURN) { 9189 mutex_exit(ST_MUTEX); 9190 return; 9191 } 9192 } 9193 mutex_exit(ST_MUTEX); 9194 if (st_handle_intr_busy(un, bp, 9195 ST_TRAN_BUSY_TIMEOUT) == 0) 9196 return; /* timeout is setup again */ 9197 mutex_enter(ST_MUTEX); 9198 } 9199 9200 done_error: 9201 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 9202 "restart transport rejected\n"); 9203 bp->b_resid = bp->b_bcount; 9204 9205 if (un->un_last_throttle) { 9206 un->un_throttle = un->un_last_throttle; 9207 } 9208 if (status != TRAN_ACCEPT) { 9209 ST_DO_ERRSTATS(un, st_transerrs); 9210 } 9211 ST_DO_KSTATS(bp, kstat_waitq_exit); 9212 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 9213 "busy restart aborted\n"); 9214 st_set_pe_flag(un); 9215 st_bioerror(bp, EIO); 9216 st_done_and_mutex_exit(un, bp); 9217 } else { 9218 if (un->un_last_throttle) { 9219 un->un_throttle = un->un_last_throttle; 9220 } 9221 mutex_exit(ST_MUTEX); 9222 } 9223 } 9224 9225 /* 9226 * st_check_media(): 9227 * Periodically check the media state using scsi_watch service; 9228 * this service calls back after TUR and possibly request sense 9229 * the callback handler (st_media_watch_cb()) decodes the request sense 9230 * data (if any) 9231 */ 9232 9233 static int 9234 st_check_media(dev_t dev, enum mtio_state state) 9235 { 9236 int rval = 0; 9237 enum mtio_state prev_state; 9238 opaque_t token = NULL; 9239 9240 GET_SOFT_STATE(dev); 9241 9242 ST_FUNC(ST_DEVINFO, st_check_media); 9243 9244 mutex_enter(ST_MUTEX); 9245 9246 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9247 "st_check_media:state=%x, mediastate=%x\n", 9248 state, un->un_mediastate); 9249 9250 prev_state = un->un_mediastate; 9251 9252 /* 9253 * is there anything to do? 9254 */ 9255 retry: 9256 if (state == un->un_mediastate || un->un_mediastate == MTIO_NONE) { 9257 /* 9258 * submit the request to the scsi_watch service; 9259 * scsi_media_watch_cb() does the real work 9260 */ 9261 mutex_exit(ST_MUTEX); 9262 token = scsi_watch_request_submit(ST_SCSI_DEVP, 9263 st_check_media_time, SENSE_LENGTH, 9264 st_media_watch_cb, (caddr_t)dev); 9265 if (token == NULL) { 9266 rval = EAGAIN; 9267 goto done; 9268 } 9269 mutex_enter(ST_MUTEX); 9270 9271 un->un_swr_token = token; 9272 un->un_specified_mediastate = state; 9273 9274 /* 9275 * now wait for media change 9276 * we will not be signalled unless mediastate == state but it 9277 * still better to test for this condition, since there 9278 * is a 5 sec cv_broadcast delay when 9279 * mediastate == MTIO_INSERTED 9280 */ 9281 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9282 "st_check_media:waiting for media state change\n"); 9283 while (un->un_mediastate == state) { 9284 if (cv_wait_sig(&un->un_state_cv, ST_MUTEX) == 0) { 9285 mutex_exit(ST_MUTEX); 9286 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9287 "st_check_media:waiting for media state " 9288 "was interrupted\n"); 9289 rval = EINTR; 9290 goto done; 9291 } 9292 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9293 "st_check_media:received signal, state=%x\n", 9294 un->un_mediastate); 9295 } 9296 } 9297 9298 /* 9299 * if we transitioned to MTIO_INSERTED, media has really been 9300 * inserted. If TUR fails, it is probably a exabyte slow spin up. 9301 * Reset and retry the state change. If everything is ok, replay 9302 * the open() logic. 9303 */ 9304 if ((un->un_mediastate == MTIO_INSERTED) && 9305 (un->un_state == ST_STATE_OFFLINE)) { 9306 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9307 "st_check_media: calling st_cmd to confirm inserted\n"); 9308 9309 /* 9310 * set this early so that TUR will make it through strategy 9311 * without triggering a st_tape_init(). We needed it set 9312 * before calling st_tape_init() ourselves anyway. If TUR 9313 * fails, set it back 9314 */ 9315 un->un_state = ST_STATE_INITIALIZING; 9316 9317 /* 9318 * If not reserved fail as getting reservation conflict 9319 * will make this hang forever. 9320 */ 9321 if ((un->un_rsvd_status & 9322 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 9323 mutex_exit(ST_MUTEX); 9324 rval = EACCES; 9325 goto done; 9326 } 9327 rval = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 9328 if (rval == EACCES) { 9329 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9330 "st_check_media: TUR got Reservation Conflict\n"); 9331 mutex_exit(ST_MUTEX); 9332 goto done; 9333 } 9334 if (rval) { 9335 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9336 "st_check_media: TUR failed, going to retry\n"); 9337 un->un_mediastate = prev_state; 9338 un->un_state = ST_STATE_OFFLINE; 9339 goto retry; 9340 } 9341 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9342 "st_check_media: media inserted\n"); 9343 9344 /* this also rewinds the tape */ 9345 rval = st_tape_init(un); 9346 if (rval != 0) { 9347 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9348 "st_check_media : OFFLINE init failure "); 9349 un->un_state = ST_STATE_OFFLINE; 9350 un->un_pos.pmode = invalid; 9351 } else { 9352 un->un_state = ST_STATE_OPEN_PENDING_IO; 9353 } 9354 } else if ((un->un_mediastate == MTIO_EJECTED) && 9355 (un->un_state != ST_STATE_OFFLINE)) { 9356 /* 9357 * supported devices must be rewound before ejection 9358 * rewind resets fileno & blkno 9359 */ 9360 un->un_laststate = un->un_state; 9361 un->un_state = ST_STATE_OFFLINE; 9362 } 9363 mutex_exit(ST_MUTEX); 9364 done: 9365 if (token) { 9366 (void) scsi_watch_request_terminate(token, 9367 SCSI_WATCH_TERMINATE_WAIT); 9368 mutex_enter(ST_MUTEX); 9369 un->un_swr_token = (opaque_t)NULL; 9370 mutex_exit(ST_MUTEX); 9371 } 9372 9373 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_media: done\n"); 9374 9375 return (rval); 9376 } 9377 9378 /* 9379 * st_media_watch_cb() is called by scsi_watch_thread for 9380 * verifying the request sense data (if any) 9381 */ 9382 static int 9383 st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp) 9384 { 9385 struct scsi_status *statusp = resultp->statusp; 9386 struct scsi_extended_sense *sensep = resultp->sensep; 9387 uchar_t actual_sense_length = resultp->actual_sense_length; 9388 struct scsi_tape *un; 9389 enum mtio_state state = MTIO_NONE; 9390 int instance; 9391 dev_t dev = (dev_t)arg; 9392 9393 instance = MTUNIT(dev); 9394 if ((un = ddi_get_soft_state(st_state, instance)) == NULL) { 9395 return (-1); 9396 } 9397 9398 mutex_enter(ST_MUTEX); 9399 ST_FUNC(ST_DEVINFO, st_media_watch_cb); 9400 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9401 "st_media_watch_cb: status=%x, sensep=%p, len=%x\n", 9402 *((char *)statusp), (void *)sensep, 9403 actual_sense_length); 9404 9405 9406 /* 9407 * if there was a check condition then sensep points to valid 9408 * sense data 9409 * if status was not a check condition but a reservation or busy 9410 * status then the new state is MTIO_NONE 9411 */ 9412 if (sensep) { 9413 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9414 "st_media_watch_cb: KEY=%x, ASC=%x, ASCQ=%x\n", 9415 sensep->es_key, sensep->es_add_code, sensep->es_qual_code); 9416 9417 switch (un->un_dp->type) { 9418 default: 9419 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9420 "st_media_watch_cb: unknown drive type %d, " 9421 "default to ST_TYPE_HP\n", un->un_dp->type); 9422 /* FALLTHROUGH */ 9423 9424 case ST_TYPE_STC3490: /* STK 4220 1/2" cartridge */ 9425 case ST_TYPE_FUJI: /* 1/2" cartridge */ 9426 case ST_TYPE_HP: /* HP 88780 1/2" reel */ 9427 if (un->un_dp->type == ST_TYPE_FUJI) { 9428 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9429 "st_media_watch_cb: ST_TYPE_FUJI\n"); 9430 } else { 9431 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9432 "st_media_watch_cb: ST_TYPE_HP\n"); 9433 } 9434 switch (sensep->es_key) { 9435 case KEY_UNIT_ATTENTION: 9436 /* not ready to ready transition */ 9437 /* hp/es_qual_code == 80 on>off>on */ 9438 /* hp/es_qual_code == 0 on>off>unld>ld>on */ 9439 if (sensep->es_add_code == 0x28) { 9440 state = MTIO_INSERTED; 9441 } 9442 break; 9443 case KEY_NOT_READY: 9444 /* in process, rewinding or loading */ 9445 if ((sensep->es_add_code == 0x04) && 9446 (sensep->es_qual_code == 0x00)) { 9447 state = MTIO_EJECTED; 9448 } 9449 break; 9450 } 9451 break; 9452 9453 case ST_TYPE_EXB8500: /* Exabyte 8500 */ 9454 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9455 "st_media_watch_cb: ST_TYPE_EXB8500\n"); 9456 switch (sensep->es_key) { 9457 case KEY_UNIT_ATTENTION: 9458 /* operator medium removal request */ 9459 if ((sensep->es_add_code == 0x5a) && 9460 (sensep->es_qual_code == 0x01)) { 9461 state = MTIO_EJECTED; 9462 /* not ready to ready transition */ 9463 } else if ((sensep->es_add_code == 0x28) && 9464 (sensep->es_qual_code == 0x00)) { 9465 state = MTIO_INSERTED; 9466 } 9467 break; 9468 case KEY_NOT_READY: 9469 /* medium not present */ 9470 if (sensep->es_add_code == 0x3a) { 9471 state = MTIO_EJECTED; 9472 } 9473 break; 9474 } 9475 break; 9476 case ST_TYPE_EXABYTE: /* Exabyte 8200 */ 9477 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9478 "st_media_watch_cb: ST_TYPE_EXABYTE\n"); 9479 switch (sensep->es_key) { 9480 case KEY_NOT_READY: 9481 if ((sensep->es_add_code == 0x04) && 9482 (sensep->es_qual_code == 0x00)) { 9483 /* volume not mounted? */ 9484 state = MTIO_EJECTED; 9485 } else if (sensep->es_add_code == 0x3a) { 9486 state = MTIO_EJECTED; 9487 } 9488 break; 9489 case KEY_UNIT_ATTENTION: 9490 state = MTIO_EJECTED; 9491 break; 9492 } 9493 break; 9494 9495 case ST_TYPE_DLT: /* quantum DLT4xxx */ 9496 switch (sensep->es_key) { 9497 case KEY_UNIT_ATTENTION: 9498 if (sensep->es_add_code == 0x28) { 9499 state = MTIO_INSERTED; 9500 } 9501 break; 9502 case KEY_NOT_READY: 9503 if (sensep->es_add_code == 0x04) { 9504 /* in transition but could be either */ 9505 state = un->un_specified_mediastate; 9506 } else if ((sensep->es_add_code == 0x3a) && 9507 (sensep->es_qual_code == 0x00)) { 9508 state = MTIO_EJECTED; 9509 } 9510 break; 9511 } 9512 break; 9513 } 9514 } else if (*((char *)statusp) == STATUS_GOOD) { 9515 state = MTIO_INSERTED; 9516 } 9517 9518 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9519 "st_media_watch_cb:state=%x, specified=%x\n", 9520 state, un->un_specified_mediastate); 9521 9522 /* 9523 * now signal the waiting thread if this is *not* the specified state; 9524 * delay the signal if the state is MTIO_INSERTED 9525 * to allow the target to recover 9526 */ 9527 if (state != un->un_specified_mediastate) { 9528 un->un_mediastate = state; 9529 if (state == MTIO_INSERTED) { 9530 /* 9531 * delay the signal to give the drive a chance 9532 * to do what it apparently needs to do 9533 */ 9534 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9535 "st_media_watch_cb:delayed cv_broadcast\n"); 9536 un->un_delay_tid = timeout(st_delayed_cv_broadcast, 9537 un, drv_usectohz((clock_t)MEDIA_ACCESS_DELAY)); 9538 } else { 9539 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9540 "st_media_watch_cb:immediate cv_broadcast\n"); 9541 cv_broadcast(&un->un_state_cv); 9542 } 9543 } 9544 mutex_exit(ST_MUTEX); 9545 return (0); 9546 } 9547 9548 /* 9549 * delayed cv_broadcast to allow for target to recover 9550 * from media insertion 9551 */ 9552 static void 9553 st_delayed_cv_broadcast(void *arg) 9554 { 9555 struct scsi_tape *un = arg; 9556 9557 ST_FUNC(ST_DEVINFO, st_delayed_cv_broadcast); 9558 9559 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9560 "st_delayed_cv_broadcast:delayed cv_broadcast\n"); 9561 9562 mutex_enter(ST_MUTEX); 9563 cv_broadcast(&un->un_state_cv); 9564 mutex_exit(ST_MUTEX); 9565 } 9566 9567 /* 9568 * restart cmd currently at the start of the waitq 9569 */ 9570 static void 9571 st_start_restart(void *arg) 9572 { 9573 struct scsi_tape *un = arg; 9574 9575 ST_FUNC(ST_DEVINFO, st_start_restart); 9576 9577 ASSERT(un != NULL); 9578 9579 mutex_enter(ST_MUTEX); 9580 9581 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_tran_restart()\n"); 9582 9583 st_start(un); 9584 9585 mutex_exit(ST_MUTEX); 9586 } 9587 9588 9589 /* 9590 * Command completion processing 9591 * 9592 */ 9593 static void 9594 st_intr(struct scsi_pkt *pkt) 9595 { 9596 recov_info *rcv = pkt->pkt_private; 9597 struct buf *bp = rcv->cmd_bp; 9598 struct scsi_tape *un; 9599 errstate action = COMMAND_DONE; 9600 clock_t timout; 9601 int status; 9602 9603 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 9604 9605 ST_FUNC(ST_DEVINFO, st_intr); 9606 9607 ASSERT(un != NULL); 9608 9609 mutex_enter(ST_MUTEX); 9610 9611 ASSERT(bp != un->un_recov_buf); 9612 9613 un->un_rqs_state &= ~(ST_RQS_ERROR); 9614 9615 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_intr()\n"); 9616 9617 if (pkt->pkt_reason != CMD_CMPLT) { 9618 ST_DEBUG(ST_DEVINFO, st_label, CE_WARN, 9619 "Unhappy packet status reason = %s statistics = 0x%x\n", 9620 scsi_rname(pkt->pkt_reason), pkt->pkt_statistics); 9621 9622 /* If device has gone away not much else to do */ 9623 if (pkt->pkt_reason == CMD_DEV_GONE) { 9624 action = COMMAND_DONE_ERROR; 9625 } else if ((pkt == un->un_rqs) || 9626 (un->un_state == ST_STATE_SENSING)) { 9627 ASSERT(pkt == un->un_rqs); 9628 ASSERT(un->un_state == ST_STATE_SENSING); 9629 un->un_state = un->un_laststate; 9630 rcv->cmd_bp = un->un_rqs_bp; 9631 ST_DO_ERRSTATS(un, st_transerrs); 9632 action = COMMAND_DONE_ERROR; 9633 } else { 9634 action = st_handle_incomplete(un, bp); 9635 } 9636 /* 9637 * At this point we know that the command was successfully 9638 * completed. Now what? 9639 */ 9640 } else if ((pkt == un->un_rqs) || (un->un_state == ST_STATE_SENSING)) { 9641 /* 9642 * okay. We were running a REQUEST SENSE. Find 9643 * out what to do next. 9644 */ 9645 ASSERT(pkt == un->un_rqs); 9646 ASSERT(un->un_state == ST_STATE_SENSING); 9647 scsi_sync_pkt(pkt); 9648 action = st_handle_sense(un, bp, &un->un_pos); 9649 /* 9650 * Make rqs isn't going to be retied. 9651 */ 9652 if (action != QUE_BUSY_COMMAND && action != QUE_COMMAND) { 9653 /* 9654 * set pkt back to original packet in case we will have 9655 * to requeue it 9656 */ 9657 pkt = BP_PKT(bp); 9658 rcv->cmd_bp = un->un_rqs_bp; 9659 /* 9660 * some actions are based on un_state, hence 9661 * restore the state st was in before ST_STATE_SENSING. 9662 */ 9663 un->un_state = un->un_laststate; 9664 } 9665 9666 } else if (un->un_arq_enabled && (pkt->pkt_state & STATE_ARQ_DONE)) { 9667 /* 9668 * the transport layer successfully completed an autorqsense 9669 */ 9670 action = st_handle_autosense(un, bp, &un->un_pos); 9671 9672 } else if ((SCBP(pkt)->sts_busy) || 9673 (SCBP(pkt)->sts_chk) || 9674 (SCBP(pkt)->sts_vu7)) { 9675 /* 9676 * Okay, we weren't running a REQUEST SENSE. Call a routine 9677 * to see if the status bits we're okay. If a request sense 9678 * is to be run, that will happen. 9679 */ 9680 action = st_check_error(un, pkt); 9681 } 9682 9683 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 9684 switch (action) { 9685 case QUE_COMMAND: 9686 /* 9687 * return cmd to head to the queue 9688 * since we are suspending so that 9689 * it gets restarted during resume 9690 */ 9691 st_add_to_queue(&un->un_runqf, &un->un_runql, 9692 un->un_runqf, bp); 9693 9694 action = JUST_RETURN; 9695 break; 9696 9697 case QUE_SENSE: 9698 action = COMMAND_DONE_ERROR; 9699 break; 9700 9701 default: 9702 break; 9703 } 9704 } 9705 9706 /* 9707 * check for undetected path failover. 9708 */ 9709 if (un->un_multipath) { 9710 9711 struct uscsi_cmd *ucmd = BP_UCMD(bp); 9712 int pkt_valid = 0; 9713 9714 if (ucmd) { 9715 /* 9716 * Also copies path instance to the uscsi structure. 9717 */ 9718 pkt_valid = scsi_uscsi_pktfini(pkt, ucmd); 9719 9720 /* 9721 * scsi_uscsi_pktfini() zeros pkt_path_instance. 9722 */ 9723 pkt->pkt_path_instance = ucmd->uscsi_path_instance; 9724 } else { 9725 pkt_valid = scsi_pkt_allocated_correctly(pkt); 9726 } 9727 9728 /* 9729 * If the scsi_pkt was not allocated correctly the 9730 * pkt_path_instance is not even there. 9731 */ 9732 if ((pkt_valid != 0) && 9733 (un->un_last_path_instance != pkt->pkt_path_instance)) { 9734 /* 9735 * Don't recover the path change if it was done 9736 * intentionally or if the device has not completely 9737 * opened yet. 9738 */ 9739 if (((pkt->pkt_flags & FLAG_PKT_PATH_INSTANCE) == 0) && 9740 (un->un_state > ST_STATE_OPENING)) { 9741 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 9742 "Failover detected, action is %s\n", 9743 errstatenames[action]); 9744 if (action == COMMAND_DONE) { 9745 action = PATH_FAILED; 9746 } 9747 } 9748 un->un_last_path_instance = pkt->pkt_path_instance; 9749 } 9750 } 9751 9752 /* 9753 * Restore old state if we were sensing. 9754 */ 9755 if (un->un_state == ST_STATE_SENSING && action != QUE_SENSE) { 9756 un->un_state = un->un_laststate; 9757 } 9758 9759 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 9760 "st_intr: pkt=%p, bp=%p, action=%s, status=%x\n", 9761 (void *)pkt, (void *)bp, errstatenames[action], SCBP_C(pkt)); 9762 9763 again: 9764 switch (action) { 9765 case COMMAND_DONE_EACCES: 9766 /* this is to report a reservation conflict */ 9767 st_bioerror(bp, EACCES); 9768 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9769 "Reservation Conflict \n"); 9770 un->un_pos.pmode = invalid; 9771 9772 /*FALLTHROUGH*/ 9773 case COMMAND_DONE_ERROR: 9774 if (un->un_pos.eof < ST_EOT_PENDING && 9775 un->un_state >= ST_STATE_OPEN) { 9776 /* 9777 * all errors set state of the tape to 'unknown' 9778 * unless we're at EOT or are doing append testing. 9779 * If sense key was illegal request, preserve state. 9780 */ 9781 if (un->un_status != KEY_ILLEGAL_REQUEST) { 9782 un->un_pos.pmode = invalid; 9783 } 9784 } 9785 9786 un->un_err_resid = bp->b_resid = bp->b_bcount; 9787 /* 9788 * since we have an error (COMMAND_DONE_ERROR), we want to 9789 * make sure an error ocurrs, so make sure at least EIO is 9790 * returned 9791 */ 9792 if (geterror(bp) == 0) 9793 st_bioerror(bp, EIO); 9794 9795 st_set_pe_flag(un); 9796 if (!(un->un_rqs_state & ST_RQS_ERROR) && 9797 (un->un_errno == EIO)) { 9798 un->un_rqs_state &= ~(ST_RQS_VALID); 9799 } 9800 break; 9801 9802 case COMMAND_DONE_ERROR_RECOVERED: 9803 un->un_err_resid = bp->b_resid = bp->b_bcount; 9804 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 9805 "st_intr(): COMMAND_DONE_ERROR_RECOVERED"); 9806 if (geterror(bp) == 0) { 9807 st_bioerror(bp, EIO); 9808 } 9809 st_set_pe_flag(un); 9810 if (!(un->un_rqs_state & ST_RQS_ERROR) && 9811 (un->un_errno == EIO)) { 9812 un->un_rqs_state &= ~(ST_RQS_VALID); 9813 } 9814 /*FALLTHROUGH*/ 9815 case COMMAND_DONE: 9816 st_set_state(un, bp); 9817 break; 9818 9819 case QUE_SENSE: 9820 if ((un->un_ncmds > 1) && !un->un_flush_on_errors) 9821 goto sense_error; 9822 9823 if (un->un_state != ST_STATE_SENSING) { 9824 un->un_laststate = un->un_state; 9825 un->un_state = ST_STATE_SENSING; 9826 } 9827 9828 /* 9829 * zero the sense data. 9830 */ 9831 bzero(un->un_rqs->pkt_scbp, SENSE_LENGTH); 9832 9833 /* 9834 * If this is not a retry on QUE_SENSE point to the original 9835 * bp of the command that got us here. 9836 */ 9837 if (pkt != un->un_rqs) { 9838 ((recov_info *)un->un_rqs->pkt_private)->cmd_bp = bp; 9839 } 9840 9841 if (un->un_throttle) { 9842 un->un_last_throttle = un->un_throttle; 9843 un->un_throttle = 0; 9844 } 9845 9846 ST_CDB(ST_DEVINFO, "Queue sense CDB", 9847 (char *)BP_PKT(bp)->pkt_cdbp); 9848 9849 /* 9850 * never retry this, some other command will have nuked the 9851 * sense, anyway 9852 */ 9853 status = st_transport(un, un->un_rqs); 9854 9855 if (un->un_last_throttle) { 9856 un->un_throttle = un->un_last_throttle; 9857 } 9858 9859 if (status == TRAN_ACCEPT) { 9860 mutex_exit(ST_MUTEX); 9861 return; 9862 } 9863 if (status != TRAN_BUSY) 9864 ST_DO_ERRSTATS(un, st_transerrs); 9865 sense_error: 9866 un->un_pos.pmode = invalid; 9867 st_bioerror(bp, EIO); 9868 st_set_pe_flag(un); 9869 break; 9870 9871 case QUE_BUSY_COMMAND: 9872 /* longish timeout */ 9873 timout = ST_STATUS_BUSY_TIMEOUT; 9874 goto que_it_up; 9875 9876 case QUE_COMMAND: 9877 /* short timeout */ 9878 timout = ST_TRAN_BUSY_TIMEOUT; 9879 que_it_up: 9880 /* 9881 * let st_handle_intr_busy put this bp back on waitq and make 9882 * checks to see if it is ok to requeue the command. 9883 */ 9884 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 9885 9886 /* 9887 * Save the throttle before setting up the timeout 9888 */ 9889 if (un->un_throttle) { 9890 un->un_last_throttle = un->un_throttle; 9891 } 9892 mutex_exit(ST_MUTEX); 9893 if (st_handle_intr_busy(un, bp, timout) == 0) 9894 return; /* timeout is setup again */ 9895 9896 mutex_enter(ST_MUTEX); 9897 un->un_pos.pmode = invalid; 9898 un->un_err_resid = bp->b_resid = bp->b_bcount; 9899 st_bioerror(bp, EIO); 9900 st_set_pe_flag(un); 9901 break; 9902 9903 case QUE_LAST_COMMAND: 9904 9905 if ((un->un_ncmds > 1) && !un->un_flush_on_errors) { 9906 scsi_log(ST_DEVINFO, st_label, CE_CONT, 9907 "un_ncmds: %d can't retry cmd \n", un->un_ncmds); 9908 goto last_command_error; 9909 } 9910 mutex_exit(ST_MUTEX); 9911 if (st_handle_intr_retry_lcmd(un, bp) == 0) 9912 return; 9913 mutex_enter(ST_MUTEX); 9914 last_command_error: 9915 un->un_err_resid = bp->b_resid = bp->b_bcount; 9916 un->un_pos.pmode = invalid; 9917 st_bioerror(bp, EIO); 9918 st_set_pe_flag(un); 9919 break; 9920 9921 case COMMAND_TIMEOUT: 9922 case DEVICE_RESET: 9923 case DEVICE_TAMPER: 9924 case ATTEMPT_RETRY: 9925 case PATH_FAILED: 9926 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 9927 "Command Recovery called on %s status\n", 9928 errstatenames[action]); 9929 action = st_command_recovery(un, pkt, action); 9930 goto again; 9931 9932 default: 9933 ASSERT(0); 9934 /* FALLTHRU */ 9935 case JUST_RETURN: 9936 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 9937 mutex_exit(ST_MUTEX); 9938 return; 9939 } 9940 9941 ST_DO_KSTATS(bp, kstat_runq_exit); 9942 st_done_and_mutex_exit(un, bp); 9943 } 9944 9945 static errstate 9946 st_handle_incomplete(struct scsi_tape *un, struct buf *bp) 9947 { 9948 static char *fail = "SCSI transport failed: reason '%s': %s\n"; 9949 recov_info *rinfo; 9950 errstate rval = COMMAND_DONE_ERROR; 9951 struct scsi_pkt *pkt = (un->un_state == ST_STATE_SENSING) ? 9952 un->un_rqs : BP_PKT(bp); 9953 int result; 9954 9955 ST_FUNC(ST_DEVINFO, st_handle_incomplete); 9956 9957 rinfo = (recov_info *)pkt->pkt_private; 9958 9959 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9960 "st_handle_incomplete(): dev = 0x%lx\n", un->un_dev); 9961 9962 ASSERT(mutex_owned(ST_MUTEX)); 9963 9964 /* prevent infinite number of retries */ 9965 if (rinfo->pkt_retry_cnt++ > st_retry_count) { 9966 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 9967 "Recovery stopped for incomplete %s command, " 9968 "retries exhausted", 9969 st_print_scsi_cmd(pkt->pkt_cdbp[0])); 9970 return (COMMAND_DONE_ERROR); 9971 } 9972 9973 switch (pkt->pkt_reason) { 9974 case CMD_INCOMPLETE: /* tran stopped with not normal state */ 9975 /* 9976 * this occurs when accessing a powered down drive, no 9977 * need to complain; just fail the open 9978 */ 9979 ST_CDB(ST_DEVINFO, "Incomplete CDB", (char *)pkt->pkt_cdbp); 9980 9981 /* 9982 * if we have commands outstanding in HBA, and a command 9983 * comes back incomplete, we're hosed, so reset target 9984 * If we have the bus, but cmd_incomplete, we probably just 9985 * have a failed selection, so don't reset the target, just 9986 * requeue the command and try again 9987 */ 9988 if ((un->un_ncmds > 1) || (pkt->pkt_state != STATE_GOT_BUS)) { 9989 goto reset_target; 9990 } 9991 9992 /* 9993 * Retry selection a couple more times if we're 9994 * open. If opening, we only try just once to 9995 * reduce probe time for nonexistant devices. 9996 */ 9997 if ((un->un_laststate > ST_STATE_OPENING) && 9998 (rinfo->pkt_retry_cnt < st_selection_retry_count)) { 9999 /* XXX check retriable? */ 10000 rval = QUE_COMMAND; 10001 } 10002 ST_DO_ERRSTATS(un, st_transerrs); 10003 break; 10004 10005 case CMD_ABORTED: 10006 /* 10007 * most likely this is caused by flush-on-error support. If 10008 * it was not there, the we're in trouble. 10009 */ 10010 if (!un->un_flush_on_errors) { 10011 un->un_status = SUN_KEY_FATAL; 10012 goto reset_target; 10013 } 10014 10015 st_set_pe_errno(un); 10016 bioerror(bp, un->un_errno); 10017 if (un->un_errno) 10018 return (COMMAND_DONE_ERROR); 10019 else 10020 return (COMMAND_DONE); 10021 10022 case CMD_TIMEOUT: /* Command timed out */ 10023 un->un_status = SUN_KEY_TIMEOUT; 10024 return (COMMAND_TIMEOUT); 10025 10026 case CMD_TRAN_ERR: 10027 case CMD_RESET: 10028 if (pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET)) { 10029 if ((un->un_rsvd_status & 10030 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 10031 ST_RESERVE) { 10032 un->un_rsvd_status |= ST_LOST_RESERVE; 10033 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 10034 "Lost Reservation\n"); 10035 } 10036 rval = DEVICE_RESET; 10037 return (rval); 10038 } 10039 if (pkt->pkt_statistics & (STAT_ABORTED | STAT_TERMINATED)) { 10040 rval = DEVICE_RESET; 10041 return (rval); 10042 } 10043 /*FALLTHROUGH*/ 10044 default: 10045 scsi_log(ST_DEVINFO, st_label, CE_WARN, 10046 "Unhandled packet status reason = %s statistics = 0x%x\n", 10047 scsi_rname(pkt->pkt_reason), pkt->pkt_statistics); 10048 reset_target: 10049 10050 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10051 "transport completed with %s\n", 10052 scsi_rname(pkt->pkt_reason)); 10053 ST_DO_ERRSTATS(un, st_transerrs); 10054 if ((pkt->pkt_state & STATE_GOT_TARGET) && 10055 ((pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET | 10056 STAT_ABORTED)) == 0)) { 10057 10058 /* 10059 * If we haven't reserved the drive don't reset it. 10060 */ 10061 if ((un->un_rsvd_status & 10062 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 10063 return (rval); 10064 } 10065 10066 /* 10067 * if we aren't lost yet we will be soon. 10068 */ 10069 un->un_pos.pmode = invalid; 10070 10071 result = st_reset(un, RESET_LUN); 10072 10073 if ((result == 0) && (un->un_state >= ST_STATE_OPEN)) { 10074 /* no hope left to recover */ 10075 scsi_log(ST_DEVINFO, st_label, CE_WARN, 10076 "recovery by resets failed\n"); 10077 return (rval); 10078 } 10079 } 10080 } 10081 10082 10083 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 10084 rval = QUE_COMMAND; 10085 } else if (bp == un->un_sbufp) { 10086 if (rinfo->privatelen == sizeof (recov_info)) { 10087 if (rinfo->cmd_attrib->retriable) { 10088 /* 10089 * These commands can be rerun 10090 * with impunity 10091 */ 10092 rval = QUE_COMMAND; 10093 } 10094 } else { 10095 cmd_attribute const *attrib; 10096 attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 10097 if (attrib->retriable) { 10098 rval = QUE_COMMAND; 10099 } 10100 } 10101 } 10102 10103 if (un->un_state >= ST_STATE_OPEN) { 10104 scsi_log(ST_DEVINFO, st_label, CE_WARN, 10105 fail, scsi_rname(pkt->pkt_reason), 10106 (rval == COMMAND_DONE_ERROR)? 10107 "giving up" : "retrying command"); 10108 } 10109 return (rval); 10110 } 10111 10112 /* 10113 * if the device is busy, then put this bp back on the waitq, on the 10114 * interrupt thread, where we want the head of the queue and not the 10115 * end 10116 * 10117 * The callers of this routine should take measures to save the 10118 * un_throttle in un_last_throttle which will be restored in 10119 * st_intr_restart(). The only exception should be st_intr_restart() 10120 * calling this routine for which the saving is already done. 10121 */ 10122 static int 10123 st_handle_intr_busy(struct scsi_tape *un, struct buf *bp, 10124 clock_t timeout_interval) 10125 { 10126 10127 int queued; 10128 int rval = 0; 10129 pkt_info *pktinfo = BP_PKT(bp)->pkt_private; 10130 10131 mutex_enter(ST_MUTEX); 10132 10133 ST_FUNC(ST_DEVINFO, st_handle_intr_busy); 10134 10135 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10136 "st_handle_intr_busy(), un = 0x%p\n", (void *)un); 10137 10138 if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) { 10139 queued = 1; 10140 } else { 10141 queued = 0; 10142 } 10143 10144 /* 10145 * Check to see if we hit the retry timeout. We check to make sure 10146 * this is the first one on the runq and make sure we have not 10147 * queued up any more, so this one has to be the last on the list 10148 * also. If it is not, we have to fail. If it is not the first, but 10149 * is the last we are in trouble anyway, as we are in the interrupt 10150 * context here. 10151 */ 10152 if ((pktinfo->str_retry_cnt++ > st_retry_count) || 10153 ((un->un_runqf != bp) && (un->un_runql != bp) && (queued))) { 10154 rval = -1; 10155 goto exit; 10156 } 10157 10158 /* put the bp back on the waitq */ 10159 if (queued) { 10160 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 10161 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quef, bp); 10162 } 10163 10164 /* 10165 * We don't want any other commands being started in the mean time. 10166 * If start had just released mutex after putting something on the 10167 * runq, we won't even get here. 10168 */ 10169 un->un_throttle = 0; 10170 10171 /* 10172 * send a marker pkt, if appropriate 10173 */ 10174 st_hba_unflush(un); 10175 10176 /* 10177 * all queues are aligned, we are just waiting to 10178 * transport 10179 */ 10180 un->un_hib_tid = timeout(st_intr_restart, un, timeout_interval); 10181 10182 exit: 10183 mutex_exit(ST_MUTEX); 10184 return (rval); 10185 } 10186 10187 /* 10188 * To get one error entry from error stack 10189 */ 10190 static int 10191 st_get_error_entry(struct scsi_tape *un, intptr_t arg, int flag) 10192 { 10193 #ifdef _MULTI_DATAMODEL 10194 /* 10195 * For use when a 32 bit app makes a call into a 10196 * 64 bit ioctl 10197 */ 10198 struct mterror_entry32 err_entry32; 10199 #endif /* _MULTI_DATAMODEL */ 10200 10201 int rval = 0; 10202 struct mterror_entry err_entry; 10203 struct mterror_entry_stack *err_link_entry_p; 10204 size_t arq_status_len_in, arq_status_len_kr; 10205 10206 ST_FUNC(ST_DEVINFO, st_get_error_entry); 10207 10208 ASSERT(mutex_owned(ST_MUTEX)); 10209 10210 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10211 "st_get_error_entry()\n"); 10212 10213 /* 10214 * if error record stack empty, return ENXIO 10215 */ 10216 if (un->un_error_entry_stk == NULL) { 10217 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10218 "st_get_error_entry: Error Entry Stack Empty!\n"); 10219 rval = ENXIO; 10220 goto ret; 10221 } 10222 10223 /* 10224 * get the top entry from stack 10225 */ 10226 err_link_entry_p = un->un_error_entry_stk; 10227 arq_status_len_kr = 10228 err_link_entry_p->mtees_entry.mtee_arq_status_len; 10229 10230 #ifdef _MULTI_DATAMODEL 10231 switch (ddi_model_convert_from(flag & FMODELS)) { 10232 case DDI_MODEL_ILP32: 10233 if (ddi_copyin((void *)arg, &err_entry32, 10234 MTERROR_ENTRY_SIZE_32, flag)) { 10235 rval = EFAULT; 10236 goto ret; 10237 } 10238 10239 arq_status_len_in = 10240 (size_t)err_entry32.mtee_arq_status_len; 10241 10242 err_entry32.mtee_cdb_len = 10243 (size32_t)err_link_entry_p->mtees_entry.mtee_cdb_len; 10244 10245 if (arq_status_len_in > arq_status_len_kr) 10246 err_entry32.mtee_arq_status_len = 10247 (size32_t)arq_status_len_kr; 10248 10249 if (ddi_copyout( 10250 err_link_entry_p->mtees_entry.mtee_cdb_buf, 10251 (void *)(uintptr_t)err_entry32.mtee_cdb_buf, 10252 err_entry32.mtee_cdb_len, flag)) { 10253 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10254 "st_get_error_entry: Copy cdb buffer error!"); 10255 rval = EFAULT; 10256 } 10257 10258 if (ddi_copyout( 10259 err_link_entry_p->mtees_entry.mtee_arq_status, 10260 (void *)(uintptr_t)err_entry32.mtee_arq_status, 10261 err_entry32.mtee_arq_status_len, flag)) { 10262 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10263 "st_get_error_entry: copy arq status error!"); 10264 rval = EFAULT; 10265 } 10266 10267 if (ddi_copyout(&err_entry32, (void *)arg, 10268 MTERROR_ENTRY_SIZE_32, flag)) { 10269 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10270 "st_get_error_entry: copy arq status out error!"); 10271 rval = EFAULT; 10272 } 10273 break; 10274 10275 case DDI_MODEL_NONE: 10276 if (ddi_copyin((void *)arg, &err_entry, 10277 MTERROR_ENTRY_SIZE_64, flag)) { 10278 rval = EFAULT; 10279 goto ret; 10280 } 10281 arq_status_len_in = err_entry.mtee_arq_status_len; 10282 10283 err_entry.mtee_cdb_len = 10284 err_link_entry_p->mtees_entry.mtee_cdb_len; 10285 10286 if (arq_status_len_in > arq_status_len_kr) 10287 err_entry.mtee_arq_status_len = 10288 arq_status_len_kr; 10289 10290 if (ddi_copyout( 10291 err_link_entry_p->mtees_entry.mtee_cdb_buf, 10292 err_entry.mtee_cdb_buf, 10293 err_entry.mtee_cdb_len, flag)) { 10294 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10295 "st_get_error_entry: Copy cdb buffer error!"); 10296 rval = EFAULT; 10297 } 10298 10299 if (ddi_copyout( 10300 err_link_entry_p->mtees_entry.mtee_arq_status, 10301 err_entry.mtee_arq_status, 10302 err_entry.mtee_arq_status_len, flag)) { 10303 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10304 "st_get_error_entry: copy arq status error!"); 10305 rval = EFAULT; 10306 } 10307 10308 if (ddi_copyout(&err_entry, (void *)arg, 10309 MTERROR_ENTRY_SIZE_64, flag)) { 10310 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10311 "st_get_error_entry: copy arq status out error!"); 10312 rval = EFAULT; 10313 } 10314 break; 10315 } 10316 #else /* _MULTI_DATAMODEL */ 10317 if (ddi_copyin((void *)arg, &err_entry, 10318 MTERROR_ENTRY_SIZE_64, flag)) { 10319 rval = EFAULT; 10320 goto ret; 10321 } 10322 arq_status_len_in = err_entry.mtee_arq_status_len; 10323 10324 err_entry.mtee_cdb_len = 10325 err_link_entry_p->mtees_entry.mtee_cdb_len; 10326 10327 if (arq_status_len_in > arq_status_len_kr) 10328 err_entry.mtee_arq_status_len = 10329 arq_status_len_kr; 10330 10331 if (ddi_copyout( 10332 err_link_entry_p->mtees_entry.mtee_cdb_buf, 10333 err_entry.mtee_cdb_buf, 10334 err_entry.mtee_cdb_len, flag)) { 10335 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10336 "st_get_error_entry: Copy cdb buffer error!"); 10337 rval = EFAULT; 10338 } 10339 10340 if (ddi_copyout( 10341 err_link_entry_p->mtees_entry.mtee_arq_status, 10342 err_entry.mtee_arq_status, 10343 err_entry.mtee_arq_status_len, flag)) { 10344 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10345 "st_get_error_entry: copy arq status buffer error!"); 10346 rval = EFAULT; 10347 } 10348 10349 if (ddi_copyout(&err_entry, (void *)arg, 10350 MTERROR_ENTRY_SIZE_64, flag)) { 10351 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10352 "st_get_error_entry: copy arq status out error!"); 10353 rval = EFAULT; 10354 } 10355 #endif /* _MULTI_DATAMODEL */ 10356 10357 /* 10358 * update stack 10359 */ 10360 un->un_error_entry_stk = err_link_entry_p->mtees_nextp; 10361 10362 kmem_free(err_link_entry_p->mtees_entry.mtee_cdb_buf, 10363 err_link_entry_p->mtees_entry.mtee_cdb_len); 10364 err_link_entry_p->mtees_entry.mtee_cdb_buf = NULL; 10365 10366 kmem_free(err_link_entry_p->mtees_entry.mtee_arq_status, 10367 SECMDS_STATUS_SIZE); 10368 err_link_entry_p->mtees_entry.mtee_arq_status = NULL; 10369 10370 kmem_free(err_link_entry_p, MTERROR_LINK_ENTRY_SIZE); 10371 err_link_entry_p = NULL; 10372 ret: 10373 return (rval); 10374 } 10375 10376 /* 10377 * MTIOCGETERROR ioctl needs to retrieve the current sense data along with 10378 * the scsi CDB command which causes the error and generates sense data and 10379 * the scsi status. 10380 * 10381 * error-record stack 10382 * 10383 * 10384 * TOP BOTTOM 10385 * ------------------------------------------ 10386 * | 0 | 1 | 2 | ... | n | 10387 * ------------------------------------------ 10388 * ^ 10389 * | 10390 * pointer to error entry 10391 * 10392 * when st driver generates one sense data record, it creates a error-entry 10393 * and pushes it onto the stack. 10394 * 10395 */ 10396 10397 static void 10398 st_update_error_stack(struct scsi_tape *un, 10399 struct scsi_pkt *pkt, 10400 struct scsi_arq_status *cmd) 10401 { 10402 struct mterror_entry_stack *err_entry_tmp; 10403 uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp; 10404 size_t cdblen = scsi_cdb_size[CDB_GROUPID(cdbp[0])]; 10405 10406 ST_FUNC(ST_DEVINFO, st_update_error_stack); 10407 10408 ASSERT(mutex_owned(ST_MUTEX)); 10409 10410 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10411 "st_update_error_stack()\n"); 10412 10413 ASSERT(cmd); 10414 ASSERT(cdbp); 10415 if (cdblen == 0) { 10416 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10417 "st_update_error_stack: CDB length error!\n"); 10418 return; 10419 } 10420 10421 err_entry_tmp = kmem_alloc(MTERROR_LINK_ENTRY_SIZE, KM_SLEEP); 10422 ASSERT(err_entry_tmp != NULL); 10423 10424 err_entry_tmp->mtees_entry.mtee_cdb_buf = 10425 kmem_alloc(cdblen, KM_SLEEP); 10426 ASSERT(err_entry_tmp->mtees_entry.mtee_cdb_buf != NULL); 10427 10428 err_entry_tmp->mtees_entry.mtee_arq_status = 10429 kmem_alloc(SECMDS_STATUS_SIZE, KM_SLEEP); 10430 ASSERT(err_entry_tmp->mtees_entry.mtee_arq_status != NULL); 10431 10432 /* 10433 * copy cdb command & length to current error entry 10434 */ 10435 err_entry_tmp->mtees_entry.mtee_cdb_len = cdblen; 10436 bcopy(cdbp, err_entry_tmp->mtees_entry.mtee_cdb_buf, cdblen); 10437 10438 /* 10439 * copy scsi status length to current error entry 10440 */ 10441 err_entry_tmp->mtees_entry.mtee_arq_status_len = 10442 SECMDS_STATUS_SIZE; 10443 10444 /* 10445 * copy sense data and scsi status to current error entry 10446 */ 10447 bcopy(cmd, err_entry_tmp->mtees_entry.mtee_arq_status, 10448 SECMDS_STATUS_SIZE); 10449 10450 err_entry_tmp->mtees_nextp = un->un_error_entry_stk; 10451 un->un_error_entry_stk = err_entry_tmp; 10452 10453 } 10454 10455 /* 10456 * Empty all the error entry in stack 10457 */ 10458 static void 10459 st_empty_error_stack(struct scsi_tape *un) 10460 { 10461 struct mterror_entry_stack *linkp; 10462 10463 ST_FUNC(ST_DEVINFO, st_empty_error_stack); 10464 10465 ASSERT(mutex_owned(ST_MUTEX)); 10466 10467 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10468 "st_empty_entry_stack()\n"); 10469 10470 while (un->un_error_entry_stk != NULL) { 10471 linkp = un->un_error_entry_stk; 10472 un->un_error_entry_stk = 10473 un->un_error_entry_stk->mtees_nextp; 10474 10475 if (linkp->mtees_entry.mtee_cdb_buf != NULL) 10476 kmem_free(linkp->mtees_entry.mtee_cdb_buf, 10477 linkp->mtees_entry.mtee_cdb_len); 10478 10479 if (linkp->mtees_entry.mtee_arq_status != NULL) 10480 kmem_free(linkp->mtees_entry.mtee_arq_status, 10481 linkp->mtees_entry.mtee_arq_status_len); 10482 10483 kmem_free(linkp, MTERROR_LINK_ENTRY_SIZE); 10484 linkp = NULL; 10485 } 10486 } 10487 10488 static errstate 10489 st_handle_sense(struct scsi_tape *un, struct buf *bp, tapepos_t *pos) 10490 { 10491 struct scsi_pkt *pkt = BP_PKT(bp); 10492 struct scsi_pkt *rqpkt = un->un_rqs; 10493 struct scsi_arq_status arqstat; 10494 recov_info *rcif = pkt->pkt_private; 10495 10496 errstate rval = COMMAND_DONE_ERROR; 10497 int amt; 10498 10499 ST_FUNC(ST_DEVINFO, st_handle_sense); 10500 10501 ASSERT(mutex_owned(ST_MUTEX)); 10502 10503 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10504 "st_handle_sense()\n"); 10505 10506 if (SCBP(rqpkt)->sts_busy) { 10507 if (rcif->privatelen == sizeof (recov_info)) { 10508 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 10509 "Attempt recovery of busy unit on request sense\n"); 10510 rval = ATTEMPT_RETRY; 10511 } else if (rcif->pkt_retry_cnt++ < st_retry_count) { 10512 ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN, 10513 "Retry busy unit on request sense\n"); 10514 rval = QUE_BUSY_COMMAND; 10515 } 10516 return (rval); 10517 } else if (SCBP(rqpkt)->sts_chk) { 10518 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10519 "Check Condition on REQUEST SENSE\n"); 10520 return (rval); 10521 } 10522 10523 /* 10524 * Make sure there is sense data to look at. 10525 */ 10526 if ((rqpkt->pkt_state & (STATE_GOT_BUS | STATE_GOT_TARGET | 10527 STATE_SENT_CMD | STATE_GOT_STATUS)) != (STATE_GOT_BUS | 10528 STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS)) { 10529 return (rval); 10530 } 10531 10532 /* was there enough data? */ 10533 amt = (int)MAX_SENSE_LENGTH - rqpkt->pkt_resid; 10534 if ((rqpkt->pkt_state & STATE_XFERRED_DATA) == 0 || 10535 (amt < SUN_MIN_SENSE_LENGTH)) { 10536 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10537 "REQUEST SENSE couldn't get sense data\n"); 10538 return (rval); 10539 } 10540 10541 bcopy(SCBP(pkt), &arqstat.sts_status, 10542 sizeof (struct scsi_status)); 10543 bcopy(SCBP(rqpkt), &arqstat.sts_rqpkt_status, 10544 sizeof (struct scsi_status)); 10545 arqstat.sts_rqpkt_reason = rqpkt->pkt_reason; 10546 arqstat.sts_rqpkt_resid = rqpkt->pkt_resid; 10547 arqstat.sts_rqpkt_state = rqpkt->pkt_state; 10548 arqstat.sts_rqpkt_statistics = rqpkt->pkt_statistics; 10549 bcopy(ST_RQSENSE, &arqstat.sts_sensedata, SENSE_LENGTH); 10550 10551 /* 10552 * copy one arqstat entry in the sense data buffer 10553 */ 10554 st_update_error_stack(un, pkt, &arqstat); 10555 return (st_decode_sense(un, bp, amt, &arqstat, pos)); 10556 } 10557 10558 static errstate 10559 st_handle_autosense(struct scsi_tape *un, struct buf *bp, tapepos_t *pos) 10560 { 10561 struct scsi_pkt *pkt = BP_PKT(bp); 10562 struct scsi_arq_status *arqstat = 10563 (struct scsi_arq_status *)pkt->pkt_scbp; 10564 errstate rval = COMMAND_DONE_ERROR; 10565 int amt; 10566 10567 ST_FUNC(ST_DEVINFO, st_handle_autosense); 10568 10569 ASSERT(mutex_owned(ST_MUTEX)); 10570 10571 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10572 "st_handle_autosense()\n"); 10573 10574 if (arqstat->sts_rqpkt_status.sts_busy) { 10575 ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN, 10576 "busy unit on request sense\n"); 10577 /* 10578 * we return QUE_SENSE so st_intr will setup the SENSE cmd. 10579 * the disadvantage is that we do not have any delay for the 10580 * second retry of rqsense and we have to keep a packet around 10581 */ 10582 return (QUE_SENSE); 10583 10584 } else if (arqstat->sts_rqpkt_reason != CMD_CMPLT) { 10585 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10586 "transport error on REQUEST SENSE\n"); 10587 if ((arqstat->sts_rqpkt_state & STATE_GOT_TARGET) && 10588 ((arqstat->sts_rqpkt_statistics & 10589 (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) == 0)) { 10590 if (st_reset(un, RESET_LUN) == 0) { 10591 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10592 "recovery by resets failed\n"); 10593 } 10594 } 10595 return (rval); 10596 10597 } else if (arqstat->sts_rqpkt_status.sts_chk) { 10598 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10599 "Check Condition on REQUEST SENSE\n"); 10600 return (rval); 10601 } 10602 10603 10604 /* was there enough data? */ 10605 if (pkt->pkt_state & STATE_XARQ_DONE) { 10606 amt = (int)MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10607 } else { 10608 if (arqstat->sts_rqpkt_resid > SENSE_LENGTH) { 10609 amt = (int)MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10610 } else { 10611 amt = (int)SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10612 } 10613 } 10614 if ((arqstat->sts_rqpkt_state & STATE_XFERRED_DATA) == 0 || 10615 (amt < SUN_MIN_SENSE_LENGTH)) { 10616 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10617 "REQUEST SENSE couldn't get sense data\n"); 10618 return (rval); 10619 } 10620 10621 if (pkt->pkt_state & STATE_XARQ_DONE) { 10622 bcopy(&arqstat->sts_sensedata, ST_RQSENSE, MAX_SENSE_LENGTH); 10623 } else { 10624 bcopy(&arqstat->sts_sensedata, ST_RQSENSE, SENSE_LENGTH); 10625 } 10626 10627 /* 10628 * copy one arqstat entry in the sense data buffer 10629 */ 10630 st_update_error_stack(un, pkt, arqstat); 10631 10632 return (st_decode_sense(un, bp, amt, arqstat, pos)); 10633 } 10634 10635 static errstate 10636 st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt, 10637 struct scsi_arq_status *statusp, tapepos_t *pos) 10638 { 10639 struct scsi_pkt *pkt = BP_PKT(bp); 10640 recov_info *ri = pkt->pkt_private; 10641 errstate rval = COMMAND_DONE_ERROR; 10642 cmd_attribute const *attrib; 10643 long resid; 10644 struct scsi_extended_sense *sensep = ST_RQSENSE; 10645 int severity; 10646 int get_error; 10647 10648 ST_FUNC(ST_DEVINFO, st_decode_sense); 10649 10650 ASSERT(mutex_owned(ST_MUTEX)); 10651 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10652 "st_decode_sense()\n"); 10653 10654 /* 10655 * For uscsi commands, squirrel away a copy of the 10656 * results of the Request Sense. 10657 */ 10658 if (USCSI_CMD(bp)) { 10659 struct uscsi_cmd *ucmd = BP_UCMD(bp); 10660 ucmd->uscsi_rqstatus = *(uchar_t *)statusp; 10661 if (ucmd->uscsi_rqlen && un->un_srqbufp) { 10662 uchar_t rqlen = min((uchar_t)amt, ucmd->uscsi_rqlen); 10663 ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen; 10664 bcopy(ST_RQSENSE, un->un_srqbufp, rqlen); 10665 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10666 "st_decode_sense: stat=0x%x resid=0x%x\n", 10667 ucmd->uscsi_rqstatus, ucmd->uscsi_rqresid); 10668 } 10669 } 10670 10671 if (ri->privatelen == sizeof (recov_info)) { 10672 attrib = ri->cmd_attrib; 10673 } else { 10674 attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 10675 } 10676 10677 /* 10678 * If the drive is an MT-02, reposition the 10679 * secondary error code into the proper place. 10680 * 10681 * XXX MT-02 is non-CCS tape, so secondary error code 10682 * is in byte 8. However, in SCSI-2, tape has CCS definition 10683 * so it's in byte 12. 10684 */ 10685 if (un->un_dp->type == ST_TYPE_EMULEX) { 10686 sensep->es_code = sensep->es_add_info[0]; 10687 } 10688 10689 ST_CDB(ST_DEVINFO, "st_decode_sense failed CDB", 10690 (caddr_t)&CDBP(pkt)->scc_cmd); 10691 10692 ST_SENSE(ST_DEVINFO, "st_decode_sense sense data", (caddr_t)statusp, 10693 sizeof (*statusp)); 10694 10695 /* for normal I/O check extract the resid values. */ 10696 if (bp != un->un_sbufp && bp != un->un_recov_buf) { 10697 if (sensep->es_valid) { 10698 resid = 10699 (sensep->es_info_1 << 24) | 10700 (sensep->es_info_2 << 16) | 10701 (sensep->es_info_3 << 8) | 10702 (sensep->es_info_4); 10703 /* If fixed block */ 10704 if (un->un_bsize) { 10705 resid *= un->un_bsize; 10706 } 10707 } else if (pkt->pkt_state & STATE_XFERRED_DATA) { 10708 resid = pkt->pkt_resid; 10709 } else { 10710 resid = bp->b_bcount; 10711 } 10712 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10713 "st_decode_sense (rw): xferred bit = %d, resid=%ld (%d), " 10714 "pkt_resid=%ld\n", pkt->pkt_state & STATE_XFERRED_DATA, 10715 resid, 10716 (sensep->es_info_1 << 24) | 10717 (sensep->es_info_2 << 16) | 10718 (sensep->es_info_3 << 8) | 10719 (sensep->es_info_4), 10720 pkt->pkt_resid); 10721 /* 10722 * The problem is, what should we believe? 10723 */ 10724 if (resid && (pkt->pkt_resid == 0)) { 10725 pkt->pkt_resid = resid; 10726 } 10727 } else { 10728 /* 10729 * If the command is SCMD_SPACE, we need to get the 10730 * residual as returned in the sense data, to adjust 10731 * our idea of current tape position correctly 10732 */ 10733 if ((sensep->es_valid) && 10734 (CDBP(pkt)->scc_cmd == SCMD_LOCATE) || 10735 (CDBP(pkt)->scc_cmd == SCMD_LOCATE_G4) || 10736 (CDBP(pkt)->scc_cmd == SCMD_SPACE) || 10737 (CDBP(pkt)->scc_cmd == SCMD_SPACE_G4) || 10738 (CDBP(pkt)->scc_cmd == SCMD_WRITE_FILE_MARK)) { 10739 resid = 10740 (sensep->es_info_1 << 24) | 10741 (sensep->es_info_2 << 16) | 10742 (sensep->es_info_3 << 8) | 10743 (sensep->es_info_4); 10744 bp->b_resid = resid; 10745 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10746 "st_decode_sense(other): resid=%ld\n", resid); 10747 } else { 10748 /* 10749 * If the special command is SCMD_READ, 10750 * the correct resid will be set later. 10751 */ 10752 if (attrib->get_cnt != NULL) { 10753 resid = attrib->get_cnt(pkt->pkt_cdbp); 10754 } else { 10755 resid = bp->b_bcount; 10756 } 10757 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10758 "st_decode_sense(special read): resid=%ld\n", 10759 resid); 10760 } 10761 } 10762 10763 if ((un->un_state >= ST_STATE_OPEN) && 10764 (DEBUGGING || st_error_level == SCSI_ERR_ALL)) { 10765 st_print_cdb(ST_DEVINFO, st_label, CE_NOTE, 10766 "Failed CDB", (char *)pkt->pkt_cdbp); 10767 st_clean_print(ST_DEVINFO, st_label, CE_CONT, 10768 "sense data", (char *)sensep, amt); 10769 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10770 "count 0x%lx resid 0x%lx pktresid 0x%lx\n", 10771 bp->b_bcount, resid, pkt->pkt_resid); 10772 } 10773 10774 switch (un->un_status = sensep->es_key) { 10775 case KEY_NO_SENSE: 10776 severity = SCSI_ERR_INFO; 10777 10778 /* 10779 * Erase, locate or rewind operation in progress, retry 10780 * ASC ASCQ 10781 * 00 18 Erase operation in progress 10782 * 00 19 Locate operation in progress 10783 * 00 1A Rewind operation in progress 10784 */ 10785 if (sensep->es_add_code == 0 && 10786 ((sensep->es_qual_code == 0x18) || 10787 (sensep->es_qual_code == 0x19) || 10788 (sensep->es_qual_code == 0x1a))) { 10789 rval = QUE_BUSY_COMMAND; 10790 break; 10791 } 10792 10793 goto common; 10794 10795 case KEY_RECOVERABLE_ERROR: 10796 severity = SCSI_ERR_RECOVERED; 10797 if ((sensep->es_class == CLASS_EXTENDED_SENSE) && 10798 (sensep->es_code == ST_DEFERRED_ERROR)) { 10799 if (un->un_dp->options & 10800 ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) { 10801 rval = QUE_LAST_COMMAND; 10802 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, 10803 severity, pos->lgclblkno, 10804 un->un_err_pos.lgclblkno, scsi_cmds, 10805 sensep); 10806 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10807 "Command will be retried\n"); 10808 } else { 10809 severity = SCSI_ERR_FATAL; 10810 rval = COMMAND_DONE_ERROR_RECOVERED; 10811 ST_DO_ERRSTATS(un, st_softerrs); 10812 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, 10813 severity, pos->lgclblkno, 10814 un->un_err_pos.lgclblkno, scsi_cmds, 10815 sensep); 10816 } 10817 break; 10818 } 10819 common: 10820 /* 10821 * XXX only want reads to be stopped by filemarks. 10822 * Don't want them to be stopped by EOT. EOT matters 10823 * only on write. 10824 */ 10825 if (sensep->es_filmk && !sensep->es_eom) { 10826 rval = COMMAND_DONE; 10827 } else if (sensep->es_eom) { 10828 rval = COMMAND_DONE; 10829 } else if (sensep->es_ili) { 10830 /* 10831 * Fun with variable length record devices: 10832 * for specifying larger blocks sizes than the 10833 * actual physical record size. 10834 */ 10835 if (un->un_bsize == 0 && resid > 0) { 10836 /* 10837 * XXX! Ugly. 10838 * The requested blocksize is > tape blocksize, 10839 * so this is ok, so we just return the 10840 * actual size xferred. 10841 */ 10842 pkt->pkt_resid = resid; 10843 rval = COMMAND_DONE; 10844 } else if (un->un_bsize == 0 && resid < 0) { 10845 /* 10846 * The requested blocksize is < tape blocksize, 10847 * so this is not ok, so we err with ENOMEM 10848 */ 10849 rval = COMMAND_DONE_ERROR_RECOVERED; 10850 st_bioerror(bp, ENOMEM); 10851 } else { 10852 ST_DO_ERRSTATS(un, st_softerrs); 10853 severity = SCSI_ERR_FATAL; 10854 rval = COMMAND_DONE_ERROR; 10855 st_bioerror(bp, EINVAL); 10856 un->un_running.pmode = invalid; 10857 } 10858 } else { 10859 /* 10860 * we hope and pray for this just being 10861 * something we can ignore (ie. a 10862 * truly recoverable soft error) 10863 */ 10864 rval = COMMAND_DONE; 10865 } 10866 if (sensep->es_filmk) { 10867 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10868 "filemark\n"); 10869 un->un_status = SUN_KEY_EOF; 10870 pos->eof = ST_EOF_PENDING; 10871 st_set_pe_flag(un); 10872 } 10873 10874 /* 10875 * ignore eom when reading, a fmk should terminate reading 10876 */ 10877 if ((sensep->es_eom) && 10878 (CDBP(pkt)->scc_cmd != SCMD_READ)) { 10879 if ((sensep->es_add_code == 0) && 10880 (sensep->es_qual_code == 4)) { 10881 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10882 "bot\n"); 10883 un->un_status = SUN_KEY_BOT; 10884 pos->eof = ST_NO_EOF; 10885 pos->lgclblkno = 0; 10886 pos->fileno = 0; 10887 pos->blkno = 0; 10888 if (pos->pmode != legacy) 10889 pos->pmode = legacy; 10890 } else { 10891 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10892 "eom\n"); 10893 un->un_status = SUN_KEY_EOT; 10894 pos->eof = ST_EOM; 10895 } 10896 st_set_pe_flag(un); 10897 } 10898 10899 break; 10900 10901 case KEY_ILLEGAL_REQUEST: 10902 10903 if (un->un_laststate >= ST_STATE_OPEN) { 10904 ST_DO_ERRSTATS(un, st_softerrs); 10905 severity = SCSI_ERR_FATAL; 10906 } else { 10907 severity = SCSI_ERR_INFO; 10908 } 10909 break; 10910 10911 case KEY_MEDIUM_ERROR: 10912 ST_DO_ERRSTATS(un, st_harderrs); 10913 severity = SCSI_ERR_FATAL; 10914 un->un_pos.pmode = invalid; 10915 un->un_running.pmode = invalid; 10916 check_keys: 10917 /* 10918 * attempt to process the keys in the presence of 10919 * other errors 10920 */ 10921 if (sensep->es_ili && rval != COMMAND_DONE_ERROR) { 10922 /* 10923 * Fun with variable length record devices: 10924 * for specifying larger blocks sizes than the 10925 * actual physical record size. 10926 */ 10927 if (un->un_bsize == 0 && resid > 0) { 10928 /* 10929 * XXX! Ugly 10930 */ 10931 pkt->pkt_resid = resid; 10932 } else if (un->un_bsize == 0 && resid < 0) { 10933 st_bioerror(bp, EINVAL); 10934 } else { 10935 severity = SCSI_ERR_FATAL; 10936 rval = COMMAND_DONE_ERROR; 10937 st_bioerror(bp, EINVAL); 10938 } 10939 } 10940 if (sensep->es_filmk) { 10941 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10942 "filemark\n"); 10943 un->un_status = SUN_KEY_EOF; 10944 pos->eof = ST_EOF_PENDING; 10945 st_set_pe_flag(un); 10946 } 10947 10948 /* 10949 * ignore eom when reading, a fmk should terminate reading 10950 */ 10951 if ((sensep->es_eom) && 10952 (CDBP(pkt)->scc_cmd != SCMD_READ)) { 10953 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "eom\n"); 10954 un->un_status = SUN_KEY_EOT; 10955 pos->eof = ST_EOM; 10956 st_set_pe_flag(un); 10957 } 10958 10959 break; 10960 10961 case KEY_VOLUME_OVERFLOW: 10962 ST_DO_ERRSTATS(un, st_softerrs); 10963 pos->eof = ST_EOM; 10964 severity = SCSI_ERR_FATAL; 10965 rval = COMMAND_DONE_ERROR; 10966 goto check_keys; 10967 10968 case KEY_HARDWARE_ERROR: 10969 ST_DO_ERRSTATS(un, st_harderrs); 10970 severity = SCSI_ERR_FATAL; 10971 rval = COMMAND_DONE_ERROR; 10972 if (un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) 10973 un->un_eject_tape_on_failure = st_check_asc_ascq(un); 10974 break; 10975 10976 case KEY_BLANK_CHECK: 10977 ST_DO_ERRSTATS(un, st_softerrs); 10978 severity = SCSI_ERR_INFO; 10979 10980 /* 10981 * if not a special request and some data was xferred then it 10982 * it is not an error yet 10983 */ 10984 if (bp != un->un_sbufp && (bp->b_flags & B_READ)) { 10985 /* 10986 * no error for read with or without data xferred 10987 */ 10988 un->un_status = SUN_KEY_EOT; 10989 pos->eof = ST_EOT; 10990 rval = COMMAND_DONE_ERROR; 10991 un->un_running.pmode = invalid; 10992 st_set_pe_flag(un); 10993 goto check_keys; 10994 } else if (bp != un->un_sbufp && 10995 (pkt->pkt_state & STATE_XFERRED_DATA)) { 10996 rval = COMMAND_DONE; 10997 } else { 10998 rval = COMMAND_DONE_ERROR_RECOVERED; 10999 } 11000 11001 if (un->un_laststate >= ST_STATE_OPEN) { 11002 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11003 "blank check\n"); 11004 pos->eof = ST_EOM; 11005 } 11006 if ((CDBP(pkt)->scc_cmd == SCMD_LOCATE) || 11007 (CDBP(pkt)->scc_cmd == SCMD_LOCATE_G4) || 11008 (CDBP(pkt)->scc_cmd == SCMD_SPACE) && 11009 (un->un_dp->options & ST_KNOWS_EOD)) { 11010 /* 11011 * we were doing a fast forward by skipping 11012 * multiple fmk at the time 11013 */ 11014 st_bioerror(bp, EIO); 11015 severity = SCSI_ERR_RECOVERED; 11016 rval = COMMAND_DONE; 11017 } 11018 st_set_pe_flag(un); 11019 goto check_keys; 11020 11021 case KEY_WRITE_PROTECT: 11022 if (st_wrongtapetype(un)) { 11023 un->un_status = SUN_KEY_WRONGMEDIA; 11024 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11025 "wrong tape for writing- use DC6150 tape " 11026 "(or equivalent)\n"); 11027 severity = SCSI_ERR_UNKNOWN; 11028 } else { 11029 severity = SCSI_ERR_FATAL; 11030 } 11031 ST_DO_ERRSTATS(un, st_harderrs); 11032 rval = COMMAND_DONE_ERROR; 11033 st_bioerror(bp, EACCES); 11034 break; 11035 11036 case KEY_UNIT_ATTENTION: 11037 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11038 "KEY_UNIT_ATTENTION : un_state = %d\n", un->un_state); 11039 11040 un->un_unit_attention_flags |= 1; 11041 /* 11042 * If we have detected a Bus Reset and the tape 11043 * drive has been reserved. 11044 */ 11045 if (ST_RQSENSE->es_add_code == 0x29) { 11046 rval = DEVICE_RESET; 11047 if ((un->un_rsvd_status & 11048 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 11049 ST_RESERVE) { 11050 un->un_rsvd_status |= ST_LOST_RESERVE; 11051 ST_DEBUG(ST_DEVINFO, st_label, CE_WARN, 11052 "st_decode_sense: Lost Reservation\n"); 11053 } 11054 } 11055 11056 /* 11057 * If this is a recovery command and retrable, retry. 11058 */ 11059 if (bp == un->un_recov_buf) { 11060 severity = SCSI_ERR_INFO; 11061 if (attrib->retriable && 11062 ri->pkt_retry_cnt++ < st_retry_count) { 11063 rval = QUE_COMMAND; 11064 } else { 11065 rval = COMMAND_DONE_ERROR; 11066 } 11067 break; /* Don't set position invalid */ 11068 } 11069 11070 /* 11071 * If ST_APPLICATION_RESERVATIONS is set, 11072 * If the asc/ascq indicates that the reservation 11073 * has been cleared just allow the write to continue 11074 * which would force a scsi 2 reserve. 11075 * If preempted that persistent reservation 11076 * the scsi 2 reserve would get a reservation conflict. 11077 */ 11078 if ((un->un_rsvd_status & 11079 ST_APPLICATION_RESERVATIONS) != 0) { 11080 /* 11081 * RESERVATIONS PREEMPTED 11082 * With MPxIO this could be a fail over? XXX 11083 */ 11084 if (ST_RQSENSE->es_add_code == 0x2a && 11085 ST_RQSENSE->es_qual_code == 0x03) { 11086 severity = SCSI_ERR_INFO; 11087 rval = COMMAND_DONE_ERROR; 11088 pos->pmode = invalid; 11089 break; 11090 /* 11091 * RESERVATIONS RELEASED 11092 */ 11093 } else if (ST_RQSENSE->es_add_code == 0x2a && 11094 ST_RQSENSE->es_qual_code == 0x04) { 11095 severity = SCSI_ERR_INFO; 11096 rval = COMMAND_DONE; 11097 break; 11098 } 11099 } 11100 11101 if (un->un_state <= ST_STATE_OPENING) { 11102 /* 11103 * Look, the tape isn't open yet, now determine 11104 * if the cause is a BUS RESET, Save the file 11105 * and Block positions for the callers to 11106 * recover from the loss of position. 11107 */ 11108 severity = SCSI_ERR_INFO; 11109 if ((pos->pmode != invalid) && 11110 (rval == DEVICE_RESET) && 11111 (un->un_restore_pos != 1)) { 11112 un->un_save_fileno = pos->fileno; 11113 un->un_save_blkno = pos->blkno; 11114 un->un_restore_pos = 1; 11115 } 11116 11117 if (attrib->retriable && 11118 ri->pkt_retry_cnt++ < st_retry_count) { 11119 rval = QUE_COMMAND; 11120 } else if (rval == DEVICE_RESET) { 11121 break; 11122 } else { 11123 rval = COMMAND_DONE_ERROR; 11124 } 11125 /* 11126 * Means it thinks the mode parameters have changed. 11127 * This is the result of a reset clearing settings or 11128 * another initiator changing what we set. 11129 */ 11130 } 11131 if (ST_RQSENSE->es_add_code == 0x2a) { 11132 if (ST_RQSENSE->es_qual_code == 0x1) { 11133 /* Error recovery will modeselect and retry. */ 11134 rval = DEVICE_TAMPER; 11135 severity = SCSI_ERR_INFO; 11136 break; /* don't set position invalid */ 11137 } 11138 if (ST_RQSENSE->es_qual_code == 0x0 || 11139 ST_RQSENSE->es_qual_code == 0x2 || 11140 ST_RQSENSE->es_qual_code == 0x3 || 11141 ST_RQSENSE->es_qual_code == 0x4 || 11142 ST_RQSENSE->es_qual_code == 0x5 || 11143 ST_RQSENSE->es_qual_code == 0x6 || 11144 ST_RQSENSE->es_qual_code == 0x7) { 11145 rval = DEVICE_TAMPER; 11146 severity = SCSI_ERR_INFO; 11147 } 11148 } else if (ST_RQSENSE->es_add_code == 0x28 && 11149 ((ST_RQSENSE->es_qual_code == 0x0) || 11150 ST_RQSENSE->es_qual_code == 0x5)) { 11151 /* 11152 * Not Ready to Ready change, Media may have changed. 11153 */ 11154 rval = DEVICE_TAMPER; 11155 severity = SCSI_ERR_RETRYABLE; 11156 } else { 11157 if (rval != DEVICE_RESET) { 11158 rval = COMMAND_DONE_ERROR; 11159 } else { 11160 /* 11161 * Returning DEVICE_RESET will call 11162 * error recovery. 11163 */ 11164 severity = SCSI_ERR_INFO; 11165 break; /* don't set position invalid */ 11166 } 11167 /* 11168 * Check if it is an Unexpected Unit Attention. 11169 * If state is >= ST_STATE_OPEN, we have 11170 * already done the initialization . 11171 * In this case it is Fatal Error 11172 * since no further reading/writing 11173 * can be done with fileno set to < 0. 11174 */ 11175 if (un->un_state >= ST_STATE_OPEN) { 11176 ST_DO_ERRSTATS(un, st_harderrs); 11177 severity = SCSI_ERR_FATAL; 11178 } else { 11179 severity = SCSI_ERR_INFO; 11180 } 11181 } 11182 11183 pos->pmode = invalid; 11184 11185 break; 11186 11187 case KEY_NOT_READY: 11188 /* 11189 * If in process of getting ready retry. 11190 */ 11191 if (sensep->es_add_code == 0x04) { 11192 switch (sensep->es_qual_code) { 11193 case 0x07: 11194 /* 11195 * We get here when the tape is rewinding. 11196 * QUE_BUSY_COMMAND retries every 10 seconds. 11197 */ 11198 if (ri->pkt_retry_cnt++ < 11199 (un->un_dp->rewind_timeout / 10)) { 11200 rval = QUE_BUSY_COMMAND; 11201 severity = SCSI_ERR_INFO; 11202 } else { 11203 /* give up */ 11204 rval = COMMAND_DONE_ERROR; 11205 severity = SCSI_ERR_FATAL; 11206 } 11207 break; 11208 case 0x01: 11209 if (ri->pkt_retry_cnt++ < st_retry_count) { 11210 rval = QUE_COMMAND; 11211 severity = SCSI_ERR_INFO; 11212 break; 11213 } 11214 default: /* FALLTHRU */ 11215 /* give up */ 11216 rval = COMMAND_DONE_ERROR; 11217 severity = SCSI_ERR_FATAL; 11218 } 11219 } else { 11220 /* give up */ 11221 rval = COMMAND_DONE_ERROR; 11222 severity = SCSI_ERR_FATAL; 11223 } 11224 11225 /* 11226 * If this was an error and after device opened 11227 * do error stats. 11228 */ 11229 if (rval == COMMAND_DONE_ERROR && 11230 un->un_state > ST_STATE_OPENING) { 11231 ST_DO_ERRSTATS(un, st_harderrs); 11232 } 11233 11234 if (ST_RQSENSE->es_add_code == 0x3a) { 11235 if (st_error_level >= SCSI_ERR_FATAL) 11236 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 11237 "Tape not inserted in drive\n"); 11238 un->un_mediastate = MTIO_EJECTED; 11239 cv_broadcast(&un->un_state_cv); 11240 } 11241 if ((un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) && 11242 (rval != QUE_COMMAND)) 11243 un->un_eject_tape_on_failure = st_check_asc_ascq(un); 11244 break; 11245 11246 case KEY_ABORTED_COMMAND: 11247 /* XXX Do drives return this when they see a lost light? */ 11248 /* Testing would say yes */ 11249 11250 if (ri->pkt_retry_cnt++ < st_retry_count) { 11251 rval = ATTEMPT_RETRY; 11252 severity = SCSI_ERR_RETRYABLE; 11253 goto check_keys; 11254 } 11255 /* 11256 * Probably a parity error... 11257 * if we retry here then this may cause data to be 11258 * written twice or data skipped during reading 11259 */ 11260 ST_DO_ERRSTATS(un, st_harderrs); 11261 severity = SCSI_ERR_FATAL; 11262 rval = COMMAND_DONE_ERROR; 11263 goto check_keys; 11264 11265 default: 11266 /* 11267 * Undecoded sense key. Try retries and hope 11268 * that will fix the problem. Otherwise, we're 11269 * dead. 11270 */ 11271 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11272 "Unhandled Sense Key '%s'\n", 11273 sense_keys[un->un_status]); 11274 ST_DO_ERRSTATS(un, st_harderrs); 11275 severity = SCSI_ERR_FATAL; 11276 rval = COMMAND_DONE_ERROR; 11277 goto check_keys; 11278 } 11279 11280 if ((!(pkt->pkt_flags & FLAG_SILENT) && 11281 un->un_state >= ST_STATE_OPEN) && (DEBUGGING || 11282 (un->un_laststate > ST_STATE_OPENING) && 11283 (severity >= st_error_level))) { 11284 11285 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity, 11286 pos->lgclblkno, un->un_err_pos.lgclblkno, 11287 scsi_cmds, sensep); 11288 if (sensep->es_filmk) { 11289 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11290 "File Mark Detected\n"); 11291 } 11292 if (sensep->es_eom) { 11293 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11294 "End-of-Media Detected\n"); 11295 } 11296 if (sensep->es_ili) { 11297 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11298 "Incorrect Length Indicator Set\n"); 11299 } 11300 } 11301 get_error = geterror(bp); 11302 if (((rval == COMMAND_DONE_ERROR) || 11303 (rval == COMMAND_DONE_ERROR_RECOVERED)) && 11304 ((get_error == EIO) || (get_error == 0))) { 11305 un->un_rqs_state |= (ST_RQS_ERROR | ST_RQS_VALID); 11306 bcopy(ST_RQSENSE, un->un_uscsi_rqs_buf, SENSE_LENGTH); 11307 if (un->un_rqs_state & ST_RQS_READ) { 11308 un->un_rqs_state &= ~(ST_RQS_READ); 11309 } else { 11310 un->un_rqs_state |= ST_RQS_OVR; 11311 } 11312 } 11313 11314 return (rval); 11315 } 11316 11317 11318 static int 11319 st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp) 11320 { 11321 int status = TRAN_ACCEPT; 11322 pkt_info *pktinfo = BP_PKT(bp)->pkt_private; 11323 11324 mutex_enter(ST_MUTEX); 11325 11326 ST_FUNC(ST_DEVINFO, st_handle_intr_retry_lcmd); 11327 11328 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 11329 "st_handle_intr_rtr_lcmd(), un = 0x%p\n", (void *)un); 11330 11331 /* 11332 * Check to see if we hit the retry timeout. We check to make sure 11333 * this is the first one on the runq and make sure we have not 11334 * queued up any more, so this one has to be the last on the list 11335 * also. If it is not, we have to fail. If it is not the first, but 11336 * is the last we are in trouble anyway, as we are in the interrupt 11337 * context here. 11338 */ 11339 if ((pktinfo->pkt_retry_cnt > st_retry_count) || 11340 ((un->un_runqf != bp) && (un->un_runql != bp))) { 11341 goto exit; 11342 } 11343 11344 if (un->un_throttle) { 11345 un->un_last_throttle = un->un_throttle; 11346 un->un_throttle = 0; 11347 } 11348 11349 /* 11350 * Here we know : bp is the first and last one on the runq 11351 * it is not necessary to put it back on the head of the 11352 * waitq and then move from waitq to runq. Save this queuing 11353 * and call scsi_transport. 11354 */ 11355 ST_CDB(ST_DEVINFO, "Retry lcmd CDB", (char *)BP_PKT(bp)->pkt_cdbp); 11356 11357 status = st_transport(un, BP_PKT(bp)); 11358 11359 if (status == TRAN_ACCEPT) { 11360 if (un->un_last_throttle) { 11361 un->un_throttle = un->un_last_throttle; 11362 } 11363 mutex_exit(ST_MUTEX); 11364 11365 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11366 "restart transport \n"); 11367 return (0); 11368 } 11369 11370 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 11371 mutex_exit(ST_MUTEX); 11372 11373 if (status == TRAN_BUSY) { 11374 if (st_handle_intr_busy(un, bp, ST_TRAN_BUSY_TIMEOUT) == 0) { 11375 return (0); 11376 } 11377 } 11378 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11379 "restart transport rejected\n"); 11380 mutex_enter(ST_MUTEX); 11381 ST_DO_ERRSTATS(un, st_transerrs); 11382 if (un->un_last_throttle) { 11383 un->un_throttle = un->un_last_throttle; 11384 } 11385 exit: 11386 mutex_exit(ST_MUTEX); 11387 return (-1); 11388 } 11389 11390 static int 11391 st_wrongtapetype(struct scsi_tape *un) 11392 { 11393 11394 ST_FUNC(ST_DEVINFO, st_wrongtapetype); 11395 11396 ASSERT(mutex_owned(ST_MUTEX)); 11397 11398 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_wrongtapetype()\n"); 11399 11400 /* 11401 * Hack to handle 600A, 600XTD, 6150 && 660 vs. 300XL tapes... 11402 */ 11403 if (un->un_dp && (un->un_dp->options & ST_QIC) && un->un_mspl) { 11404 switch (un->un_dp->type) { 11405 case ST_TYPE_WANGTEK: 11406 case ST_TYPE_ARCHIVE: 11407 /* 11408 * If this really worked, we could go off of 11409 * the density codes set in the modesense 11410 * page. For this drive, 0x10 == QIC-120, 11411 * 0xf == QIC-150, and 0x5 should be for 11412 * both QIC-24 and, maybe, QIC-11. However, 11413 * the h/w doesn't do what the manual says 11414 * that it should, so we'll key off of 11415 * getting a WRITE PROTECT error AND wp *not* 11416 * set in the mode sense information. 11417 */ 11418 /* 11419 * XXX but we already know that status is 11420 * write protect, so don't check it again. 11421 */ 11422 11423 if (un->un_status == KEY_WRITE_PROTECT && 11424 un->un_mspl->wp == 0) { 11425 return (1); 11426 } 11427 break; 11428 default: 11429 break; 11430 } 11431 } 11432 return (0); 11433 } 11434 11435 static errstate 11436 st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt) 11437 { 11438 errstate action; 11439 recov_info *rcvi = pkt->pkt_private; 11440 buf_t *bp = rcvi->cmd_bp; 11441 struct scsi_arq_status *stat = (struct scsi_arq_status *)pkt->pkt_scbp; 11442 11443 ST_FUNC(ST_DEVINFO, st_check_error); 11444 11445 ASSERT(mutex_owned(ST_MUTEX)); 11446 11447 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_error()\n"); 11448 11449 switch (SCBP_C(pkt)) { 11450 case STATUS_RESERVATION_CONFLICT: 11451 /* 11452 * Command recovery is enabled, not just opening, 11453 * we had the drive reserved and we thing its ours. 11454 * Call recovery to attempt to take it back. 11455 */ 11456 if ((rcvi->privatelen == sizeof (recov_info)) && 11457 (bp != un->un_recov_buf) && 11458 (un->un_state > ST_STATE_OPEN_PENDING_IO) && 11459 ((un->un_rsvd_status & (ST_RESERVE | 11460 ST_APPLICATION_RESERVATIONS)) != 0)) { 11461 action = ATTEMPT_RETRY; 11462 un->un_rsvd_status |= ST_LOST_RESERVE; 11463 } else { 11464 action = COMMAND_DONE_EACCES; 11465 un->un_rsvd_status |= ST_RESERVATION_CONFLICT; 11466 } 11467 break; 11468 11469 case STATUS_BUSY: 11470 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, "unit busy\n"); 11471 if (rcvi->privatelen == sizeof (recov_info) && 11472 un->un_multipath && (pkt->pkt_state == (STATE_GOT_BUS | 11473 STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS))) { 11474 /* 11475 * Status returned by scsi_vhci indicating path 11476 * has failed over. 11477 */ 11478 action = PATH_FAILED; 11479 break; 11480 } 11481 /* FALLTHRU */ 11482 case STATUS_QFULL: 11483 if (rcvi->privatelen == sizeof (recov_info)) { 11484 /* 11485 * If recovery is inabled use it instead of 11486 * blind reties. 11487 */ 11488 action = ATTEMPT_RETRY; 11489 } else if (rcvi->pkt_retry_cnt++ < st_retry_count) { 11490 action = QUE_BUSY_COMMAND; 11491 } else if ((un->un_rsvd_status & 11492 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 11493 /* 11494 * If this is a command done before reserve is done 11495 * don't reset. 11496 */ 11497 action = COMMAND_DONE_ERROR; 11498 } else { 11499 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 11500 "unit busy too long\n"); 11501 (void) st_reset(un, RESET_ALL); 11502 action = COMMAND_DONE_ERROR; 11503 } 11504 break; 11505 11506 case STATUS_CHECK: 11507 case STATUS_TERMINATED: 11508 /* 11509 * we should only get here if the auto rqsense failed 11510 * thru a uscsi cmd without autorequest sense 11511 * so we just try again 11512 */ 11513 if (un->un_arq_enabled && 11514 stat->sts_rqpkt_reason == CMD_CMPLT && 11515 (stat->sts_rqpkt_state & (STATE_GOT_BUS | 11516 STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS)) == 11517 (STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD | 11518 STATE_GOT_STATUS)) { 11519 11520 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 11521 "Really got sense data\n"); 11522 action = st_decode_sense(un, bp, MAX_SENSE_LENGTH - 11523 pkt->pkt_resid, stat, &un->un_pos); 11524 } else { 11525 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 11526 "Trying to queue sense command\n"); 11527 action = QUE_SENSE; 11528 } 11529 break; 11530 11531 case STATUS_TASK_ABORT: 11532 /* 11533 * This is an aborted task. This can be a reset on the other 11534 * port of a multiport drive. Lets try and recover it. 11535 */ 11536 action = DEVICE_RESET; 11537 break; 11538 11539 default: 11540 action = COMMAND_DONE; 11541 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 11542 "Unexpected scsi status byte 0x%x\n", SCBP_C(pkt)); 11543 } 11544 return (action); 11545 } 11546 11547 static void 11548 st_calc_bnum(struct scsi_tape *un, struct buf *bp, struct scsi_pkt *pkt) 11549 { 11550 int nblks; 11551 int nfiles; 11552 long count; 11553 recov_info *ri = pkt->pkt_private; 11554 cmd_attribute const *attrib; 11555 11556 ST_FUNC(ST_DEVINFO, st_calc_bnum); 11557 11558 ASSERT(mutex_owned(ST_MUTEX)); 11559 11560 if (ri->privatelen == sizeof (recov_info)) { 11561 attrib = ri->cmd_attrib; 11562 ASSERT(attrib->recov_pos_type == POS_EXPECTED); 11563 ASSERT(attrib->chg_tape_pos); 11564 } else { 11565 ri = NULL; 11566 attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 11567 } 11568 11569 count = bp->b_bcount - bp->b_resid; 11570 11571 /* Command reads or writes data */ 11572 if (attrib->transfers_data != TRAN_NONE) { 11573 if (count == 0) { 11574 if (attrib->transfers_data == TRAN_WRTE) { 11575 ASSERT(un->un_pos.eof == ST_EOM); 11576 nblks = 0; 11577 nfiles = 0; 11578 } else { 11579 ASSERT(un->un_pos.eof == ST_EOF_PENDING); 11580 nblks = 0; 11581 nfiles = 1; 11582 } 11583 } else if (un->un_bsize == 0) { 11584 /* 11585 * If variable block mode. 11586 * Fixed bit in CBD should be zero. 11587 */ 11588 ASSERT((pkt->pkt_cdbp[1] & 1) == 0); 11589 nblks = 1; 11590 un->un_kbytes_xferred += (count / ONE_K); 11591 nfiles = 0; 11592 } else { 11593 /* 11594 * If fixed block mode. 11595 * Fixed bit in CBD should be one. 11596 */ 11597 ASSERT((pkt->pkt_cdbp[1] & 1) == 1); 11598 nblks = (count / un->un_bsize); 11599 un->un_kbytes_xferred += (nblks * un->un_bsize) / ONE_K; 11600 nfiles = 0; 11601 } 11602 /* 11603 * So its possable to read some blocks and hit a filemark. 11604 * Example reading in fixed block mode where more then one 11605 * block at a time is requested. In this case because the 11606 * filemark is hit something less then the requesed number 11607 * of blocks is read. 11608 */ 11609 if (un->un_pos.eof == ST_EOF_PENDING && bp->b_resid) { 11610 nfiles = 1; 11611 } 11612 } else { 11613 nblks = 0; 11614 nfiles = count; 11615 } 11616 11617 /* 11618 * If some command failed after this one started and it seems 11619 * to have finshed without error count the position. 11620 */ 11621 if (un->un_persistence && un->un_persist_errors) { 11622 ASSERT(un->un_pos.pmode != invalid); 11623 } 11624 11625 if (attrib->chg_tape_direction == DIR_FORW) { 11626 un->un_pos.blkno += nblks; 11627 un->un_pos.lgclblkno += nblks; 11628 un->un_pos.lgclblkno += nfiles; 11629 } else if (attrib->chg_tape_direction == DIR_REVC) { 11630 un->un_pos.blkno -= nblks; 11631 un->un_pos.lgclblkno -= nblks; 11632 un->un_pos.lgclblkno -= nfiles; 11633 } else { 11634 ASSERT(0); 11635 } 11636 11637 /* recovery disabled */ 11638 if (ri == NULL) { 11639 un->un_running.pmode = invalid; 11640 return; 11641 } 11642 11643 /* 11644 * If we didn't just read a filemark. 11645 */ 11646 if (un->un_pos.eof != ST_EOF_PENDING) { 11647 ASSERT(nblks != 0 && nfiles == 0); 11648 /* 11649 * If Previously calulated expected position does not match 11650 * debug the expected position. 11651 */ 11652 if ((ri->pos.pmode != invalid) && nblks && 11653 ((un->un_pos.blkno != ri->pos.blkno) || 11654 (un->un_pos.lgclblkno != ri->pos.lgclblkno))) { 11655 #ifdef STDEBUG 11656 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 11657 "Expected", &ri->pos); 11658 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 11659 "But Got", &un->un_pos); 11660 #endif 11661 un->un_running.pmode = invalid; 11662 } 11663 } else { 11664 ASSERT(nfiles != 0); 11665 if (un->un_running.pmode != invalid) { 11666 /* 11667 * blkno and lgclblkno already counted in 11668 * st_add_recovery_info_to_pkt(). Since a block was not 11669 * read and a filemark was. 11670 */ 11671 if (attrib->chg_tape_direction == DIR_FORW) { 11672 un->un_running.fileno++; 11673 un->un_running.blkno = 0; 11674 } else if (attrib->chg_tape_direction == DIR_REVC) { 11675 un->un_running.fileno--; 11676 un->un_running.blkno = LASTBLK; 11677 } 11678 } 11679 } 11680 } 11681 11682 static void 11683 st_set_state(struct scsi_tape *un, struct buf *bp) 11684 { 11685 struct scsi_pkt *sp = BP_PKT(bp); 11686 struct uscsi_cmd *ucmd; 11687 11688 ST_FUNC(ST_DEVINFO, st_set_state); 11689 11690 ASSERT(mutex_owned(ST_MUTEX)); 11691 ASSERT(bp != un->un_recov_buf); 11692 11693 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 11694 "st_set_state(): eof=%x fmneeded=%x pkt_resid=0x%lx (%ld)\n", 11695 un->un_pos.eof, un->un_fmneeded, sp->pkt_resid, sp->pkt_resid); 11696 11697 if (bp != un->un_sbufp) { 11698 #ifdef STDEBUG 11699 if (DEBUGGING && sp->pkt_resid) { 11700 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11701 "pkt_resid %ld bcount %ld\n", 11702 sp->pkt_resid, bp->b_bcount); 11703 } 11704 #endif 11705 bp->b_resid = sp->pkt_resid; 11706 if (geterror(bp) != EIO) { 11707 st_calc_bnum(un, bp, sp); 11708 } 11709 if (bp->b_flags & B_READ) { 11710 un->un_lastop = ST_OP_READ; 11711 un->un_fmneeded = 0; 11712 } else { 11713 un->un_lastop = ST_OP_WRITE; 11714 if (un->un_dp->options & ST_REEL) { 11715 un->un_fmneeded = 2; 11716 } else { 11717 un->un_fmneeded = 1; 11718 } 11719 } 11720 /* 11721 * all is honky dory at this point, so let's 11722 * readjust the throttle, to increase speed, if we 11723 * have not throttled down. 11724 */ 11725 if (un->un_throttle) { 11726 un->un_throttle = un->un_max_throttle; 11727 } 11728 } else { 11729 optype new_lastop = ST_OP_NIL; 11730 uchar_t cmd = (uchar_t)(intptr_t)bp->b_forw; 11731 11732 switch (cmd) { 11733 case SCMD_WRITE: 11734 case SCMD_WRITE_G4: 11735 bp->b_resid = sp->pkt_resid; 11736 new_lastop = ST_OP_WRITE; 11737 if (geterror(bp) == EIO) { 11738 break; 11739 } 11740 st_calc_bnum(un, bp, sp); 11741 if (un->un_dp->options & ST_REEL) { 11742 un->un_fmneeded = 2; 11743 } else { 11744 un->un_fmneeded = 1; 11745 } 11746 break; 11747 case SCMD_READ: 11748 case SCMD_READ_G4: 11749 bp->b_resid = sp->pkt_resid; 11750 new_lastop = ST_OP_READ; 11751 un->un_lastop = ST_OP_READ; 11752 if (geterror(bp) == EIO) { 11753 break; 11754 } 11755 st_calc_bnum(un, bp, sp); 11756 un->un_fmneeded = 0; 11757 break; 11758 case SCMD_WRITE_FILE_MARK_G4: 11759 case SCMD_WRITE_FILE_MARK: 11760 { 11761 int fmdone; 11762 11763 if (un->un_pos.eof != ST_EOM) { 11764 un->un_pos.eof = ST_NO_EOF; 11765 } 11766 fmdone = (bp->b_bcount - bp->b_resid); 11767 if (fmdone > 0) { 11768 un->un_lastop = new_lastop = ST_OP_WEOF; 11769 un->un_pos.lgclblkno += fmdone; 11770 un->un_pos.fileno += fmdone; 11771 un->un_pos.blkno = 0; 11772 } else { 11773 new_lastop = ST_OP_CTL; 11774 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 11775 "Flushed buffer\n"); 11776 } 11777 if (fmdone > un->un_fmneeded) { 11778 un->un_fmneeded = 0; 11779 } else { 11780 un->un_fmneeded -= fmdone; 11781 } 11782 break; 11783 } 11784 case SCMD_REWIND: 11785 un->un_pos.eof = ST_NO_EOF; 11786 un->un_pos.fileno = 0; 11787 un->un_pos.blkno = 0; 11788 un->un_pos.lgclblkno = 0; 11789 if (un->un_pos.pmode != legacy) 11790 un->un_pos.pmode = legacy; 11791 new_lastop = ST_OP_CTL; 11792 un->un_restore_pos = 0; 11793 break; 11794 11795 case SCMD_SPACE: 11796 case SCMD_SPACE_G4: 11797 { 11798 int64_t count; 11799 int64_t resid; 11800 int64_t done; 11801 cmd_attribute const *attrib; 11802 recov_info *ri = sp->pkt_private; 11803 11804 if (ri->privatelen == sizeof (recov_info)) { 11805 attrib = ri->cmd_attrib; 11806 } else { 11807 attrib = 11808 st_lookup_cmd_attribute(sp->pkt_cdbp[0]); 11809 } 11810 11811 resid = (int64_t)SPACE_CNT(bp->b_resid); 11812 count = (int64_t)attrib->get_cnt(sp->pkt_cdbp); 11813 11814 if (count >= 0) { 11815 done = (count - resid); 11816 } else { 11817 done = ((-count) - resid); 11818 } 11819 if (done > 0) { 11820 un->un_lastop = new_lastop = ST_OP_CTL; 11821 } else { 11822 new_lastop = ST_OP_CTL; 11823 } 11824 11825 ST_SPAC(ST_DEVINFO, st_label, CE_WARN, 11826 "space cmd: cdb[1] = %s\n" 11827 "space data: = 0x%lx\n" 11828 "space count: = %"PRId64"\n" 11829 "space resid: = %"PRId64"\n" 11830 "spaces done: = %"PRId64"\n" 11831 "fileno before = %d\n" 11832 "blkno before = %d\n", 11833 space_strs[sp->pkt_cdbp[1] & 7], 11834 bp->b_bcount, 11835 count, resid, done, 11836 un->un_pos.fileno, un->un_pos.blkno); 11837 11838 switch (sp->pkt_cdbp[1]) { 11839 case SPACE_TYPE(SP_FLM): 11840 /* Space file forward */ 11841 if (count >= 0) { 11842 if (un->un_pos.eof <= ST_EOF) { 11843 un->un_pos.eof = ST_NO_EOF; 11844 } 11845 un->un_pos.fileno += done; 11846 un->un_pos.blkno = 0; 11847 break; 11848 } 11849 /* Space file backward */ 11850 if (done > un->un_pos.fileno) { 11851 un->un_pos.fileno = 0; 11852 un->un_pos.blkno = 0; 11853 } else { 11854 un->un_pos.fileno -= done; 11855 un->un_pos.blkno = LASTBLK; 11856 un->un_running.pmode = invalid; 11857 } 11858 break; 11859 case SPACE_TYPE(SP_BLK): 11860 /* Space block forward */ 11861 if (count >= 0) { 11862 un->un_pos.blkno += done; 11863 break; 11864 } 11865 /* Space block backward */ 11866 if (un->un_pos.eof >= ST_EOF_PENDING) { 11867 /* 11868 * we stepped back into 11869 * a previous file; we are not 11870 * making an effort to pretend that 11871 * we are still in the current file 11872 * ie. logical == physical position 11873 * and leave it to st_ioctl to correct 11874 */ 11875 if (done > un->un_pos.blkno) { 11876 un->un_pos.blkno = 0; 11877 } else { 11878 un->un_pos.fileno--; 11879 un->un_pos.blkno = LASTBLK; 11880 un->un_running.pmode = invalid; 11881 } 11882 } else { 11883 un->un_pos.blkno -= done; 11884 } 11885 break; 11886 case SPACE_TYPE(SP_SQFLM): 11887 un->un_pos.pmode = logical; 11888 un->un_pos.blkno = 0; 11889 un->un_lastop = new_lastop = ST_OP_CTL; 11890 break; 11891 case SPACE_TYPE(SP_EOD): 11892 un->un_pos.pmode = logical; 11893 un->un_pos.eof = ST_EOM; 11894 un->un_status = KEY_BLANK_CHECK; 11895 break; 11896 default: 11897 un->un_pos.pmode = invalid; 11898 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 11899 "Unsupported space cmd: %s\n", 11900 space_strs[sp->pkt_cdbp[1] & 7]); 11901 11902 un->un_lastop = new_lastop = ST_OP_CTL; 11903 } 11904 11905 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11906 "after_space rs %"PRId64" fil %d blk %d\n", 11907 resid, un->un_pos.fileno, un->un_pos.blkno); 11908 11909 break; 11910 } 11911 case SCMD_LOAD: 11912 if ((bp->b_bcount & (LD_LOAD | LD_EOT)) == LD_LOAD) { 11913 un->un_pos.fileno = 0; 11914 if (un->un_pos.pmode != legacy) 11915 un->un_pos.pmode = legacy; 11916 } else { 11917 un->un_state = ST_STATE_OFFLINE; 11918 un->un_pos.pmode = invalid; 11919 11920 } 11921 /* 11922 * If we are loading or unloading we expect the media id 11923 * to change. Lets make it unknown. 11924 */ 11925 if (un->un_media_id != bogusID && un->un_media_id_len) { 11926 kmem_free(un->un_media_id, un->un_media_id_len); 11927 un->un_media_id = NULL; 11928 un->un_media_id_len = 0; 11929 } 11930 un->un_density_known = 0; 11931 un->un_pos.eof = ST_NO_EOF; 11932 un->un_pos.blkno = 0; 11933 un->un_lastop = new_lastop = ST_OP_CTL; 11934 break; 11935 case SCMD_ERASE: 11936 un->un_pos.eof = ST_NO_EOF; 11937 un->un_pos.blkno = 0; 11938 un->un_pos.fileno = 0; 11939 un->un_pos.lgclblkno = 0; 11940 if (un->un_pos.pmode != legacy) 11941 un->un_pos.pmode = legacy; 11942 new_lastop = ST_OP_CTL; 11943 break; 11944 case SCMD_RESERVE: 11945 un->un_rsvd_status |= ST_RESERVE; 11946 un->un_rsvd_status &= 11947 ~(ST_RELEASE | ST_LOST_RESERVE | 11948 ST_RESERVATION_CONFLICT | ST_INITIATED_RESET); 11949 new_lastop = ST_OP_CTL; 11950 break; 11951 case SCMD_RELEASE: 11952 un->un_rsvd_status |= ST_RELEASE; 11953 un->un_rsvd_status &= 11954 ~(ST_RESERVE | ST_LOST_RESERVE | 11955 ST_RESERVATION_CONFLICT | ST_INITIATED_RESET); 11956 new_lastop = ST_OP_CTL; 11957 break; 11958 case SCMD_PERSISTENT_RESERVE_IN: 11959 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11960 "PGR_IN command\n"); 11961 new_lastop = ST_OP_CTL; 11962 break; 11963 case SCMD_PERSISTENT_RESERVE_OUT: 11964 switch (sp->pkt_cdbp[1] & ST_SA_MASK) { 11965 case ST_SA_SCSI3_RESERVE: 11966 case ST_SA_SCSI3_PREEMPT: 11967 case ST_SA_SCSI3_PREEMPTANDABORT: 11968 un->un_rsvd_status |= 11969 (ST_APPLICATION_RESERVATIONS | ST_RESERVE); 11970 un->un_rsvd_status &= ~(ST_RELEASE | 11971 ST_LOST_RESERVE | ST_RESERVATION_CONFLICT | 11972 ST_INITIATED_RESET); 11973 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11974 "PGR Reserve and set: entering" 11975 " ST_APPLICATION_RESERVATIONS mode"); 11976 break; 11977 case ST_SA_SCSI3_REGISTER: 11978 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11979 "PGR Reserve register key"); 11980 un->un_rsvd_status |= ST_INIT_RESERVE; 11981 break; 11982 case ST_SA_SCSI3_CLEAR: 11983 un->un_rsvd_status &= ~ST_INIT_RESERVE; 11984 /* FALLTHROUGH */ 11985 case ST_SA_SCSI3_RELEASE: 11986 un->un_rsvd_status &= 11987 ~(ST_APPLICATION_RESERVATIONS | ST_RESERVE | 11988 ST_LOST_RESERVE | ST_RESERVATION_CONFLICT | 11989 ST_INITIATED_RESET); 11990 un->un_rsvd_status |= ST_RELEASE; 11991 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11992 "PGR Release and reset: exiting" 11993 " ST_APPLICATION_RESERVATIONS mode"); 11994 break; 11995 } 11996 new_lastop = ST_OP_CTL; 11997 break; 11998 case SCMD_TEST_UNIT_READY: 11999 case SCMD_READ_BLKLIM: 12000 case SCMD_REQUEST_SENSE: 12001 case SCMD_INQUIRY: 12002 case SCMD_RECOVER_BUF: 12003 case SCMD_MODE_SELECT: 12004 case SCMD_MODE_SENSE: 12005 case SCMD_DOORLOCK: 12006 case SCMD_READ_BUFFER: 12007 case SCMD_REPORT_DENSITIES: 12008 case SCMD_LOG_SELECT_G1: 12009 case SCMD_LOG_SENSE_G1: 12010 case SCMD_REPORT_LUNS: 12011 case SCMD_READ_ATTRIBUTE: 12012 case SCMD_WRITE_ATTRIBUTE: 12013 case SCMD_SVC_ACTION_IN_G5: 12014 case SCMD_SECURITY_PROTO_IN: 12015 case SCMD_SECURITY_PROTO_OUT: 12016 new_lastop = ST_OP_CTL; 12017 break; 12018 case SCMD_READ_POSITION: 12019 new_lastop = ST_OP_CTL; 12020 /* 12021 * Only if the buf used was un_sbufp. 12022 * Among other things the prevents read positions used 12023 * as part of error recovery from messing up our 12024 * current position as they will use un_recov_buf. 12025 */ 12026 if (USCSI_CMD(bp)) { 12027 (void) st_get_read_pos(un, bp); 12028 } 12029 break; 12030 case SCMD_LOCATE: 12031 case SCMD_LOCATE_G4: 12032 /* Locate makes position mode no longer legacy */ 12033 un->un_lastop = new_lastop = ST_OP_CTL; 12034 break; 12035 case SCMD_MAINTENANCE_IN: 12036 switch (sp->pkt_cdbp[1]) { 12037 case SSVC_ACTION_GET_SUPPORTED_OPERATIONS: 12038 case SSVC_ACTION_SET_TARGET_PORT_GROUPS: 12039 new_lastop = ST_OP_CTL; 12040 break; 12041 } 12042 if (new_lastop != ST_OP_NIL) { 12043 break; 12044 } 12045 default: 12046 /* 12047 * Unknown command, If was USCSI and USCSI_SILENT 12048 * flag was not set, set position to unknown. 12049 */ 12050 if ((((ucmd = BP_UCMD(bp)) != NULL) && 12051 (ucmd->uscsi_flags & USCSI_SILENT) == 0)) { 12052 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 12053 "unknown cmd 0x%X caused loss of state\n", 12054 cmd); 12055 } else { 12056 /* 12057 * keep the old agreement to allow unknown 12058 * commands with the USCSI_SILENT set. 12059 * This prevents ASSERT below. 12060 */ 12061 new_lastop = ST_OP_CTL; 12062 break; 12063 } 12064 /* FALLTHROUGH */ 12065 case SCMD_WRITE_BUFFER: /* Writes new firmware to device */ 12066 un->un_pos.pmode = invalid; 12067 un->un_lastop = new_lastop = ST_OP_CTL; 12068 break; 12069 } 12070 12071 /* new_lastop should have been changed */ 12072 ASSERT(new_lastop != ST_OP_NIL); 12073 12074 /* If un_lastop should copy new_lastop */ 12075 if (((un->un_lastop == ST_OP_WRITE) || 12076 (un->un_lastop == ST_OP_WEOF)) && 12077 new_lastop != ST_OP_CTL) { 12078 un->un_lastop = new_lastop; 12079 } 12080 } 12081 12082 /* 12083 * In the st driver we have a logical and physical file position. 12084 * Under BSD behavior, when you get a zero read, the logical position 12085 * is before the filemark but after the last record of the file. 12086 * The physical position is after the filemark. MTIOCGET should always 12087 * return the logical file position. 12088 * 12089 * The next read gives a silent skip to the next file. 12090 * Under SVR4, the logical file position remains before the filemark 12091 * until the file is closed or a space operation is performed. 12092 * Hence set err_resid and err_file before changing fileno if case 12093 * BSD Behaviour. 12094 */ 12095 un->un_err_resid = bp->b_resid; 12096 COPY_POS(&un->un_err_pos, &un->un_pos); 12097 12098 12099 /* 12100 * If we've seen a filemark via the last read operation 12101 * advance the file counter, but mark things such that 12102 * the next read operation gets a zero count. We have 12103 * to put this here to handle the case of sitting right 12104 * at the end of a tape file having seen the file mark, 12105 * but the tape is closed and then re-opened without 12106 * any further i/o. That is, the position information 12107 * must be updated before a close. 12108 */ 12109 12110 if (un->un_lastop == ST_OP_READ && un->un_pos.eof == ST_EOF_PENDING) { 12111 /* 12112 * If we're a 1/2" tape, and we get a filemark 12113 * right on block 0, *AND* we were not in the 12114 * first file on the tape, and we've hit logical EOM. 12115 * We'll mark the state so that later we do the 12116 * right thing (in st_close(), st_strategy() or 12117 * st_ioctl()). 12118 * 12119 */ 12120 if ((un->un_dp->options & ST_REEL) && 12121 !(un->un_dp->options & ST_READ_IGNORE_EOFS) && 12122 un->un_pos.blkno == 0 && un->un_pos.fileno > 0) { 12123 un->un_pos.eof = ST_EOT_PENDING; 12124 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12125 "eot pending\n"); 12126 un->un_pos.fileno++; 12127 un->un_pos.blkno = 0; 12128 } else if (BP_UCMD(bp)) { 12129 /* 12130 * Uscsi reads have no concept of Berkley ver System IV. 12131 * Counts here must match raw device. 12132 * A non-full resid implies fix block mode where an 12133 * attempt to read X blocks resulted in less then X. 12134 */ 12135 if (bp->b_resid != bp->b_bcount) { 12136 un->un_pos.eof = ST_EOF; 12137 } else { 12138 /* Read over a file mark */ 12139 un->un_pos.fileno++; 12140 /* logical block is counted up elsewhere */ 12141 /* we're before the first block in next file */ 12142 un->un_pos.blkno = 0; 12143 /* EOF is no longer pending */ 12144 un->un_pos.eof = ST_NO_EOF; 12145 } 12146 } else if (BSD_BEHAVIOR) { 12147 /* 12148 * If the read of the filemark was a side effect 12149 * of reading some blocks (i.e., data was actually 12150 * read), then the EOF mark is pending and the 12151 * bump into the next file awaits the next read 12152 * operation (which will return a zero count), or 12153 * a close or a space operation, else the bump 12154 * into the next file occurs now. 12155 */ 12156 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12157 "resid=%lx, bcount=%lx\n", 12158 bp->b_resid, bp->b_bcount); 12159 12160 if (bp->b_resid != bp->b_bcount) { 12161 un->un_pos.eof = ST_EOF; 12162 } else { 12163 un->un_silent_skip = 1; 12164 un->un_pos.eof = ST_NO_EOF; 12165 un->un_pos.fileno++; 12166 un->un_pos.lgclblkno++; 12167 un->un_save_blkno = un->un_pos.blkno; 12168 un->un_pos.blkno = 0; 12169 } 12170 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12171 "eof of file %d, eof=%d\n", 12172 un->un_pos.fileno, un->un_pos.eof); 12173 } else if (SVR4_BEHAVIOR) { 12174 /* 12175 * If the read of the filemark was a side effect 12176 * of reading some blocks (i.e., data was actually 12177 * read), then the next read should return 0 12178 */ 12179 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12180 "resid=%lx, bcount=%lx\n", 12181 bp->b_resid, bp->b_bcount); 12182 if (bp->b_resid == bp->b_bcount) { 12183 un->un_pos.eof = ST_EOF; 12184 } 12185 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12186 "eof of file=%d, eof=%d\n", 12187 un->un_pos.fileno, un->un_pos.eof); 12188 } 12189 } 12190 } 12191 12192 /* 12193 * set the correct un_errno, to take corner cases into consideration 12194 */ 12195 static void 12196 st_set_pe_errno(struct scsi_tape *un) 12197 { 12198 ST_FUNC(ST_DEVINFO, st_set_pe_errno); 12199 12200 ASSERT(mutex_owned(ST_MUTEX)); 12201 12202 /* if errno is already set, don't reset it */ 12203 if (un->un_errno) 12204 return; 12205 12206 /* here un_errno == 0 */ 12207 /* 12208 * if the last transfer before flushing all the 12209 * waiting I/O's, was 0 (resid = count), then we 12210 * want to give the user an error on all the rest, 12211 * so here. If there was a transfer, we set the 12212 * resid and counts to 0, and let it drop through, 12213 * giving a zero return. the next I/O will then 12214 * give an error. 12215 */ 12216 if (un->un_last_resid == un->un_last_count) { 12217 switch (un->un_pos.eof) { 12218 case ST_EOM: 12219 un->un_errno = ENOMEM; 12220 break; 12221 case ST_EOT: 12222 case ST_EOF: 12223 un->un_errno = EIO; 12224 break; 12225 } 12226 } else { 12227 /* 12228 * we know they did not have a zero, so make 12229 * sure they get one 12230 */ 12231 un->un_last_resid = un->un_last_count = 0; 12232 } 12233 } 12234 12235 12236 /* 12237 * send in a marker pkt to terminate flushing of commands by BBA (via 12238 * flush-on-errors) property. The HBA will always return TRAN_ACCEPT 12239 */ 12240 static void 12241 st_hba_unflush(struct scsi_tape *un) 12242 { 12243 ST_FUNC(ST_DEVINFO, st_hba_unflush); 12244 12245 ASSERT(mutex_owned(ST_MUTEX)); 12246 12247 if (!un->un_flush_on_errors) 12248 return; 12249 12250 #ifdef FLUSH_ON_ERRORS 12251 12252 if (!un->un_mkr_pkt) { 12253 un->un_mkr_pkt = scsi_init_pkt(ROUTE, NULL, (struct buf *)NULL, 12254 NULL, 0, 0, 0, SLEEP_FUNC, NULL); 12255 12256 /* we slept, so it must be there */ 12257 pkt->pkt_flags |= FLAG_FLUSH_MARKER; 12258 } 12259 12260 st_transport(un, un->un_mkr_pkt); 12261 #endif 12262 } 12263 12264 static char * 12265 st_print_scsi_cmd(char cmd) 12266 { 12267 char tmp[64]; 12268 char *cpnt; 12269 12270 cpnt = scsi_cmd_name(cmd, scsi_cmds, tmp); 12271 /* tmp goes out of scope on return and caller sees garbage */ 12272 if (cpnt == tmp) { 12273 cpnt = "Unknown Command"; 12274 } 12275 return (cpnt); 12276 } 12277 12278 static void 12279 st_print_cdb(dev_info_t *dip, char *label, uint_t level, 12280 char *title, char *cdb) 12281 { 12282 int len = scsi_cdb_size[CDB_GROUPID(cdb[0])]; 12283 char buf[256]; 12284 struct scsi_tape *un; 12285 int instance = ddi_get_instance(dip); 12286 12287 un = ddi_get_soft_state(st_state, instance); 12288 12289 ST_FUNC(dip, st_print_cdb); 12290 12291 /* force one line output so repeated commands are printed once */ 12292 if ((st_debug & 0x180) == 0x100) { 12293 scsi_log(dip, label, level, "node %s cmd %s\n", 12294 st_dev_name(un->un_dev), st_print_scsi_cmd(*cdb)); 12295 return; 12296 } 12297 12298 /* force one line output so repeated CDB's are printed once */ 12299 if ((st_debug & 0x180) == 0x80) { 12300 st_clean_print(dip, label, level, NULL, cdb, len); 12301 } else { 12302 (void) sprintf(buf, "%s for cmd(%s)", title, 12303 st_print_scsi_cmd(*cdb)); 12304 st_clean_print(dip, label, level, buf, cdb, len); 12305 } 12306 } 12307 12308 static void 12309 st_clean_print(dev_info_t *dev, char *label, uint_t level, 12310 char *title, char *data, int len) 12311 { 12312 int i; 12313 int c; 12314 char *format; 12315 char buf[256]; 12316 uchar_t byte; 12317 12318 ST_FUNC(dev, st_clean_print); 12319 12320 12321 if (title) { 12322 (void) sprintf(buf, "%s:\n", title); 12323 scsi_log(dev, label, level, "%s", buf); 12324 level = CE_CONT; 12325 } 12326 12327 for (i = 0; i < len; ) { 12328 buf[0] = 0; 12329 for (c = 0; c < 8 && i < len; c++, i++) { 12330 byte = (uchar_t)data[i]; 12331 if (byte < 0x10) 12332 format = "0x0%x "; 12333 else 12334 format = "0x%x "; 12335 (void) sprintf(&buf[(int)strlen(buf)], format, byte); 12336 } 12337 (void) sprintf(&buf[(int)strlen(buf)], "\n"); 12338 12339 scsi_log(dev, label, level, "%s\n", buf); 12340 level = CE_CONT; 12341 } 12342 } 12343 12344 /* 12345 * Conditionally enabled debugging 12346 */ 12347 #ifdef STDEBUG 12348 static void 12349 st_debug_cmds(struct scsi_tape *un, int com, int count, int wait) 12350 { 12351 char tmpbuf[64]; 12352 12353 ST_FUNC(ST_DEVINFO, st_debug_cmds); 12354 12355 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12356 "cmd=%s count=0x%x (%d) %ssync\n", 12357 scsi_cmd_name(com, scsi_cmds, tmpbuf), 12358 count, count, 12359 wait == ASYNC_CMD ? "a" : ""); 12360 } 12361 #endif /* STDEBUG */ 12362 12363 /* 12364 * Returns pointer to name of minor node name of device 'dev'. 12365 */ 12366 static char * 12367 st_dev_name(dev_t dev) 12368 { 12369 struct scsi_tape *un; 12370 const char density[] = { 'l', 'm', 'h', 'c' }; 12371 static char name[32]; 12372 minor_t minor; 12373 int instance; 12374 int nprt = 0; 12375 12376 minor = getminor(dev); 12377 instance = ((minor & 0xff80) >> 5) | (minor & 3); 12378 un = ddi_get_soft_state(st_state, instance); 12379 if (un) { 12380 ST_FUNC(ST_DEVINFO, st_dev_name); 12381 } 12382 12383 name[nprt] = density[(minor & MT_DENSITY_MASK) >> 3]; 12384 12385 if (minor & MT_BSD) { 12386 name[++nprt] = 'b'; 12387 } 12388 12389 if (minor & MT_NOREWIND) { 12390 name[++nprt] = 'n'; 12391 } 12392 12393 /* NULL terminator */ 12394 name[++nprt] = 0; 12395 12396 return (name); 12397 } 12398 12399 /* 12400 * Soft error reporting, so far unique to each drive 12401 * 12402 * Currently supported: exabyte and DAT soft error reporting 12403 */ 12404 static int 12405 st_report_exabyte_soft_errors(dev_t dev, int flag) 12406 { 12407 uchar_t *sensep; 12408 int amt; 12409 int rval = 0; 12410 char cdb[CDB_GROUP0], *c = cdb; 12411 struct uscsi_cmd *com; 12412 12413 GET_SOFT_STATE(dev); 12414 12415 ST_FUNC(ST_DEVINFO, st_report_exabyte_soft_errors); 12416 12417 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12418 "st_report_exabyte_soft_errors(dev = 0x%lx, flag = %d)\n", 12419 dev, flag); 12420 12421 ASSERT(mutex_owned(ST_MUTEX)); 12422 12423 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 12424 sensep = kmem_zalloc(TAPE_SENSE_LENGTH, KM_SLEEP); 12425 12426 *c++ = SCMD_REQUEST_SENSE; 12427 *c++ = 0; 12428 *c++ = 0; 12429 *c++ = 0; 12430 *c++ = TAPE_SENSE_LENGTH; 12431 /* 12432 * set CLRCNT (byte 5, bit 7 which clears the error counts) 12433 */ 12434 *c = (char)0x80; 12435 12436 com->uscsi_cdb = cdb; 12437 com->uscsi_cdblen = CDB_GROUP0; 12438 com->uscsi_bufaddr = (caddr_t)sensep; 12439 com->uscsi_buflen = TAPE_SENSE_LENGTH; 12440 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 12441 com->uscsi_timeout = un->un_dp->non_motion_timeout; 12442 12443 rval = st_uscsi_cmd(un, com, FKIOCTL); 12444 if (rval || com->uscsi_status) { 12445 goto done; 12446 } 12447 12448 /* 12449 * was there enough data? 12450 */ 12451 amt = (int)TAPE_SENSE_LENGTH - com->uscsi_resid; 12452 12453 if ((amt >= 19) && un->un_kbytes_xferred) { 12454 uint_t count, error_rate; 12455 uint_t rate; 12456 12457 if (sensep[21] & CLN) { 12458 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12459 "Periodic head cleaning required"); 12460 } 12461 if (un->un_kbytes_xferred < (EXABYTE_MIN_TRANSFER/ONE_K)) { 12462 goto done; 12463 } 12464 /* 12465 * check if soft error reporting needs to be done. 12466 */ 12467 count = sensep[16] << 16 | sensep[17] << 8 | sensep[18]; 12468 count &= 0xffffff; 12469 error_rate = (count * 100)/un->un_kbytes_xferred; 12470 12471 #ifdef STDEBUG 12472 if (st_soft_error_report_debug) { 12473 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 12474 "Exabyte Soft Error Report:\n"); 12475 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12476 "read/write error counter: %d\n", count); 12477 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12478 "number of bytes transferred: %dK\n", 12479 un->un_kbytes_xferred); 12480 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12481 "error_rate: %d%%\n", error_rate); 12482 12483 if (amt >= 22) { 12484 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12485 "unit sense: 0x%b 0x%b 0x%b\n", 12486 sensep[19], SENSE_19_BITS, 12487 sensep[20], SENSE_20_BITS, 12488 sensep[21], SENSE_21_BITS); 12489 } 12490 if (amt >= 27) { 12491 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12492 "tracking retry counter: %d\n", 12493 sensep[26]); 12494 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12495 "read/write retry counter: %d\n", 12496 sensep[27]); 12497 } 12498 } 12499 #endif 12500 12501 if (flag & FWRITE) { 12502 rate = EXABYTE_WRITE_ERROR_THRESHOLD; 12503 } else { 12504 rate = EXABYTE_READ_ERROR_THRESHOLD; 12505 } 12506 if (error_rate >= rate) { 12507 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12508 "Soft error rate (%d%%) during %s was too high", 12509 error_rate, 12510 ((flag & FWRITE) ? wrg_str : rdg_str)); 12511 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12512 "Please, replace tape cartridge\n"); 12513 } 12514 } 12515 12516 done: 12517 kmem_free(com, sizeof (*com)); 12518 kmem_free(sensep, TAPE_SENSE_LENGTH); 12519 12520 if (rval != 0) { 12521 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12522 "exabyte soft error reporting failed\n"); 12523 } 12524 return (rval); 12525 } 12526 12527 /* 12528 * this is very specific to Archive 4mm dat 12529 */ 12530 #define ONE_GIG (ONE_K * ONE_K * ONE_K) 12531 12532 static int 12533 st_report_dat_soft_errors(dev_t dev, int flag) 12534 { 12535 uchar_t *sensep; 12536 int amt, i; 12537 int rval = 0; 12538 char cdb[CDB_GROUP1], *c = cdb; 12539 struct uscsi_cmd *com; 12540 struct scsi_arq_status status; 12541 12542 GET_SOFT_STATE(dev); 12543 12544 ST_FUNC(ST_DEVINFO, st_report_dat_soft_errors); 12545 12546 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12547 "st_report_dat_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag); 12548 12549 ASSERT(mutex_owned(ST_MUTEX)); 12550 12551 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 12552 sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP); 12553 12554 *c++ = SCMD_LOG_SENSE_G1; 12555 *c++ = 0; 12556 *c++ = (flag & FWRITE) ? 0x42 : 0x43; 12557 *c++ = 0; 12558 *c++ = 0; 12559 *c++ = 0; 12560 *c++ = 2; 12561 *c++ = 0; 12562 *c++ = (char)LOG_SENSE_LENGTH; 12563 *c = 0; 12564 com->uscsi_cdb = cdb; 12565 com->uscsi_cdblen = CDB_GROUP1; 12566 com->uscsi_bufaddr = (caddr_t)sensep; 12567 com->uscsi_buflen = LOG_SENSE_LENGTH; 12568 com->uscsi_rqlen = sizeof (status); 12569 com->uscsi_rqbuf = (caddr_t)&status; 12570 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 12571 com->uscsi_timeout = un->un_dp->non_motion_timeout; 12572 rval = st_uscsi_cmd(un, com, FKIOCTL); 12573 if (rval) { 12574 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12575 "DAT soft error reporting failed\n"); 12576 } 12577 if (rval || com->uscsi_status) { 12578 goto done; 12579 } 12580 12581 /* 12582 * was there enough data? 12583 */ 12584 amt = (int)LOG_SENSE_LENGTH - com->uscsi_resid; 12585 12586 if ((amt >= MIN_LOG_SENSE_LENGTH) && un->un_kbytes_xferred) { 12587 int total, retries, param_code; 12588 12589 total = -1; 12590 retries = -1; 12591 amt = sensep[3] + 4; 12592 12593 12594 #ifdef STDEBUG 12595 if (st_soft_error_report_debug) { 12596 (void) printf("logsense:"); 12597 for (i = 0; i < MIN_LOG_SENSE_LENGTH; i++) { 12598 if (i % 16 == 0) { 12599 (void) printf("\t\n"); 12600 } 12601 (void) printf(" %x", sensep[i]); 12602 } 12603 (void) printf("\n"); 12604 } 12605 #endif 12606 12607 /* 12608 * parse the param_codes 12609 */ 12610 if (sensep[0] == 2 || sensep[0] == 3) { 12611 for (i = 4; i < amt; i++) { 12612 param_code = (sensep[i++] << 8); 12613 param_code += sensep[i++]; 12614 i++; /* skip control byte */ 12615 if (param_code == 5) { 12616 if (sensep[i++] == 4) { 12617 total = (sensep[i++] << 24); 12618 total += (sensep[i++] << 16); 12619 total += (sensep[i++] << 8); 12620 total += sensep[i]; 12621 } 12622 } else if (param_code == 0x8007) { 12623 if (sensep[i++] == 2) { 12624 retries = sensep[i++] << 8; 12625 retries += sensep[i]; 12626 } 12627 } else { 12628 i += sensep[i]; 12629 } 12630 } 12631 } 12632 12633 /* 12634 * if the log sense returned valid numbers then determine 12635 * the read and write error thresholds based on the amount of 12636 * data transferred 12637 */ 12638 12639 if (total > 0 && retries > 0) { 12640 short normal_retries = 0; 12641 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 12642 "total xferred (%s) =%x, retries=%x\n", 12643 ((flag & FWRITE) ? wrg_str : rdg_str), 12644 total, retries); 12645 12646 if (flag & FWRITE) { 12647 if (total <= 12648 WRITE_SOFT_ERROR_WARNING_THRESHOLD) { 12649 normal_retries = 12650 DAT_SMALL_WRITE_ERROR_THRESHOLD; 12651 } else { 12652 normal_retries = 12653 DAT_LARGE_WRITE_ERROR_THRESHOLD; 12654 } 12655 } else { 12656 if (total <= 12657 READ_SOFT_ERROR_WARNING_THRESHOLD) { 12658 normal_retries = 12659 DAT_SMALL_READ_ERROR_THRESHOLD; 12660 } else { 12661 normal_retries = 12662 DAT_LARGE_READ_ERROR_THRESHOLD; 12663 } 12664 } 12665 12666 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 12667 "normal retries=%d\n", normal_retries); 12668 12669 if (retries >= normal_retries) { 12670 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12671 "Soft error rate (retries = %d) during " 12672 "%s was too high", retries, 12673 ((flag & FWRITE) ? wrg_str : rdg_str)); 12674 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12675 "Periodic head cleaning required " 12676 "and/or replace tape cartridge\n"); 12677 } 12678 12679 } else if (total == -1 || retries == -1) { 12680 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12681 "log sense parameter code does not make sense\n"); 12682 } 12683 } 12684 12685 /* 12686 * reset all values 12687 */ 12688 c = cdb; 12689 *c++ = SCMD_LOG_SELECT_G1; 12690 *c++ = 2; /* this resets all values */ 12691 *c++ = (char)0xc0; 12692 *c++ = 0; 12693 *c++ = 0; 12694 *c++ = 0; 12695 *c++ = 0; 12696 *c++ = 0; 12697 *c++ = 0; 12698 *c = 0; 12699 com->uscsi_bufaddr = NULL; 12700 com->uscsi_buflen = 0; 12701 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT; 12702 rval = st_uscsi_cmd(un, com, FKIOCTL); 12703 if (rval) { 12704 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12705 "DAT soft error reset failed\n"); 12706 } 12707 done: 12708 kmem_free(com, sizeof (*com)); 12709 kmem_free(sensep, LOG_SENSE_LENGTH); 12710 return (rval); 12711 } 12712 12713 static int 12714 st_report_soft_errors(dev_t dev, int flag) 12715 { 12716 GET_SOFT_STATE(dev); 12717 12718 ST_FUNC(ST_DEVINFO, st_report_soft_errors); 12719 12720 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12721 "st_report_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag); 12722 12723 ASSERT(mutex_owned(ST_MUTEX)); 12724 12725 switch (un->un_dp->type) { 12726 case ST_TYPE_EXB8500: 12727 case ST_TYPE_EXABYTE: 12728 return (st_report_exabyte_soft_errors(dev, flag)); 12729 /*NOTREACHED*/ 12730 case ST_TYPE_PYTHON: 12731 return (st_report_dat_soft_errors(dev, flag)); 12732 /*NOTREACHED*/ 12733 default: 12734 un->un_dp->options &= ~ST_SOFT_ERROR_REPORTING; 12735 return (-1); 12736 } 12737 } 12738 12739 /* 12740 * persistent error routines 12741 */ 12742 12743 /* 12744 * enable persistent errors, and set the throttle appropriately, checking 12745 * for flush-on-errors capability 12746 */ 12747 static void 12748 st_turn_pe_on(struct scsi_tape *un) 12749 { 12750 ST_FUNC(ST_DEVINFO, st_turn_pe_on); 12751 12752 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_on\n"); 12753 ASSERT(mutex_owned(ST_MUTEX)); 12754 12755 un->un_persistence = 1; 12756 12757 /* 12758 * only use flush-on-errors if auto-request-sense and untagged-qing are 12759 * enabled. This will simplify the error handling for request senses 12760 */ 12761 12762 if (un->un_arq_enabled && un->un_untagged_qing) { 12763 uchar_t f_o_e; 12764 12765 mutex_exit(ST_MUTEX); 12766 f_o_e = (scsi_ifsetcap(ROUTE, "flush-on-errors", 1, 1) == 1) ? 12767 1 : 0; 12768 mutex_enter(ST_MUTEX); 12769 12770 un->un_flush_on_errors = f_o_e; 12771 } else { 12772 un->un_flush_on_errors = 0; 12773 } 12774 12775 if (un->un_flush_on_errors) 12776 un->un_max_throttle = (uchar_t)st_max_throttle; 12777 else 12778 un->un_max_throttle = 1; 12779 12780 if (un->un_dp->options & ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) 12781 un->un_max_throttle = 1; 12782 12783 /* this will send a marker pkt */ 12784 st_clear_pe(un); 12785 } 12786 12787 /* 12788 * This turns persistent errors permanently off 12789 */ 12790 static void 12791 st_turn_pe_off(struct scsi_tape *un) 12792 { 12793 ST_FUNC(ST_DEVINFO, st_turn_pe_off); 12794 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_off\n"); 12795 ASSERT(mutex_owned(ST_MUTEX)); 12796 12797 /* turn it off for good */ 12798 un->un_persistence = 0; 12799 12800 /* this will send a marker pkt */ 12801 st_clear_pe(un); 12802 12803 /* turn off flush on error capability, if enabled */ 12804 if (un->un_flush_on_errors) { 12805 mutex_exit(ST_MUTEX); 12806 (void) scsi_ifsetcap(ROUTE, "flush-on-errors", 0, 1); 12807 mutex_enter(ST_MUTEX); 12808 } 12809 12810 12811 un->un_flush_on_errors = 0; 12812 } 12813 12814 /* 12815 * This clear persistent errors, allowing more commands through, and also 12816 * sending a marker packet. 12817 */ 12818 static void 12819 st_clear_pe(struct scsi_tape *un) 12820 { 12821 ST_FUNC(ST_DEVINFO, st_clear_pe); 12822 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_clear\n"); 12823 ASSERT(mutex_owned(ST_MUTEX)); 12824 12825 un->un_persist_errors = 0; 12826 un->un_throttle = un->un_last_throttle = 1; 12827 un->un_errno = 0; 12828 st_hba_unflush(un); 12829 } 12830 12831 /* 12832 * This will flag persistent errors, shutting everything down, if the 12833 * application had enabled persistent errors via MTIOCPERSISTENT 12834 */ 12835 static void 12836 st_set_pe_flag(struct scsi_tape *un) 12837 { 12838 ST_FUNC(ST_DEVINFO, st_set_pe_flag); 12839 ASSERT(mutex_owned(ST_MUTEX)); 12840 12841 if (un->un_persistence) { 12842 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_flag\n"); 12843 un->un_persist_errors = 1; 12844 un->un_throttle = un->un_last_throttle = 0; 12845 cv_broadcast(&un->un_sbuf_cv); 12846 } 12847 } 12848 12849 static int 12850 st_do_reserve(struct scsi_tape *un) 12851 { 12852 int rval; 12853 int was_lost = un->un_rsvd_status & ST_LOST_RESERVE; 12854 12855 ST_FUNC(ST_DEVINFO, st_do_reserve); 12856 12857 /* 12858 * Issue a Throw-Away reserve command to clear the 12859 * check condition. 12860 * If the current behaviour of reserve/release is to 12861 * hold reservation across opens , and if a Bus reset 12862 * has been issued between opens then this command 12863 * would set the ST_LOST_RESERVE flags in rsvd_status. 12864 * In this case return an EACCES so that user knows that 12865 * reservation has been lost in between opens. 12866 * If this error is not returned and we continue with 12867 * successful open , then user may think position of the 12868 * tape is still the same but inreality we would rewind the 12869 * tape and continue from BOT. 12870 */ 12871 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12872 if (rval) { 12873 if ((un->un_rsvd_status & ST_LOST_RESERVE_BETWEEN_OPENS) == 12874 ST_LOST_RESERVE_BETWEEN_OPENS) { 12875 un->un_rsvd_status &= ~(ST_LOST_RESERVE | ST_RESERVE); 12876 un->un_errno = EACCES; 12877 return (EACCES); 12878 } 12879 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12880 } 12881 if (rval == 0) { 12882 un->un_rsvd_status |= ST_INIT_RESERVE; 12883 } 12884 if (was_lost) { 12885 un->un_running.pmode = invalid; 12886 } 12887 12888 return (rval); 12889 } 12890 12891 static int 12892 st_check_cdb_for_need_to_reserve(struct scsi_tape *un, uchar_t *cdb) 12893 { 12894 int rval; 12895 cmd_attribute const *attrib; 12896 12897 ST_FUNC(ST_DEVINFO, st_check_cdb_for_need_to_reserve); 12898 12899 /* 12900 * If already reserved no need to do it again. 12901 * Also if Reserve and Release are disabled Just return. 12902 */ 12903 if ((un->un_rsvd_status & (ST_APPLICATION_RESERVATIONS)) || 12904 ((un->un_rsvd_status & (ST_RESERVE | ST_LOST_RESERVE)) == 12905 ST_RESERVE) || (un->un_dp->options & ST_NO_RESERVE_RELEASE)) { 12906 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12907 "st_check_cdb_for_need_to_reserve() reserve unneeded %s", 12908 st_print_scsi_cmd((uchar_t)cdb[0])); 12909 return (0); 12910 } 12911 12912 /* See if command is on the list */ 12913 attrib = st_lookup_cmd_attribute(cdb[0]); 12914 12915 if (attrib == NULL) { 12916 rval = 1; /* Not found, when in doubt reserve */ 12917 } else if ((attrib->requires_reserve) != 0) { 12918 rval = 1; 12919 } else if ((attrib->reserve_byte) != 0) { 12920 /* 12921 * cmd is on list. 12922 * if byte is zero always allowed. 12923 */ 12924 rval = 1; 12925 } else if (((cdb[attrib->reserve_byte]) & 12926 (attrib->reserve_mask)) != 0) { 12927 rval = 1; 12928 } else { 12929 rval = 0; 12930 } 12931 12932 if (rval) { 12933 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12934 "Command %s requires reservation", 12935 st_print_scsi_cmd(cdb[0])); 12936 12937 rval = st_do_reserve(un); 12938 } 12939 12940 return (rval); 12941 } 12942 12943 static int 12944 st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd, int cnt) 12945 { 12946 int rval; 12947 cmd_attribute const *attrib; 12948 12949 ST_FUNC(ST_DEVINFO, st_check_cmd_for_need_to_reserve); 12950 12951 /* 12952 * Do not reserve when already reserved, when not supported or when 12953 * auto-rewinding on device closure. 12954 */ 12955 if ((un->un_rsvd_status & (ST_APPLICATION_RESERVATIONS)) || 12956 ((un->un_rsvd_status & (ST_RESERVE | ST_LOST_RESERVE)) == 12957 ST_RESERVE) || (un->un_dp->options & ST_NO_RESERVE_RELEASE) || 12958 ((un->un_state == ST_STATE_CLOSING) && (cmd == SCMD_REWIND))) { 12959 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12960 "st_check_cmd_for_need_to_reserve() reserve unneeded %s", 12961 st_print_scsi_cmd(cmd)); 12962 return (0); 12963 } 12964 12965 /* search for this command on the list */ 12966 attrib = st_lookup_cmd_attribute(cmd); 12967 12968 if (attrib == NULL) { 12969 rval = 1; /* Not found, when in doubt reserve */ 12970 } else if ((attrib->requires_reserve) != 0) { 12971 rval = 1; 12972 } else if ((attrib->reserve_byte) != 0) { 12973 /* 12974 * cmd is on list. 12975 * if byte is zero always allowed. 12976 */ 12977 rval = 1; 12978 } else if (((attrib->reserve_mask) & cnt) != 0) { 12979 rval = 1; 12980 } else { 12981 rval = 0; 12982 } 12983 12984 if (rval) { 12985 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12986 "Cmd %s requires reservation", st_print_scsi_cmd(cmd)); 12987 12988 rval = st_do_reserve(un); 12989 } 12990 12991 return (rval); 12992 } 12993 12994 static int 12995 st_reserve_release(struct scsi_tape *un, int cmd, ubufunc_t ubf) 12996 { 12997 struct uscsi_cmd uscsi_cmd; 12998 int rval; 12999 char cdb[CDB_GROUP0]; 13000 struct scsi_arq_status stat; 13001 13002 13003 13004 ST_FUNC(ST_DEVINFO, st_reserve_release); 13005 13006 ASSERT(mutex_owned(ST_MUTEX)); 13007 13008 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13009 "st_reserve_release: %s \n", 13010 (cmd == ST_RELEASE)? "Releasing":"Reserving"); 13011 13012 bzero(&cdb, CDB_GROUP0); 13013 if (cmd == ST_RELEASE) { 13014 cdb[0] = SCMD_RELEASE; 13015 } else { 13016 cdb[0] = SCMD_RESERVE; 13017 } 13018 bzero(&uscsi_cmd, sizeof (struct uscsi_cmd)); 13019 uscsi_cmd.uscsi_flags = USCSI_WRITE | USCSI_RQENABLE; 13020 uscsi_cmd.uscsi_cdb = cdb; 13021 uscsi_cmd.uscsi_cdblen = CDB_GROUP0; 13022 uscsi_cmd.uscsi_timeout = un->un_dp->non_motion_timeout; 13023 uscsi_cmd.uscsi_rqbuf = (caddr_t)&stat; 13024 uscsi_cmd.uscsi_rqlen = sizeof (stat); 13025 13026 rval = ubf(un, &uscsi_cmd, FKIOCTL); 13027 13028 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13029 "st_reserve_release: rval(1)=%d\n", rval); 13030 13031 if (rval) { 13032 if (uscsi_cmd.uscsi_status == STATUS_RESERVATION_CONFLICT) { 13033 rval = EACCES; 13034 } 13035 /* 13036 * dynamically turn off reserve/release support 13037 * in case of drives which do not support 13038 * reserve/release command(ATAPI drives). 13039 */ 13040 if (un->un_status == KEY_ILLEGAL_REQUEST) { 13041 if ((un->un_dp->options & ST_NO_RESERVE_RELEASE) == 0) { 13042 un->un_dp->options |= ST_NO_RESERVE_RELEASE; 13043 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13044 "Tape unit does not support " 13045 "reserve/release \n"); 13046 } 13047 rval = 0; 13048 } 13049 } 13050 return (rval); 13051 } 13052 13053 static int 13054 st_take_ownership(struct scsi_tape *un, ubufunc_t ubf) 13055 { 13056 int rval; 13057 13058 ST_FUNC(ST_DEVINFO, st_take_ownership); 13059 13060 ASSERT(mutex_owned(ST_MUTEX)); 13061 13062 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13063 "st_take_ownership: Entering ...\n"); 13064 13065 13066 rval = st_reserve_release(un, ST_RESERVE, ubf); 13067 /* 13068 * XXX -> Should reset be done only if we get EACCES. 13069 * . 13070 */ 13071 if (rval) { 13072 if (st_reset(un, RESET_LUN) == 0) { 13073 return (EIO); 13074 } 13075 un->un_rsvd_status &= 13076 ~(ST_LOST_RESERVE | ST_RESERVATION_CONFLICT); 13077 13078 mutex_exit(ST_MUTEX); 13079 delay(drv_usectohz(ST_RESERVATION_DELAY)); 13080 mutex_enter(ST_MUTEX); 13081 /* 13082 * remove the check condition. 13083 */ 13084 (void) st_reserve_release(un, ST_RESERVE, ubf); 13085 rval = st_reserve_release(un, ST_RESERVE, ubf); 13086 if (rval != 0) { 13087 if ((st_reserve_release(un, ST_RESERVE, ubf)) 13088 != 0) { 13089 rval = (un->un_rsvd_status & 13090 ST_RESERVATION_CONFLICT) ? EACCES : EIO; 13091 return (rval); 13092 } 13093 } 13094 /* 13095 * Set tape state to ST_STATE_OFFLINE , in case if 13096 * the user wants to continue and start using 13097 * the tape. 13098 */ 13099 un->un_state = ST_STATE_OFFLINE; 13100 un->un_rsvd_status |= ST_INIT_RESERVE; 13101 } 13102 return (rval); 13103 } 13104 13105 static int 13106 st_create_errstats(struct scsi_tape *un, int instance) 13107 { 13108 char kstatname[KSTAT_STRLEN]; 13109 13110 ST_FUNC(ST_DEVINFO, st_create_errstats); 13111 13112 /* 13113 * Create device error kstats 13114 */ 13115 13116 if (un->un_errstats == (kstat_t *)0) { 13117 (void) sprintf(kstatname, "st%d,err", instance); 13118 un->un_errstats = kstat_create("sterr", instance, kstatname, 13119 "device_error", KSTAT_TYPE_NAMED, 13120 sizeof (struct st_errstats) / sizeof (kstat_named_t), 13121 KSTAT_FLAG_PERSISTENT); 13122 13123 if (un->un_errstats) { 13124 struct st_errstats *stp; 13125 13126 stp = (struct st_errstats *)un->un_errstats->ks_data; 13127 kstat_named_init(&stp->st_softerrs, "Soft Errors", 13128 KSTAT_DATA_ULONG); 13129 kstat_named_init(&stp->st_harderrs, "Hard Errors", 13130 KSTAT_DATA_ULONG); 13131 kstat_named_init(&stp->st_transerrs, "Transport Errors", 13132 KSTAT_DATA_ULONG); 13133 kstat_named_init(&stp->st_vid, "Vendor", 13134 KSTAT_DATA_CHAR); 13135 kstat_named_init(&stp->st_pid, "Product", 13136 KSTAT_DATA_CHAR); 13137 kstat_named_init(&stp->st_revision, "Revision", 13138 KSTAT_DATA_CHAR); 13139 kstat_named_init(&stp->st_serial, "Serial No", 13140 KSTAT_DATA_CHAR); 13141 un->un_errstats->ks_private = un; 13142 un->un_errstats->ks_update = nulldev; 13143 kstat_install(un->un_errstats); 13144 /* 13145 * Fill in the static data 13146 */ 13147 (void) strncpy(&stp->st_vid.value.c[0], 13148 ST_INQUIRY->inq_vid, 8); 13149 /* 13150 * XXX: Emulex MT-02 (and emulators) predates 13151 * SCSI-1 and has no vid & pid inquiry data. 13152 */ 13153 if (ST_INQUIRY->inq_len != 0) { 13154 (void) strncpy(&stp->st_pid.value.c[0], 13155 ST_INQUIRY->inq_pid, 16); 13156 (void) strncpy(&stp->st_revision.value.c[0], 13157 ST_INQUIRY->inq_revision, 4); 13158 } 13159 } 13160 } 13161 return (0); 13162 } 13163 13164 static int 13165 st_validate_tapemarks(struct scsi_tape *un, ubufunc_t ubf, tapepos_t *pos) 13166 { 13167 int rval; 13168 bufunc_t bf = (ubf == st_uscsi_rcmd) ? st_rcmd : st_cmd; 13169 13170 ST_FUNC(ST_DEVINFO, st_validate_tapemarks); 13171 13172 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 13173 ASSERT(mutex_owned(ST_MUTEX)); 13174 13175 /* Can't restore an invalid position */ 13176 if (pos->pmode == invalid) { 13177 return (4); 13178 } 13179 13180 /* 13181 * Assumtions: 13182 * If a position was read and is in logical position mode. 13183 * If a drive supports read position it supports locate. 13184 * If the read position type is not NO_POS. even though 13185 * a read position make not have been attemped yet. 13186 * 13187 * The drive can locate to the position. 13188 */ 13189 if (pos->pmode == logical || un->un_read_pos_type != NO_POS) { 13190 /* 13191 * If position mode is logical or legacy mode try 13192 * to locate there as it is faster. 13193 * If it fails try the old way. 13194 */ 13195 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 13196 "Restoring tape position to lgclblkbo=0x%"PRIx64"....", 13197 pos->lgclblkno); 13198 13199 if (st_logical_block_locate(un, st_uscsi_cmd, &un->un_pos, 13200 pos->lgclblkno, pos->partition) == 0) { 13201 /* Assume we are there copy rest of position back */ 13202 if (un->un_pos.lgclblkno == pos->lgclblkno) { 13203 COPY_POS(&un->un_pos, pos); 13204 } 13205 return (0); 13206 } 13207 13208 /* 13209 * If logical block locate failed to restore a logical 13210 * position, can't recover. 13211 */ 13212 if (pos->pmode == logical) { 13213 return (-1); 13214 } 13215 } 13216 13217 13218 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 13219 "Restoring tape position at fileno=%x, blkno=%x....", 13220 pos->fileno, pos->blkno); 13221 13222 /* 13223 * Rewind ? Oh yeah, Fidelity has got the STK F/W changed 13224 * so as not to rewind tape on RESETS: Gee, Has life ever 13225 * been simple in tape land ? 13226 */ 13227 rval = bf(un, SCMD_REWIND, 0, SYNC_CMD); 13228 if (rval) { 13229 scsi_log(ST_DEVINFO, st_label, CE_WARN, 13230 "Failed to restore the last file and block position: In" 13231 " this state, Tape will be loaded at BOT during next open"); 13232 un->un_pos.pmode = invalid; 13233 return (rval); 13234 } 13235 13236 /* If the position was as the result of back space file */ 13237 if (pos->blkno > (INF / 2)) { 13238 /* Go one extra file forward */ 13239 pos->fileno++; 13240 /* Figure how many blocks to back into the previous file */ 13241 pos->blkno = -(INF - pos->blkno); 13242 } 13243 13244 /* Go to requested fileno */ 13245 if (pos->fileno) { 13246 rval = st_cmd(un, SCMD_SPACE, Fmk(pos->fileno), SYNC_CMD); 13247 if (rval) { 13248 scsi_log(ST_DEVINFO, st_label, CE_WARN, 13249 "Failed to restore the last file position: In this " 13250 " state, Tape will be loaded at BOT during next" 13251 " open %d", __LINE__); 13252 un->un_pos.pmode = invalid; 13253 pos->pmode = invalid; 13254 return (rval); 13255 } 13256 } 13257 13258 /* 13259 * If backing into a file we already did an extra file forward. 13260 * Now we have to back over the filemark to get to the end of 13261 * the previous file. The blkno has been ajusted to a negative 13262 * value so we will get to the expected location. 13263 */ 13264 if (pos->blkno) { 13265 rval = bf(un, SCMD_SPACE, Fmk(-1), SYNC_CMD); 13266 if (rval) { 13267 scsi_log(ST_DEVINFO, st_label, CE_WARN, 13268 "Failed to restore the last file position: In this " 13269 " state, Tape will be loaded at BOT during next" 13270 " open %d", __LINE__); 13271 un->un_pos.pmode = invalid; 13272 pos->pmode = invalid; 13273 return (rval); 13274 } 13275 } 13276 13277 /* 13278 * The position mode, block and fileno should be correct, 13279 * This updates eof and logical position information. 13280 */ 13281 un->un_pos.eof = pos->eof; 13282 un->un_pos.lgclblkno = pos->lgclblkno; 13283 13284 return (0); 13285 } 13286 13287 /* 13288 * check sense key, ASC, ASCQ in order to determine if the tape needs 13289 * to be ejected 13290 */ 13291 13292 static int 13293 st_check_asc_ascq(struct scsi_tape *un) 13294 { 13295 struct scsi_extended_sense *sensep = ST_RQSENSE; 13296 struct tape_failure_code *code; 13297 13298 ST_FUNC(ST_DEVINFO, st_check_asc_ascq); 13299 13300 for (code = st_tape_failure_code; code->key != 0xff; code++) { 13301 if ((code->key == sensep->es_key) && 13302 (code->add_code == sensep->es_add_code) && 13303 (code->qual_code == sensep->es_qual_code)) 13304 return (1); 13305 } 13306 return (0); 13307 } 13308 13309 /* 13310 * st_logpage_supported() sends a Log Sense command with 13311 * page code = 0 = Supported Log Pages Page to the device, 13312 * to see whether the page 'page' is supported. 13313 * Return values are: 13314 * -1 if the Log Sense command fails 13315 * 0 if page is not supported 13316 * 1 if page is supported 13317 */ 13318 13319 static int 13320 st_logpage_supported(struct scsi_tape *un, uchar_t page) 13321 { 13322 uchar_t *sp, *sensep; 13323 unsigned length; 13324 struct uscsi_cmd *com; 13325 struct scsi_arq_status status; 13326 int rval; 13327 char cdb[CDB_GROUP1] = { 13328 SCMD_LOG_SENSE_G1, 13329 0, 13330 SUPPORTED_LOG_PAGES_PAGE, 13331 0, 13332 0, 13333 0, 13334 0, 13335 0, 13336 (char)LOG_SENSE_LENGTH, 13337 0 13338 }; 13339 13340 ST_FUNC(ST_DEVINFO, st_logpage_supported); 13341 13342 ASSERT(mutex_owned(ST_MUTEX)); 13343 13344 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13345 sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP); 13346 13347 com->uscsi_cdb = cdb; 13348 com->uscsi_cdblen = CDB_GROUP1; 13349 com->uscsi_bufaddr = (caddr_t)sensep; 13350 com->uscsi_buflen = LOG_SENSE_LENGTH; 13351 com->uscsi_rqlen = sizeof (status); 13352 com->uscsi_rqbuf = (caddr_t)&status; 13353 com->uscsi_flags = 13354 USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 13355 com->uscsi_timeout = un->un_dp->non_motion_timeout; 13356 rval = st_uscsi_cmd(un, com, FKIOCTL); 13357 if (rval || com->uscsi_status) { 13358 /* uscsi-command failed */ 13359 rval = -1; 13360 } else { 13361 13362 sp = sensep + 3; 13363 13364 for (length = *sp++; length > 0; length--, sp++) { 13365 13366 if (*sp == page) { 13367 rval = 1; 13368 break; 13369 } 13370 } 13371 } 13372 kmem_free(com, sizeof (struct uscsi_cmd)); 13373 kmem_free(sensep, LOG_SENSE_LENGTH); 13374 return (rval); 13375 } 13376 13377 13378 /* 13379 * st_check_clean_bit() gets the status of the tape's cleaning bit. 13380 * 13381 * If the device does support the TapeAlert log page, then the cleaning bit 13382 * information will be read from this page. Otherwise we will see if one of 13383 * ST_CLN_TYPE_1, ST_CLN_TYPE_2 or ST_CLN_TYPE_3 is set in the properties of 13384 * the device, which means, that we can get the cleaning bit information via 13385 * a RequestSense command. 13386 * If both methods of getting cleaning bit information are not supported 13387 * st_check_clean_bit() will return with 0. Otherwise st_check_clean_bit() 13388 * returns with 13389 * - MTF_TAPE_CLN_SUPPORTED if cleaning bit is not set or 13390 * - MTF_TAPE_CLN_SUPPORTED | MTF_TAPE_HEAD_DIRTY if cleaning bit is set. 13391 * If the call to st_uscsi_cmd() to do the Log Sense or the Request Sense 13392 * command fails, or if the amount of Request Sense data is not enough, then 13393 * st_check_clean_bit() returns with -1. 13394 */ 13395 13396 static int 13397 st_check_clean_bit(struct scsi_tape *un) 13398 { 13399 int rval = 0; 13400 13401 ST_FUNC(ST_DEVINFO, st_check_clean_bit); 13402 13403 ASSERT(mutex_owned(ST_MUTEX)); 13404 13405 if (un->un_HeadClean & TAPE_ALERT_NOT_SUPPORTED) { 13406 return (rval); 13407 } 13408 13409 if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) { 13410 13411 rval = st_logpage_supported(un, TAPE_SEQUENTIAL_PAGE); 13412 if (rval == -1) { 13413 return (0); 13414 } 13415 if (rval == 1) { 13416 13417 un->un_HeadClean |= TAPE_SEQUENTIAL_SUPPORTED; 13418 } 13419 13420 rval = st_logpage_supported(un, TAPE_ALERT_PAGE); 13421 if (rval == -1) { 13422 return (0); 13423 } 13424 if (rval == 1) { 13425 13426 un->un_HeadClean |= TAPE_ALERT_SUPPORTED; 13427 } 13428 13429 if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) { 13430 13431 un->un_HeadClean = TAPE_ALERT_NOT_SUPPORTED; 13432 } 13433 } 13434 13435 rval = 0; 13436 13437 if (un->un_HeadClean & TAPE_SEQUENTIAL_SUPPORTED) { 13438 13439 rval = st_check_sequential_clean_bit(un); 13440 if (rval == -1) { 13441 return (0); 13442 } 13443 } 13444 13445 if ((rval == 0) && (un->un_HeadClean & TAPE_ALERT_SUPPORTED)) { 13446 13447 rval = st_check_alert_flags(un); 13448 if (rval == -1) { 13449 return (0); 13450 } 13451 } 13452 13453 if ((rval == 0) && (un->un_dp->options & ST_CLN_MASK)) { 13454 13455 rval = st_check_sense_clean_bit(un); 13456 if (rval == -1) { 13457 return (0); 13458 } 13459 } 13460 13461 /* 13462 * If found a supported means to check need to clean. 13463 */ 13464 if (rval & MTF_TAPE_CLN_SUPPORTED) { 13465 13466 /* 13467 * head needs to be cleaned. 13468 */ 13469 if (rval & MTF_TAPE_HEAD_DIRTY) { 13470 13471 /* 13472 * Print log message only first time 13473 * found needing cleaned. 13474 */ 13475 if ((un->un_HeadClean & TAPE_PREVIOUSLY_DIRTY) == 0) { 13476 13477 scsi_log(ST_DEVINFO, st_label, CE_WARN, 13478 "Periodic head cleaning required"); 13479 13480 un->un_HeadClean |= TAPE_PREVIOUSLY_DIRTY; 13481 } 13482 13483 } else { 13484 13485 un->un_HeadClean &= ~TAPE_PREVIOUSLY_DIRTY; 13486 } 13487 } 13488 13489 return (rval); 13490 } 13491 13492 13493 static int 13494 st_check_sequential_clean_bit(struct scsi_tape *un) 13495 { 13496 int rval; 13497 int ix; 13498 ushort_t parameter; 13499 struct uscsi_cmd *cmd; 13500 struct log_sequential_page *sp; 13501 struct log_sequential_page_parameter *prm; 13502 struct scsi_arq_status status; 13503 char cdb[CDB_GROUP1] = { 13504 SCMD_LOG_SENSE_G1, 13505 0, 13506 TAPE_SEQUENTIAL_PAGE | CURRENT_CUMULATIVE_VALUES, 13507 0, 13508 0, 13509 0, 13510 0, 13511 (char)(sizeof (struct log_sequential_page) >> 8), 13512 (char)(sizeof (struct log_sequential_page)), 13513 0 13514 }; 13515 13516 ST_FUNC(ST_DEVINFO, st_check_sequential_clean_bit); 13517 13518 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13519 sp = kmem_zalloc(sizeof (struct log_sequential_page), KM_SLEEP); 13520 13521 cmd->uscsi_flags = 13522 USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 13523 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 13524 cmd->uscsi_cdb = cdb; 13525 cmd->uscsi_cdblen = CDB_GROUP1; 13526 cmd->uscsi_bufaddr = (caddr_t)sp; 13527 cmd->uscsi_buflen = sizeof (struct log_sequential_page); 13528 cmd->uscsi_rqlen = sizeof (status); 13529 cmd->uscsi_rqbuf = (caddr_t)&status; 13530 13531 rval = st_uscsi_cmd(un, cmd, FKIOCTL); 13532 13533 if (rval || cmd->uscsi_status || cmd->uscsi_resid) { 13534 13535 rval = -1; 13536 13537 } else if (sp->log_page.code != TAPE_SEQUENTIAL_PAGE) { 13538 13539 rval = -1; 13540 } 13541 13542 prm = &sp->param[0]; 13543 13544 for (ix = 0; rval == 0 && ix < TAPE_SEQUENTIAL_PAGE_PARA; ix++) { 13545 13546 if (prm->log_param.length == 0) { 13547 break; 13548 } 13549 13550 parameter = (((prm->log_param.pc_hi << 8) & 0xff00) + 13551 (prm->log_param.pc_lo & 0xff)); 13552 13553 if (parameter == SEQUENTIAL_NEED_CLN) { 13554 13555 rval = MTF_TAPE_CLN_SUPPORTED; 13556 if (prm->param_value[prm->log_param.length - 1]) { 13557 13558 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13559 "sequential log says head dirty\n"); 13560 rval |= MTF_TAPE_HEAD_DIRTY; 13561 } 13562 } 13563 prm = (struct log_sequential_page_parameter *) 13564 &prm->param_value[prm->log_param.length]; 13565 } 13566 13567 kmem_free(cmd, sizeof (struct uscsi_cmd)); 13568 kmem_free(sp, sizeof (struct log_sequential_page)); 13569 13570 return (rval); 13571 } 13572 13573 13574 static int 13575 st_check_alert_flags(struct scsi_tape *un) 13576 { 13577 struct st_tape_alert *ta; 13578 struct uscsi_cmd *com; 13579 struct scsi_arq_status status; 13580 unsigned ix, length; 13581 int rval; 13582 tape_alert_flags flag; 13583 char cdb[CDB_GROUP1] = { 13584 SCMD_LOG_SENSE_G1, 13585 0, 13586 TAPE_ALERT_PAGE | CURRENT_THRESHOLD_VALUES, 13587 0, 13588 0, 13589 0, 13590 0, 13591 (char)(sizeof (struct st_tape_alert) >> 8), 13592 (char)(sizeof (struct st_tape_alert)), 13593 0 13594 }; 13595 13596 ST_FUNC(ST_DEVINFO, st_check_alert_clean_bit); 13597 13598 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13599 ta = kmem_zalloc(sizeof (struct st_tape_alert), KM_SLEEP); 13600 13601 com->uscsi_cdb = cdb; 13602 com->uscsi_cdblen = CDB_GROUP1; 13603 com->uscsi_bufaddr = (caddr_t)ta; 13604 com->uscsi_buflen = sizeof (struct st_tape_alert); 13605 com->uscsi_rqlen = sizeof (status); 13606 com->uscsi_rqbuf = (caddr_t)&status; 13607 com->uscsi_flags = 13608 USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 13609 com->uscsi_timeout = un->un_dp->non_motion_timeout; 13610 13611 rval = st_uscsi_cmd(un, com, FKIOCTL); 13612 13613 if (rval || com->uscsi_status || com->uscsi_resid) { 13614 13615 rval = -1; /* uscsi-command failed */ 13616 13617 } else if (ta->log_page.code != TAPE_ALERT_PAGE) { 13618 13619 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13620 "Not Alert Log Page returned 0x%X\n", ta->log_page.code); 13621 rval = -1; 13622 } 13623 13624 length = (ta->log_page.length_hi << 8) + ta->log_page.length_lo; 13625 13626 13627 if (length != TAPE_ALERT_PARAMETER_LENGTH) { 13628 13629 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13630 "TapeAlert length %d\n", length); 13631 } 13632 13633 13634 for (ix = 0; ix < TAPE_ALERT_MAX_PARA; ix++) { 13635 13636 /* 13637 * if rval is bad before the first pass don't bother 13638 */ 13639 if (ix == 0 && rval != 0) { 13640 13641 break; 13642 } 13643 13644 flag = ((ta->param[ix].log_param.pc_hi << 8) + 13645 ta->param[ix].log_param.pc_lo); 13646 13647 if ((ta->param[ix].param_value & 1) == 0) { 13648 continue; 13649 } 13650 /* 13651 * check to see if current parameter is of interest. 13652 * CLEAN_FOR_ERRORS is vendor specific to 9840 9940 stk's. 13653 */ 13654 if ((flag == TAF_CLEAN_NOW) || 13655 (flag == TAF_CLEAN_PERIODIC) || 13656 ((flag == CLEAN_FOR_ERRORS) && 13657 (un->un_dp->type == ST_TYPE_STK9840))) { 13658 13659 rval = MTF_TAPE_CLN_SUPPORTED; 13660 13661 13662 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13663 "alert_page drive needs clean %d\n", flag); 13664 un->un_HeadClean |= TAPE_ALERT_STILL_DIRTY; 13665 rval |= MTF_TAPE_HEAD_DIRTY; 13666 13667 } else if (flag == TAF_CLEANING_MEDIA) { 13668 13669 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13670 "alert_page drive was cleaned\n"); 13671 un->un_HeadClean &= ~TAPE_ALERT_STILL_DIRTY; 13672 } 13673 13674 } 13675 13676 /* 13677 * Report it as dirty till we see it cleaned 13678 */ 13679 if (un->un_HeadClean & TAPE_ALERT_STILL_DIRTY) { 13680 13681 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13682 "alert_page still dirty\n"); 13683 rval |= MTF_TAPE_HEAD_DIRTY; 13684 } 13685 13686 kmem_free(com, sizeof (struct uscsi_cmd)); 13687 kmem_free(ta, sizeof (struct st_tape_alert)); 13688 13689 return (rval); 13690 } 13691 13692 13693 static int 13694 st_check_sense_clean_bit(struct scsi_tape *un) 13695 { 13696 uchar_t *sensep; 13697 char cdb[CDB_GROUP0]; 13698 struct uscsi_cmd *com; 13699 ushort_t byte_pos; 13700 uchar_t bit_mask; 13701 unsigned length; 13702 int index; 13703 int rval; 13704 13705 ST_FUNC(ST_DEVINFO, st_check_sense_clean_bit); 13706 13707 /* 13708 * Since this tape does not support Tape Alert, 13709 * we now try to get the cleanbit status via 13710 * Request Sense. 13711 */ 13712 13713 if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_1) { 13714 13715 index = 0; 13716 13717 } else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_2) { 13718 13719 index = 1; 13720 13721 } else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_3) { 13722 13723 index = 2; 13724 13725 } else { 13726 13727 return (-1); 13728 } 13729 13730 byte_pos = st_cln_bit_position[index].cln_bit_byte; 13731 bit_mask = st_cln_bit_position[index].cln_bit_mask; 13732 length = byte_pos + 1; 13733 13734 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13735 sensep = kmem_zalloc(length, KM_SLEEP); 13736 13737 cdb[0] = SCMD_REQUEST_SENSE; 13738 cdb[1] = 0; 13739 cdb[2] = 0; 13740 cdb[3] = 0; 13741 cdb[4] = (char)length; 13742 cdb[5] = 0; 13743 13744 com->uscsi_cdb = cdb; 13745 com->uscsi_cdblen = CDB_GROUP0; 13746 com->uscsi_bufaddr = (caddr_t)sensep; 13747 com->uscsi_buflen = length; 13748 com->uscsi_flags = 13749 USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 13750 com->uscsi_timeout = un->un_dp->non_motion_timeout; 13751 13752 rval = st_uscsi_cmd(un, com, FKIOCTL); 13753 13754 if (rval || com->uscsi_status || com->uscsi_resid) { 13755 13756 rval = -1; 13757 13758 } else { 13759 13760 rval = MTF_TAPE_CLN_SUPPORTED; 13761 if ((sensep[byte_pos] & bit_mask) == bit_mask) { 13762 13763 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13764 "sense data says head dirty\n"); 13765 rval |= MTF_TAPE_HEAD_DIRTY; 13766 } 13767 } 13768 13769 kmem_free(com, sizeof (struct uscsi_cmd)); 13770 kmem_free(sensep, length); 13771 return (rval); 13772 } 13773 13774 /* 13775 * st_clear_unit_attention 13776 * 13777 * run test unit ready's to clear out outstanding 13778 * unit attentions. 13779 * returns zero for SUCCESS or the errno from st_cmd call 13780 */ 13781 static int 13782 st_clear_unit_attentions(dev_t dev_instance, int max_trys) 13783 { 13784 int i = 0; 13785 int rval; 13786 13787 GET_SOFT_STATE(dev_instance); 13788 ST_FUNC(ST_DEVINFO, st_clear_unit_attentions); 13789 13790 do { 13791 rval = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 13792 } while ((rval != 0) && (rval != ENXIO) && (++i < max_trys)); 13793 return (rval); 13794 } 13795 13796 static void 13797 st_calculate_timeouts(struct scsi_tape *un) 13798 { 13799 ST_FUNC(ST_DEVINFO, st_calculate_timeouts); 13800 13801 if (un->un_dp->non_motion_timeout == 0) { 13802 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13803 un->un_dp->non_motion_timeout = 13804 st_io_time * st_long_timeout_x; 13805 } else { 13806 un->un_dp->non_motion_timeout = (ushort_t)st_io_time; 13807 } 13808 } 13809 13810 if (un->un_dp->io_timeout == 0) { 13811 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13812 un->un_dp->io_timeout = st_io_time * st_long_timeout_x; 13813 } else { 13814 un->un_dp->io_timeout = (ushort_t)st_io_time; 13815 } 13816 } 13817 13818 if (un->un_dp->rewind_timeout == 0) { 13819 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13820 un->un_dp->rewind_timeout = 13821 st_space_time * st_long_timeout_x; 13822 } else { 13823 un->un_dp->rewind_timeout = (ushort_t)st_space_time; 13824 } 13825 } 13826 13827 if (un->un_dp->space_timeout == 0) { 13828 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13829 un->un_dp->space_timeout = 13830 st_space_time * st_long_timeout_x; 13831 } else { 13832 un->un_dp->space_timeout = (ushort_t)st_space_time; 13833 } 13834 } 13835 13836 if (un->un_dp->load_timeout == 0) { 13837 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13838 un->un_dp->load_timeout = 13839 st_space_time * st_long_timeout_x; 13840 } else { 13841 un->un_dp->load_timeout = (ushort_t)st_space_time; 13842 } 13843 } 13844 13845 if (un->un_dp->unload_timeout == 0) { 13846 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13847 un->un_dp->unload_timeout = 13848 st_space_time * st_long_timeout_x; 13849 } else { 13850 un->un_dp->unload_timeout = (ushort_t)st_space_time; 13851 } 13852 } 13853 13854 if (un->un_dp->erase_timeout == 0) { 13855 if (un->un_dp->options & ST_LONG_ERASE) { 13856 un->un_dp->erase_timeout = 13857 st_space_time * st_long_space_time_x; 13858 } else { 13859 un->un_dp->erase_timeout = (ushort_t)st_space_time; 13860 } 13861 } 13862 } 13863 13864 13865 static writablity 13866 st_is_not_wormable(struct scsi_tape *un) 13867 { 13868 ST_FUNC(ST_DEVINFO, st_is_not_wormable); 13869 return (RDWR); 13870 } 13871 13872 static writablity 13873 st_is_hp_dat_tape_worm(struct scsi_tape *un) 13874 { 13875 writablity wrt; 13876 13877 ST_FUNC(ST_DEVINFO, st_is_hp_dat_tape_worm); 13878 13879 /* Mode sense should be current */ 13880 if (un->un_mspl->media_type == 1) { 13881 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13882 "Drive has WORM media loaded\n"); 13883 wrt = WORM; 13884 } else { 13885 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13886 "Drive has non WORM media loaded\n"); 13887 wrt = RDWR; 13888 } 13889 return (wrt); 13890 } 13891 13892 #define HP_DAT_INQUIRY 0x4A 13893 static writablity 13894 st_is_hp_dat_worm(struct scsi_tape *un) 13895 { 13896 char *buf; 13897 int result; 13898 writablity wrt; 13899 13900 ST_FUNC(ST_DEVINFO, st_is_hp_dat_worm); 13901 13902 buf = kmem_zalloc(HP_DAT_INQUIRY, KM_SLEEP); 13903 13904 result = st_get_special_inquiry(un, HP_DAT_INQUIRY, buf, 0); 13905 13906 if (result != 0) { 13907 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13908 "Read Standard Inquiry for WORM support failed"); 13909 wrt = FAILED; 13910 } else if ((buf[40] & 1) == 0) { 13911 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13912 "Drive is NOT WORMable\n"); 13913 /* This drive doesn't support it so don't check again */ 13914 un->un_dp->options &= ~ST_WORMABLE; 13915 wrt = RDWR; 13916 un->un_wormable = st_is_not_wormable; 13917 } else { 13918 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13919 "Drive supports WORM version %d\n", buf[40] >> 1); 13920 un->un_wormable = st_is_hp_dat_tape_worm; 13921 wrt = un->un_wormable(un); 13922 } 13923 13924 kmem_free(buf, HP_DAT_INQUIRY); 13925 13926 /* 13927 * If drive doesn't support it no point in checking further. 13928 */ 13929 return (wrt); 13930 } 13931 13932 static writablity 13933 st_is_hp_lto_tape_worm(struct scsi_tape *un) 13934 { 13935 writablity wrt; 13936 13937 ST_FUNC(ST_DEVINFO, st_is_hp_lto_tape_worm); 13938 13939 /* Mode sense should be current */ 13940 switch (un->un_mspl->media_type) { 13941 case 0x00: 13942 switch (un->un_mspl->density) { 13943 case 0x40: 13944 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13945 "Drive has standard Gen I media loaded\n"); 13946 break; 13947 case 0x42: 13948 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13949 "Drive has standard Gen II media loaded\n"); 13950 break; 13951 case 0x44: 13952 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13953 "Drive has standard Gen III media loaded\n"); 13954 break; 13955 case 0x46: 13956 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13957 "Drive has standard Gen IV media loaded\n"); 13958 break; 13959 default: 13960 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13961 "Drive has standard unknown 0x%X media loaded\n", 13962 un->un_mspl->density); 13963 } 13964 wrt = RDWR; 13965 break; 13966 case 0x01: 13967 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13968 "Drive has WORM medium loaded\n"); 13969 wrt = WORM; 13970 break; 13971 case 0x80: 13972 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13973 "Drive has CD-ROM emulation medium loaded\n"); 13974 wrt = WORM; 13975 break; 13976 default: 13977 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13978 "Drive has an unexpected medium type 0x%X loaded\n", 13979 un->un_mspl->media_type); 13980 wrt = RDWR; 13981 } 13982 13983 return (wrt); 13984 } 13985 13986 #define LTO_REQ_INQUIRY 44 13987 static writablity 13988 st_is_hp_lto_worm(struct scsi_tape *un) 13989 { 13990 char *buf; 13991 int result; 13992 writablity wrt; 13993 13994 ST_FUNC(ST_DEVINFO, st_is_hp_lto_worm); 13995 13996 buf = kmem_zalloc(LTO_REQ_INQUIRY, KM_SLEEP); 13997 13998 result = st_get_special_inquiry(un, LTO_REQ_INQUIRY, buf, 0); 13999 14000 if (result != 0) { 14001 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14002 "Read Standard Inquiry for WORM support failed"); 14003 wrt = FAILED; 14004 } else if ((buf[40] & 1) == 0) { 14005 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14006 "Drive is NOT WORMable\n"); 14007 /* This drive doesn't support it so don't check again */ 14008 un->un_dp->options &= ~ST_WORMABLE; 14009 wrt = RDWR; 14010 un->un_wormable = st_is_not_wormable; 14011 } else { 14012 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14013 "Drive supports WORM version %d\n", buf[40] >> 1); 14014 un->un_wormable = st_is_hp_lto_tape_worm; 14015 wrt = un->un_wormable(un); 14016 } 14017 14018 kmem_free(buf, LTO_REQ_INQUIRY); 14019 14020 /* 14021 * If drive doesn't support it no point in checking further. 14022 */ 14023 return (wrt); 14024 } 14025 14026 static writablity 14027 st_is_t10_worm_device(struct scsi_tape *un) 14028 { 14029 writablity wrt; 14030 14031 ST_FUNC(ST_DEVINFO, st_is_t10_worm_device); 14032 14033 if (un->un_mspl->media_type == 0x3c) { 14034 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14035 "Drive has WORM media loaded\n"); 14036 wrt = WORM; 14037 } else { 14038 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14039 "Drive has non WORM media loaded\n"); 14040 wrt = RDWR; 14041 } 14042 return (wrt); 14043 } 14044 14045 #define SEQ_CAP_PAGE (char)0xb0 14046 static writablity 14047 st_is_t10_worm(struct scsi_tape *un) 14048 { 14049 char *buf; 14050 int result; 14051 writablity wrt; 14052 14053 ST_FUNC(ST_DEVINFO, st_is_t10_worm); 14054 14055 buf = kmem_zalloc(6, KM_SLEEP); 14056 14057 result = st_get_special_inquiry(un, 6, buf, SEQ_CAP_PAGE); 14058 14059 if (result != 0) { 14060 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14061 "Read Vitial Inquiry for Sequental Capability" 14062 " WORM support failed %x", result); 14063 wrt = FAILED; 14064 } else if ((buf[4] & 1) == 0) { 14065 ASSERT(buf[1] == SEQ_CAP_PAGE); 14066 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14067 "Drive is NOT WORMable\n"); 14068 /* This drive doesn't support it so don't check again */ 14069 un->un_dp->options &= ~ST_WORMABLE; 14070 wrt = RDWR; 14071 un->un_wormable = st_is_not_wormable; 14072 } else { 14073 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14074 "Drive supports WORM\n"); 14075 un->un_wormable = st_is_t10_worm_device; 14076 wrt = un->un_wormable(un); 14077 } 14078 14079 kmem_free(buf, 6); 14080 14081 return (wrt); 14082 } 14083 14084 14085 #define STK_REQ_SENSE 26 14086 14087 static writablity 14088 st_is_stk_worm(struct scsi_tape *un) 14089 { 14090 char cdb[CDB_GROUP0] = {SCMD_REQUEST_SENSE, 0, 0, 0, STK_REQ_SENSE, 0}; 14091 struct scsi_extended_sense *sense; 14092 struct uscsi_cmd *cmd; 14093 char *buf; 14094 int result; 14095 writablity wrt; 14096 14097 ST_FUNC(ST_DEVINFO, st_is_stk_worm); 14098 14099 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 14100 buf = kmem_alloc(STK_REQ_SENSE, KM_SLEEP); 14101 sense = (struct scsi_extended_sense *)buf; 14102 14103 cmd->uscsi_flags = USCSI_READ; 14104 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 14105 cmd->uscsi_cdb = &cdb[0]; 14106 cmd->uscsi_bufaddr = buf; 14107 cmd->uscsi_buflen = STK_REQ_SENSE; 14108 cmd->uscsi_cdblen = CDB_GROUP0; 14109 cmd->uscsi_rqlen = 0; 14110 cmd->uscsi_rqbuf = NULL; 14111 14112 result = st_uscsi_cmd(un, cmd, FKIOCTL); 14113 14114 if (result != 0 || cmd->uscsi_status != 0) { 14115 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14116 "Request Sense for WORM failed"); 14117 wrt = RDWR; 14118 } else if (sense->es_add_len + 8 < 24) { 14119 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14120 "Drive didn't send enough sense data for WORM byte %d\n", 14121 sense->es_add_len + 8); 14122 wrt = RDWR; 14123 un->un_wormable = st_is_not_wormable; 14124 } else if ((buf[24]) & 0x02) { 14125 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14126 "Drive has WORM tape loaded\n"); 14127 wrt = WORM; 14128 un->un_wormable = st_is_stk_worm; 14129 } else { 14130 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14131 "Drive has normal tape loaded\n"); 14132 wrt = RDWR; 14133 un->un_wormable = st_is_stk_worm; 14134 } 14135 14136 kmem_free(buf, STK_REQ_SENSE); 14137 kmem_free(cmd, sizeof (struct uscsi_cmd)); 14138 return (wrt); 14139 } 14140 14141 #define DLT_INQ_SZ 44 14142 14143 static writablity 14144 st_is_dlt_tape_worm(struct scsi_tape *un) 14145 { 14146 caddr_t buf; 14147 int result; 14148 writablity wrt; 14149 14150 ST_FUNC(ST_DEVINFO, st_is_dlt_tape_worm); 14151 14152 buf = kmem_alloc(DLT_INQ_SZ, KM_SLEEP); 14153 14154 /* Read Attribute Media Type */ 14155 14156 result = st_read_attributes(un, 0x0408, buf, 10, st_uscsi_cmd); 14157 14158 /* 14159 * If this quantum drive is attached via an HBA that cannot 14160 * support thr read attributes command return error in the 14161 * hope that someday they will support the t10 method. 14162 */ 14163 if (result == EINVAL && un->un_max_cdb_sz < CDB_GROUP4) { 14164 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14165 "Read Attribute Command for WORM Media detection is not " 14166 "supported on the HBA that this drive is attached to."); 14167 wrt = RDWR; 14168 un->un_wormable = st_is_not_wormable; 14169 goto out; 14170 } 14171 14172 if (result != 0) { 14173 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14174 "Read Attribute Command for WORM Media returned 0x%x", 14175 result); 14176 wrt = RDWR; 14177 un->un_dp->options &= ~ST_WORMABLE; 14178 goto out; 14179 } 14180 14181 if ((uchar_t)buf[9] == 0x80) { 14182 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14183 "Drive media is WORM\n"); 14184 wrt = WORM; 14185 } else { 14186 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14187 "Drive media is not WORM Media 0x%x\n", (uchar_t)buf[9]); 14188 wrt = RDWR; 14189 } 14190 14191 out: 14192 kmem_free(buf, DLT_INQ_SZ); 14193 return (wrt); 14194 } 14195 14196 static writablity 14197 st_is_dlt_worm(struct scsi_tape *un) 14198 { 14199 caddr_t buf; 14200 int result; 14201 writablity wrt; 14202 14203 ST_FUNC(ST_DEVINFO, st_is_dlt_worm); 14204 14205 buf = kmem_alloc(DLT_INQ_SZ, KM_SLEEP); 14206 14207 result = st_get_special_inquiry(un, DLT_INQ_SZ, buf, 0xC0); 14208 14209 if (result != 0) { 14210 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14211 "Read Vendor Specific Inquiry for WORM support failed"); 14212 wrt = RDWR; 14213 goto out; 14214 } 14215 14216 if ((buf[2] & 1) == 0) { 14217 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14218 "Drive is not WORMable\n"); 14219 wrt = RDWR; 14220 un->un_dp->options &= ~ST_WORMABLE; 14221 un->un_wormable = st_is_not_wormable; 14222 goto out; 14223 } else { 14224 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14225 "Drive is WORMable\n"); 14226 un->un_wormable = st_is_dlt_tape_worm; 14227 wrt = un->un_wormable(un); 14228 } 14229 out: 14230 kmem_free(buf, DLT_INQ_SZ); 14231 14232 return (wrt); 14233 } 14234 14235 typedef struct { 14236 struct modeheader_seq header; 14237 #if defined(_BIT_FIELDS_LTOH) /* X86 */ 14238 uchar_t pagecode :6, 14239 :2; 14240 uchar_t page_len; 14241 uchar_t syslogalive :2, 14242 device :1, 14243 abs :1, 14244 ulpbot :1, 14245 prth :1, 14246 ponej :1, 14247 ait :1; 14248 uchar_t span; 14249 14250 uchar_t :6, 14251 worm :1, 14252 mic :1; 14253 uchar_t worm_cap :1, 14254 :7; 14255 uint32_t :32; 14256 #else /* SPARC */ 14257 uchar_t :2, 14258 pagecode :6; 14259 uchar_t page_len; 14260 uchar_t ait :1, 14261 device :1, 14262 abs :1, 14263 ulpbot :1, 14264 prth :1, 14265 ponej :1, 14266 syslogalive :2; 14267 uchar_t span; 14268 uchar_t mic :1, 14269 worm :1, 14270 :6; 14271 uchar_t :7, 14272 worm_cap :1; 14273 uint32_t :32; 14274 #endif 14275 }ait_dev_con; 14276 14277 #define AIT_DEV_PAGE 0x31 14278 static writablity 14279 st_is_sony_worm(struct scsi_tape *un) 14280 { 14281 int result; 14282 writablity wrt; 14283 ait_dev_con *ait_conf; 14284 14285 ST_FUNC(ST_DEVINFO, st_is_sony_worm); 14286 14287 ait_conf = kmem_zalloc(sizeof (ait_dev_con), KM_SLEEP); 14288 14289 result = st_gen_mode_sense(un, st_uscsi_cmd, AIT_DEV_PAGE, 14290 (struct seq_mode *)ait_conf, sizeof (ait_dev_con)); 14291 14292 if (result == 0) { 14293 14294 if (ait_conf->pagecode != AIT_DEV_PAGE) { 14295 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14296 "returned page 0x%x not 0x%x AIT_DEV_PAGE\n", 14297 ait_conf->pagecode, AIT_DEV_PAGE); 14298 wrt = RDWR; 14299 un->un_wormable = st_is_not_wormable; 14300 14301 } else if (ait_conf->worm_cap) { 14302 14303 un->un_wormable = st_is_sony_worm; 14304 14305 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14306 "Drives is WORMable\n"); 14307 if (ait_conf->worm) { 14308 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14309 "Media is WORM\n"); 14310 wrt = WORM; 14311 } else { 14312 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14313 "Media is not WORM\n"); 14314 wrt = RDWR; 14315 } 14316 14317 } else { 14318 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14319 "Drives not is WORMable\n"); 14320 wrt = RDWR; 14321 /* No further checking required */ 14322 un->un_dp->options &= ~ST_WORMABLE; 14323 } 14324 14325 } else { 14326 14327 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14328 "AIT device config mode sense page read command failed" 14329 " result = %d ", result); 14330 wrt = FAILED; 14331 un->un_wormable = st_is_not_wormable; 14332 } 14333 14334 kmem_free(ait_conf, sizeof (ait_dev_con)); 14335 return (wrt); 14336 } 14337 14338 static writablity 14339 st_is_drive_worm(struct scsi_tape *un) 14340 { 14341 writablity wrt; 14342 14343 ST_FUNC(ST_DEVINFO, st_is_sony_worm); 14344 14345 switch (un->un_dp->type) { 14346 case MT_ISDLT: 14347 wrt = st_is_dlt_worm(un); 14348 break; 14349 14350 case MT_ISSTK9840: 14351 wrt = st_is_stk_worm(un); 14352 break; 14353 14354 case MT_IS8MM: 14355 case MT_ISAIT: 14356 wrt = st_is_sony_worm(un); 14357 break; 14358 14359 case MT_LTO: 14360 if (strncmp("HP ", un->un_dp->vid, 3) == 0) { 14361 wrt = st_is_hp_lto_worm(un); 14362 } else { 14363 wrt = st_is_t10_worm(un); 14364 } 14365 break; 14366 14367 case MT_ISDAT: 14368 if (strncmp("HP ", un->un_dp->vid, 3) == 0) { 14369 wrt = st_is_hp_dat_worm(un); 14370 } else { 14371 wrt = st_is_t10_worm(un); 14372 } 14373 break; 14374 14375 default: 14376 wrt = FAILED; 14377 break; 14378 } 14379 14380 /* 14381 * If any of the above failed try the t10 standard method. 14382 */ 14383 if (wrt == FAILED) { 14384 wrt = st_is_t10_worm(un); 14385 } 14386 14387 /* 14388 * Unknown method for detecting WORM media. 14389 */ 14390 if (wrt == FAILED) { 14391 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14392 "Unknown method for WORM media detection\n"); 14393 wrt = RDWR; 14394 un->un_dp->options &= ~ST_WORMABLE; 14395 } 14396 14397 return (wrt); 14398 } 14399 14400 static int 14401 st_read_attributes(struct scsi_tape *un, uint16_t attribute, void *pnt, 14402 size_t size, ubufunc_t bufunc) 14403 { 14404 char cdb[CDB_GROUP4]; 14405 int result; 14406 struct uscsi_cmd *cmd; 14407 struct scsi_arq_status status; 14408 14409 caddr_t buf = (caddr_t)pnt; 14410 14411 ST_FUNC(ST_DEVINFO, st_read_attributes); 14412 14413 if (un->un_sd->sd_inq->inq_ansi < 3) { 14414 return (ENOTTY); 14415 } 14416 14417 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 14418 14419 cdb[0] = (char)SCMD_READ_ATTRIBUTE; 14420 cdb[1] = 0; 14421 cdb[2] = 0; 14422 cdb[3] = 0; 14423 cdb[4] = 0; 14424 cdb[5] = 0; 14425 cdb[6] = 0; 14426 cdb[7] = 0; 14427 cdb[8] = (char)(attribute >> 8); 14428 cdb[9] = (char)(attribute); 14429 cdb[10] = (char)(size >> 24); 14430 cdb[11] = (char)(size >> 16); 14431 cdb[12] = (char)(size >> 8); 14432 cdb[13] = (char)(size); 14433 cdb[14] = 0; 14434 cdb[15] = 0; 14435 14436 14437 cmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE | USCSI_DIAGNOSE; 14438 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 14439 cmd->uscsi_cdb = &cdb[0]; 14440 cmd->uscsi_bufaddr = (caddr_t)buf; 14441 cmd->uscsi_buflen = size; 14442 cmd->uscsi_cdblen = sizeof (cdb); 14443 cmd->uscsi_rqlen = sizeof (status); 14444 cmd->uscsi_rqbuf = (caddr_t)&status; 14445 14446 result = bufunc(un, cmd, FKIOCTL); 14447 14448 if (result != 0 || cmd->uscsi_status != 0) { 14449 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 14450 "st_read_attribute failed: result %d status %d\n", 14451 result, cmd->uscsi_status); 14452 /* 14453 * If this returns invalid operation code don't try again. 14454 */ 14455 if (un->un_sd->sd_sense->es_key == KEY_ILLEGAL_REQUEST && 14456 un->un_sd->sd_sense->es_add_code == 0x20) { 14457 result = ENOTTY; 14458 } else if (result == 0) { 14459 result = EIO; 14460 } 14461 14462 } else { 14463 14464 /* 14465 * The attribute retured should match the attribute requested. 14466 */ 14467 if (buf[4] != cdb[8] || buf[5] != cdb[9]) { 14468 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14469 "st_read_attribute got wrong data back expected " 14470 "0x%x got 0x%x\n", attribute, buf[6] << 8 | buf[7]); 14471 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 14472 "bad? data", buf, size); 14473 result = EIO; 14474 } 14475 } 14476 14477 kmem_free(cmd, sizeof (struct uscsi_cmd)); 14478 14479 return (result); 14480 } 14481 14482 static int 14483 st_get_special_inquiry(struct scsi_tape *un, uchar_t size, caddr_t dest, 14484 uchar_t page) 14485 { 14486 char cdb[CDB_GROUP0]; 14487 struct scsi_extended_sense *sense; 14488 struct uscsi_cmd *cmd; 14489 int result; 14490 14491 ST_FUNC(ST_DEVINFO, st_get_special_inquiry); 14492 14493 cdb[0] = SCMD_INQUIRY; 14494 cdb[1] = page ? 1 : 0; 14495 cdb[2] = page; 14496 cdb[3] = 0; 14497 cdb[4] = size; 14498 cdb[5] = 0; 14499 14500 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 14501 sense = kmem_alloc(sizeof (struct scsi_extended_sense), KM_SLEEP); 14502 14503 cmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE; 14504 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 14505 cmd->uscsi_cdb = &cdb[0]; 14506 cmd->uscsi_bufaddr = dest; 14507 cmd->uscsi_buflen = size; 14508 cmd->uscsi_cdblen = CDB_GROUP0; 14509 cmd->uscsi_rqlen = sizeof (struct scsi_extended_sense); 14510 cmd->uscsi_rqbuf = (caddr_t)sense; 14511 14512 result = st_uscsi_cmd(un, cmd, FKIOCTL); 14513 14514 if (result != 0 || cmd->uscsi_status != 0) { 14515 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14516 "st_get_special_inquiry() failed for page %x", page); 14517 if (result == 0) { 14518 result = EIO; 14519 } 14520 } 14521 14522 kmem_free(sense, sizeof (struct scsi_extended_sense)); 14523 kmem_free(cmd, sizeof (struct uscsi_cmd)); 14524 14525 return (result); 14526 } 14527 14528 14529 static int 14530 st_update_block_pos(struct scsi_tape *un, bufunc_t bf, int post_space) 14531 { 14532 int rval = ENOTTY; 14533 uchar_t status = un->un_status; 14534 posmode previous_pmode = un->un_running.pmode; 14535 14536 ST_FUNC(ST_DEVINFO, st_update_block_pos); 14537 14538 while (un->un_read_pos_type != NO_POS) { 14539 rval = bf(un, SCMD_READ_POSITION, 32, SYNC_CMD); 14540 14541 /* 14542 * If read position command returned good status 14543 * Parse the data to see if the position can be interpreted. 14544 */ 14545 if ((rval == 0) && 14546 ((rval = st_interpret_read_pos(un, &un->un_pos, 14547 un->un_read_pos_type, 32, (caddr_t)un->un_read_pos_data, 14548 post_space)) == 0)) { 14549 /* 14550 * Update the running position as well if un_pos was 14551 * ok. But only if recovery is enabled. 14552 */ 14553 if (st_recov_sz != sizeof (recov_info)) { 14554 break; 14555 } 14556 rval = st_interpret_read_pos(un, &un->un_running, 14557 un->un_read_pos_type, 32, 14558 (caddr_t)un->un_read_pos_data, post_space); 14559 un->un_status = status; 14560 break; 14561 } else if (un->un_status == KEY_UNIT_ATTENTION) { 14562 un->un_running.pmode = previous_pmode; 14563 continue; 14564 } else if (un->un_status != KEY_ILLEGAL_REQUEST) { 14565 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 14566 "st_update_block_pos() read position cmd 0x%x" 14567 " returned 0x%x un_status = %d", 14568 un->un_read_pos_type, rval, un->un_status); 14569 /* ENOTTY means it read garbage. try something else. */ 14570 if (rval == ENOTTY) { 14571 rval = EIO; /* so ENOTTY is not final rval */ 14572 } else { 14573 break; 14574 } 14575 } else { 14576 ST_DEBUG4(ST_DEVINFO, st_label, CE_NOTE, 14577 "st_update_block_pos() read position cmd %x" 14578 " returned %x", un->un_read_pos_type, rval); 14579 un->un_running.pmode = previous_pmode; 14580 } 14581 14582 switch (un->un_read_pos_type) { 14583 case SHORT_POS: 14584 un->un_read_pos_type = NO_POS; 14585 break; 14586 14587 case LONG_POS: 14588 un->un_read_pos_type = EXT_POS; 14589 break; 14590 14591 case EXT_POS: 14592 un->un_read_pos_type = SHORT_POS; 14593 break; 14594 14595 default: 14596 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 14597 "Unexpected read position type 0x%x", 14598 un->un_read_pos_type); 14599 } 14600 un->un_status = KEY_NO_SENSE; 14601 } 14602 14603 return (rval); 14604 } 14605 14606 static int 14607 st_get_read_pos(struct scsi_tape *un, buf_t *bp) 14608 { 14609 int result; 14610 size_t d_sz; 14611 caddr_t pos_info; 14612 struct uscsi_cmd *cmd = (struct uscsi_cmd *)bp->b_back; 14613 14614 ST_FUNC(ST_DEVINFO, st_get_read_pos); 14615 14616 if (cmd->uscsi_bufaddr == NULL || cmd->uscsi_buflen <= 0) { 14617 return (0); 14618 } 14619 14620 if (bp_mapin_common(bp, VM_NOSLEEP) == NULL) { 14621 14622 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14623 "bp_mapin_common() failed"); 14624 14625 return (EIO); 14626 } 14627 14628 d_sz = bp->b_bcount - bp->b_resid; 14629 if (d_sz == 0) { 14630 bp_mapout(bp); 14631 return (EIO); 14632 } 14633 14634 /* 14635 * Copy the buf to a double-word aligned memory that can hold the 14636 * tape_position_t data structure. 14637 */ 14638 if ((pos_info = kmem_alloc(d_sz, KM_NOSLEEP)) == NULL) { 14639 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14640 "kmem_alloc() failed"); 14641 bp_mapout(bp); 14642 return (EIO); 14643 } 14644 bcopy(bp->b_un.b_addr, pos_info, d_sz); 14645 14646 #ifdef STDEBUG 14647 if ((st_debug & 0x7) > 2) { 14648 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 14649 "st_get_read_pos() position info", 14650 pos_info, bp->b_bcount); 14651 } 14652 #endif 14653 14654 result = st_interpret_read_pos(un, &un->un_pos, cmd->uscsi_cdb[1], 14655 d_sz, pos_info, 0); 14656 14657 COPY_POS(&un->un_running, &un->un_pos); 14658 14659 kmem_free(pos_info, d_sz); 14660 bp_mapout(bp); 14661 14662 return (result); 14663 } 14664 14665 #if defined(_BIG_ENDIAN) 14666 14667 #define FIX_ENDIAN16(x) 14668 #define FIX_ENDIAN32(x) 14669 #define FIX_ENDIAN64(x) 14670 14671 #elif defined(_LITTLE_ENDIAN) 14672 14673 static void 14674 st_swap16(uint16_t *val) 14675 { 14676 uint16_t tmp; 14677 14678 tmp = (*val >> 8) & 0xff; 14679 tmp |= (*val << 8) & 0xff00; 14680 14681 *val = tmp; 14682 } 14683 14684 static void 14685 st_swap32(uint32_t *val) 14686 { 14687 uint32_t tmp; 14688 14689 tmp = (*val >> 24) & 0xff; 14690 tmp |= (*val >> 8) & 0xff00; 14691 tmp |= (*val << 8) & 0xff0000; 14692 tmp |= (*val << 24) & 0xff000000; 14693 14694 *val = tmp; 14695 } 14696 14697 static void 14698 st_swap64(uint64_t *val) 14699 { 14700 uint32_t low; 14701 uint32_t high; 14702 14703 low = (uint32_t)(*val); 14704 high = (uint32_t)(*val >> 32); 14705 14706 st_swap32(&low); 14707 st_swap32(&high); 14708 14709 *val = high; 14710 *val |= ((uint64_t)low << 32); 14711 } 14712 14713 #define FIX_ENDIAN16(x) st_swap16(x) 14714 #define FIX_ENDIAN32(x) st_swap32(x) 14715 #define FIX_ENDIAN64(x) st_swap64(x) 14716 #endif 14717 14718 /* 14719 * st_interpret_read_pos() 14720 * 14721 * Returns: 14722 * 0 If secsessful. 14723 * EIO If read postion responce data was unuseable or invalid. 14724 * ERANGE If the position of the drive is too large for the read_p_type. 14725 * ENOTTY If the responce data looks invalid for the read position type. 14726 */ 14727 14728 static int 14729 st_interpret_read_pos(struct scsi_tape const *un, tapepos_t *dest, 14730 read_p_types type, size_t data_sz, const caddr_t responce, int post_space) 14731 { 14732 int rval = 0; 14733 int flag = 0; 14734 tapepos_t org; 14735 14736 ST_FUNC(ST_DEVINFO, st_interpret_read_pos); 14737 14738 /* 14739 * We expect the position value to change after a space command. 14740 * So if post_space is set we don't print out what has changed. 14741 */ 14742 if ((dest != &un->un_pos) && (post_space == 0) && 14743 (st_recov_sz == sizeof (recov_info))) { 14744 COPY_POS(&org, dest); 14745 flag = 1; 14746 } 14747 14748 /* 14749 * See what kind of read position was requested. 14750 */ 14751 switch (type) { 14752 14753 case SHORT_POS: /* Short data format */ 14754 { 14755 tape_position_t *pos_info = (tape_position_t *)responce; 14756 uint32_t value; 14757 14758 /* If reserved fields are non zero don't use the data */ 14759 if (pos_info->reserved0 || pos_info->reserved1 || 14760 pos_info->reserved2[0] || pos_info->reserved2[1] || 14761 pos_info->reserved3) { 14762 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14763 "Invalid Read Short Position Data returned\n"); 14764 rval = EIO; 14765 break; 14766 } 14767 /* 14768 * Position is to large to use this type of read position. 14769 */ 14770 if (pos_info->posi_err == 1) { 14771 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14772 "Drive reported position error\n"); 14773 rval = ERANGE; 14774 break; 14775 } 14776 /* 14777 * If your at the begining of partition and end at the same 14778 * time it's very small partition or bad data. 14779 */ 14780 if (pos_info->begin_of_part && pos_info->end_of_part) { 14781 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14782 "SHORT_POS returned begin and end of" 14783 " partition\n"); 14784 rval = EIO; 14785 break; 14786 } 14787 14788 if (pos_info->blk_posi_unkwn == 0) { 14789 14790 value = pos_info->host_block; 14791 FIX_ENDIAN32(&value); 14792 14793 /* 14794 * If the tape is rewound the host blcok should be 0. 14795 */ 14796 if ((pos_info->begin_of_part == 1) && 14797 (value != 0)) { 14798 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14799 "SHORT_POS returned begin of partition" 14800 " but host block was 0x%x\n", value); 14801 rval = EIO; 14802 break; 14803 } 14804 14805 if (dest->lgclblkno != value) { 14806 if (flag) 14807 flag++; 14808 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14809 "SHORT_POS current logical 0x%"PRIx64" read" 14810 " 0x%x\n", dest->lgclblkno, value); 14811 } 14812 14813 dest->lgclblkno = (uint64_t)value; 14814 14815 /* 14816 * If the begining of partition is true and the 14817 * block number is zero we will beleive that it is 14818 * rewound. Promote the pmode to legacy. 14819 */ 14820 if ((pos_info->begin_of_part == 1) && 14821 (value == 0)) { 14822 dest->blkno = 0; 14823 dest->fileno = 0; 14824 if (dest->pmode != legacy) 14825 dest->pmode = legacy; 14826 /* 14827 * otherwise if the pmode was invalid, 14828 * promote it to logical. 14829 */ 14830 } else if (dest->pmode == invalid) { 14831 dest->pmode = logical; 14832 } 14833 14834 if (dest->partition != pos_info->partition_number) { 14835 if (flag) 14836 flag++; 14837 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14838 "SHORT_POS current partition %d read %d\n", 14839 dest->partition, 14840 pos_info->partition_number); 14841 } 14842 14843 dest->partition = pos_info->partition_number; 14844 14845 } else { 14846 dest->pmode = invalid; 14847 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14848 "Tape drive reported block position as unknown\n"); 14849 } 14850 break; 14851 } 14852 14853 case LONG_POS: /* Long data format */ 14854 { 14855 uint64_t value; 14856 tape_position_long_t *long_pos_info = 14857 (tape_position_long_t *)responce; 14858 14859 /* If reserved fields are non zero don't use the data */ 14860 if ((long_pos_info->reserved0) || 14861 (long_pos_info->reserved1) || 14862 (long_pos_info->reserved2)) { 14863 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14864 "Invalid Read Long Position Data returned\n"); 14865 rval = ENOTTY; 14866 break; 14867 } 14868 14869 /* Is position Valid */ 14870 if (long_pos_info->blk_posi_unkwn == 0) { 14871 uint32_t part; 14872 14873 value = long_pos_info->block_number; 14874 FIX_ENDIAN64(&value); 14875 14876 /* 14877 * If it says we are at the begining of partition 14878 * the block value better be 0. 14879 */ 14880 if ((long_pos_info->begin_of_part == 1) && 14881 (value != 0)) { 14882 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14883 "LONG_POS returned begin of partition but" 14884 " block number was 0x%"PRIx64"\n", value); 14885 rval = ENOTTY; 14886 break; 14887 } 14888 /* 14889 * Can't be at the start and the end of the partition 14890 * at the same time if the partition is larger the 0. 14891 */ 14892 if (long_pos_info->begin_of_part && 14893 long_pos_info->end_of_part) { 14894 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14895 "LONG_POS returned begin and end of" 14896 " partition\n"); 14897 rval = ENOTTY; 14898 break; 14899 } 14900 14901 /* 14902 * If the logical block number is not what we expected. 14903 */ 14904 if (dest->lgclblkno != value) { 14905 if (flag) 14906 flag++; 14907 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14908 "LONG_POS current logical 0x%"PRIx64 14909 " read 0x%"PRIx64"\n", 14910 dest->lgclblkno, value); 14911 } 14912 dest->lgclblkno = value; 14913 14914 /* 14915 * If the begining of partition is true and the 14916 * block number is zero we will beleive that it is 14917 * rewound. Promote the pmode to legacy. 14918 */ 14919 if ((long_pos_info->begin_of_part == 1) && 14920 (long_pos_info->block_number == 0)) { 14921 dest->blkno = 0; 14922 dest->fileno = 0; 14923 if (dest->pmode != legacy) 14924 dest->pmode = legacy; 14925 /* 14926 * otherwise if the pmode was invalid, 14927 * promote it to logical. 14928 */ 14929 } else if (dest->pmode == invalid) { 14930 dest->pmode = logical; 14931 } 14932 14933 part = long_pos_info->partition; 14934 FIX_ENDIAN32(&part); 14935 if (dest->partition != part) { 14936 if (flag) 14937 flag++; 14938 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14939 "LONG_POS current partition %d" 14940 " read %d\n", dest->partition, part); 14941 } 14942 dest->partition = part; 14943 } else { 14944 /* 14945 * If the drive doesn't know location, 14946 * we don't either. 14947 */ 14948 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14949 "Tape drive reported block position as unknown\n"); 14950 dest->pmode = invalid; 14951 } 14952 14953 /* Is file position valid */ 14954 if (long_pos_info->mrk_posi_unkwn == 0) { 14955 value = long_pos_info->file_number; 14956 FIX_ENDIAN64(&value); 14957 /* 14958 * If it says we are at the begining of partition 14959 * the block value better be 0. 14960 */ 14961 if ((long_pos_info->begin_of_part == 1) && 14962 (value != 0)) { 14963 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14964 "LONG_POS returned begin of partition but" 14965 " block number was 0x%"PRIx64"\n", value); 14966 rval = ENOTTY; 14967 break; 14968 } 14969 if (((dest->pmode == legacy) || 14970 (dest->pmode == logical)) && 14971 (dest->fileno != value)) { 14972 if (flag) 14973 flag++; 14974 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14975 "LONG_POS fileno 0x%"PRIx64 14976 " not un_pos %x\n", value, 14977 dest->fileno); 14978 } else if (dest->pmode == invalid) { 14979 dest->pmode = logical; 14980 } 14981 dest->fileno = (int32_t)value; 14982 } 14983 14984 if (dest->pmode != invalid && long_pos_info->end_of_part) { 14985 dest->eof = ST_EOT; 14986 } 14987 14988 break; 14989 } 14990 14991 case EXT_POS: /* Extended data format */ 14992 { 14993 uint64_t value; 14994 uint16_t len; 14995 tape_position_ext_t *ext_pos_info = 14996 (tape_position_ext_t *)responce; 14997 14998 /* Make sure that there is enough data there */ 14999 if (data_sz < 16) { 15000 break; 15001 } 15002 15003 /* If reserved fields are non zero don't use the data */ 15004 if (ext_pos_info->reserved0 || ext_pos_info->reserved1) { 15005 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15006 "EXT_POS reserved fields not zero\n"); 15007 rval = ENOTTY; 15008 break; 15009 } 15010 15011 /* 15012 * In the unlikely event of overflowing 64 bits of position. 15013 */ 15014 if (ext_pos_info->posi_err != 0) { 15015 rval = ERANGE; 15016 break; 15017 } 15018 15019 len = ext_pos_info->parameter_len; 15020 FIX_ENDIAN16(&len); 15021 15022 if (len != 0x1c) { 15023 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15024 "EXT_POS parameter_len should be 0x1c was 0x%x\n", 15025 len); 15026 rval = ENOTTY; 15027 break; 15028 } 15029 15030 /* Is block position information valid */ 15031 if (ext_pos_info->blk_posi_unkwn == 0) { 15032 15033 value = ext_pos_info->host_block; 15034 FIX_ENDIAN64(&value); 15035 if ((ext_pos_info->begin_of_part == 1) && 15036 (value != 0)) { 15037 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15038 "EXT_POS returned begining of partition but" 15039 " the host block was 0x%"PRIx64"\n", value); 15040 rval = ENOTTY; 15041 break; 15042 } 15043 15044 if (dest->lgclblkno != value) { 15045 if (flag) 15046 flag++; 15047 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15048 "EXT_POS current logical 0x%"PRIx64 15049 " read 0x%"PRIx64"\n", 15050 dest->lgclblkno, value); 15051 } 15052 dest->lgclblkno = value; 15053 15054 /* 15055 * If the begining of partition is true and the 15056 * block number is zero we will beleive that it is 15057 * rewound. Promote the pmode to legacy. 15058 */ 15059 if ((ext_pos_info->begin_of_part == 1) && 15060 (ext_pos_info->host_block == 0)) { 15061 dest->blkno = 0; 15062 dest->fileno = 0; 15063 if (dest->pmode != legacy) { 15064 dest->pmode = legacy; 15065 } 15066 /* 15067 * otherwise if the pmode was invalid, 15068 * promote it to logical. 15069 */ 15070 } else if (dest->pmode == invalid) { 15071 dest->pmode = logical; 15072 } 15073 15074 if (dest->partition != ext_pos_info->partition) { 15075 if (flag) 15076 flag++; 15077 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15078 "EXT_POS current partition %d read %d\n", 15079 dest->partition, 15080 ext_pos_info->partition); 15081 } 15082 dest->partition = ext_pos_info->partition; 15083 15084 } else { 15085 dest->pmode = invalid; 15086 } 15087 break; 15088 } 15089 15090 default: 15091 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 15092 "Got unexpected SCMD_READ_POSITION type %d\n", type); 15093 rval = EIO; 15094 } 15095 15096 if ((flag > 1) && (rval == 0) && (org.pmode != invalid)) { 15097 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 15098 "position read in", &org); 15099 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 15100 "position read out", dest); 15101 } 15102 15103 return (rval); 15104 } 15105 15106 static int 15107 st_logical_block_locate(struct scsi_tape *un, ubufunc_t ubf, tapepos_t *pos, 15108 uint64_t lblk, uchar_t partition) 15109 { 15110 int rval; 15111 char cdb[CDB_GROUP4]; 15112 struct uscsi_cmd *cmd; 15113 struct scsi_extended_sense sense; 15114 bufunc_t bf = (ubf == st_uscsi_cmd) ? st_cmd : st_rcmd; 15115 15116 ST_FUNC(ST_DEVINFO, st_logical_block_locate); 15117 /* 15118 * Not sure what to do when doing recovery and not wanting 15119 * to update un_pos 15120 */ 15121 15122 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 15123 15124 if (lblk <= INT32_MAX) { 15125 cmd->uscsi_cdblen = CDB_GROUP1; 15126 cdb[0] = SCMD_LOCATE; 15127 cdb[1] = pos->partition == partition ? 0 : 2; 15128 cdb[2] = 0; 15129 cdb[3] = (char)(lblk >> 24); 15130 cdb[4] = (char)(lblk >> 16); 15131 cdb[5] = (char)(lblk >> 8); 15132 cdb[6] = (char)(lblk); 15133 cdb[7] = 0; 15134 cdb[8] = partition; 15135 cdb[9] = 0; 15136 } else { 15137 /* 15138 * If the drive doesn't give a 64 bit read position data 15139 * it is unlikely it will accept 64 bit locates. 15140 */ 15141 if (un->un_read_pos_type != LONG_POS) { 15142 kmem_free(cmd, sizeof (struct uscsi_cmd)); 15143 return (ERANGE); 15144 } 15145 cmd->uscsi_cdblen = CDB_GROUP4; 15146 cdb[0] = (char)SCMD_LOCATE_G4; 15147 cdb[1] = pos->partition == partition ? 0 : 2; 15148 cdb[2] = 0; 15149 cdb[3] = partition; 15150 cdb[4] = (char)(lblk >> 56); 15151 cdb[5] = (char)(lblk >> 48); 15152 cdb[6] = (char)(lblk >> 40); 15153 cdb[7] = (char)(lblk >> 32); 15154 cdb[8] = (char)(lblk >> 24); 15155 cdb[9] = (char)(lblk >> 16); 15156 cdb[10] = (char)(lblk >> 8); 15157 cdb[11] = (char)(lblk); 15158 cdb[12] = 0; 15159 cdb[13] = 0; 15160 cdb[14] = 0; 15161 cdb[15] = 0; 15162 } 15163 15164 15165 cmd->uscsi_flags = USCSI_WRITE | USCSI_DIAGNOSE | USCSI_RQENABLE; 15166 cmd->uscsi_rqbuf = (caddr_t)&sense; 15167 cmd->uscsi_rqlen = sizeof (sense); 15168 cmd->uscsi_timeout = un->un_dp->space_timeout; 15169 cmd->uscsi_cdb = cdb; 15170 15171 rval = ubf(un, cmd, FKIOCTL); 15172 15173 pos->pmode = logical; 15174 pos->eof = ST_NO_EOF; 15175 15176 if (lblk > INT32_MAX) { 15177 /* 15178 * XXX This is a work around till we handle Descriptor format 15179 * sense data. Since we are sending a command where the standard 15180 * sense data can not correctly represent a correct residual in 15181 * 4 bytes. 15182 */ 15183 if (un->un_status == KEY_ILLEGAL_REQUEST) { 15184 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15185 "Big LOCATE ILLEGAL_REQUEST: rval = %d\n", rval); 15186 /* Doesn't like big locate command */ 15187 un->un_status = 0; 15188 rval = ERANGE; 15189 } else if ((un->un_pos.pmode == invalid) || (rval != 0)) { 15190 /* Aborted big locate command */ 15191 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15192 "Big LOCATE resulted in invalid pos: rval = %d\n", 15193 rval); 15194 un->un_status = 0; 15195 rval = EIO; 15196 } else if (st_update_block_pos(un, bf, 1)) { 15197 /* read position failed */ 15198 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15199 "Big LOCATE and read pos: rval = %d\n", rval); 15200 rval = EIO; 15201 } else if (lblk > un->un_pos.lgclblkno) { 15202 /* read position worked but position was not expected */ 15203 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15204 "Big LOCATE and recover read less then desired 0x%" 15205 PRIx64"\n", un->un_pos.lgclblkno); 15206 un->un_err_resid = lblk - un->un_pos.lgclblkno; 15207 un->un_status = KEY_BLANK_CHECK; 15208 rval = ESPIPE; 15209 } else if (lblk == un->un_pos.lgclblkno) { 15210 /* read position was what was expected */ 15211 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15212 "Big LOCATE and recover seems to have worked\n"); 15213 un->un_err_resid = 0; 15214 rval = 0; 15215 } else { 15216 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 15217 "BIGLOCATE end up going backwards"); 15218 un->un_err_resid = lblk; 15219 rval = EIO; 15220 } 15221 15222 } else if (rval == 0) { 15223 /* Worked as requested */ 15224 pos->lgclblkno = lblk; 15225 15226 } else if (((cmd->uscsi_status & ST_STATUS_MASK) == STATUS_CHECK) && 15227 (cmd->uscsi_resid != 0)) { 15228 /* Got part way there but wasn't enough blocks on tape */ 15229 pos->lgclblkno = lblk - cmd->uscsi_resid; 15230 un->un_err_resid = cmd->uscsi_resid; 15231 un->un_status = KEY_BLANK_CHECK; 15232 rval = ESPIPE; 15233 15234 } else if (st_update_block_pos(un, bf, 1) == 0) { 15235 /* Got part way there but drive didn't tell what we missed by */ 15236 un->un_err_resid = lblk - pos->lgclblkno; 15237 un->un_status = KEY_BLANK_CHECK; 15238 rval = ESPIPE; 15239 15240 } else { 15241 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15242 "Failed LOCATE and recover pos: rval = %d status = %d\n", 15243 rval, cmd->uscsi_status); 15244 un->un_err_resid = lblk; 15245 un->un_status = KEY_ILLEGAL_REQUEST; 15246 pos->pmode = invalid; 15247 rval = EIO; 15248 } 15249 15250 kmem_free(cmd, sizeof (struct uscsi_cmd)); 15251 15252 return (rval); 15253 } 15254 15255 static int 15256 st_mtfsf_ioctl(struct scsi_tape *un, int64_t files) 15257 { 15258 int rval; 15259 15260 ST_FUNC(ST_DEVINFO, st_mtfsf_ioctl); 15261 15262 15263 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15264 "st_mtfsf_ioctl: count=%"PRIx64", eof=%x\n", files, un->un_pos.eof); 15265 #if 0 15266 if ((IN_EOF(un->un_pos)) && (files == 1)) { 15267 un->un_pos.fileno++; 15268 un->un_pos.blkno = 0; 15269 return (0); 15270 } 15271 #endif 15272 /* pmode == invalid already handled */ 15273 if (un->un_pos.pmode == legacy) { 15274 /* 15275 * forward space over filemark 15276 * 15277 * For ASF we allow a count of 0 on fsf which means 15278 * we just want to go to beginning of current file. 15279 * Equivalent to "nbsf(0)" or "bsf(1) + fsf". 15280 * Allow stepping over double fmk with reel 15281 */ 15282 if ((un->un_pos.eof >= ST_EOT) && 15283 (files > 0) && 15284 ((un->un_dp->options & ST_REEL) == 0)) { 15285 /* we're at EOM */ 15286 un->un_err_resid = files; 15287 un->un_status = KEY_BLANK_CHECK; 15288 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15289 "st_mtfsf_ioctl: EIO : MTFSF at EOM"); 15290 return (EIO); 15291 } 15292 15293 /* 15294 * physical tape position may not be what we've been 15295 * telling the user; adjust the request accordingly 15296 */ 15297 if (IN_EOF(un->un_pos)) { 15298 un->un_pos.fileno++; 15299 un->un_pos.blkno = 0; 15300 /* 15301 * For positive direction case, we're now covered. 15302 * For zero or negative direction, we're covered 15303 * (almost) 15304 */ 15305 files--; 15306 } 15307 15308 } 15309 15310 if (st_check_density_or_wfm(un->un_dev, 1, B_READ, STEPBACK)) { 15311 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15312 "st_mtfsf_ioctl: EIO : MTFSF density/wfm failed"); 15313 return (EIO); 15314 } 15315 15316 15317 /* 15318 * Forward space file marks. 15319 * We leave ourselves at block zero 15320 * of the target file number. 15321 */ 15322 if (files < 0) { 15323 rval = st_backward_space_files(un, -files, 0); 15324 } else { 15325 rval = st_forward_space_files(un, files); 15326 } 15327 15328 return (rval); 15329 } 15330 15331 static int 15332 st_forward_space_files(struct scsi_tape *un, int64_t count) 15333 { 15334 int rval; 15335 15336 ST_FUNC(ST_DEVINFO, st_forward_space_files); 15337 15338 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15339 "fspace: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof); 15340 15341 ASSERT(count >= 0); 15342 ASSERT(un->un_pos.pmode != invalid); 15343 15344 /* 15345 * A space with a count of zero means take me to the start of file. 15346 */ 15347 if (count == 0) { 15348 15349 /* Hay look were already there */ 15350 if (un->un_pos.pmode == legacy && un->un_pos.blkno == 0) { 15351 un->un_err_resid = 0; 15352 COPY_POS(&un->un_err_pos, &un->un_pos); 15353 return (0); 15354 } 15355 15356 /* 15357 * Well we are in the first file. 15358 * A rewind will get to the start. 15359 */ 15360 if (un->un_pos.pmode == legacy && un->un_pos.fileno == 0) { 15361 rval = st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 15362 15363 /* 15364 * Can we backspace to get there? 15365 * This should work in logical mode. 15366 */ 15367 } else if (un->un_dp->options & ST_BSF) { 15368 rval = st_space_to_begining_of_file(un); 15369 15370 /* 15371 * Can't back space but current file number is known, 15372 * So rewind and space from the begining of the partition. 15373 */ 15374 } else if (un->un_pos.pmode == legacy) { 15375 rval = st_scenic_route_to_begining_of_file(un, 15376 un->un_pos.fileno); 15377 15378 /* 15379 * pmode is logical and ST_BSF is not set. 15380 * The LONG_POS read position contains the fileno. 15381 * If the read position works, rewind and space. 15382 */ 15383 } else if (un->un_read_pos_type == LONG_POS) { 15384 rval = st_cmd(un, SCMD_READ_POSITION, 0, SYNC_CMD); 15385 if (rval) { 15386 /* 15387 * We didn't get the file position from the 15388 * read position command. 15389 * We are going to trust the drive to backspace 15390 * and then position after the filemark. 15391 */ 15392 rval = st_space_to_begining_of_file(un); 15393 } 15394 rval = st_interpret_read_pos(un, &un->un_pos, LONG_POS, 15395 32, (caddr_t)un->un_read_pos_data, 0); 15396 if ((rval) && (un->un_pos.pmode == invalid)) { 15397 rval = st_space_to_begining_of_file(un); 15398 } else { 15399 rval = st_scenic_route_to_begining_of_file(un, 15400 un->un_pos.fileno); 15401 } 15402 } else { 15403 rval = EIO; 15404 } 15405 /* 15406 * If something didn't work we are lost 15407 */ 15408 if (rval != 0) { 15409 un->un_pos.pmode = invalid; 15410 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15411 "st_mtioctop : EIO : fspace pmode invalid"); 15412 15413 rval = EIO; 15414 } 15415 15416 } else { 15417 rval = st_space_fmks(un, count); 15418 } 15419 15420 if (rval != EIO && count < 0) { 15421 /* 15422 * we came here with a count < 0; we now need 15423 * to skip back to end up before the filemark 15424 */ 15425 rval = st_backward_space_files(un, 1, 1); 15426 } 15427 15428 return (rval); 15429 } 15430 15431 static int 15432 st_scenic_route_to_begining_of_file(struct scsi_tape *un, int32_t fileno) 15433 { 15434 int rval; 15435 15436 ST_FUNC(ST_DEVINFO, st_scenic_route_to_begining_of_file); 15437 15438 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 15439 rval = EIO; 15440 } else if (st_cmd(un, SCMD_SPACE, Fmk(fileno), SYNC_CMD)) { 15441 rval = EIO; 15442 } 15443 15444 return (rval); 15445 } 15446 15447 static int 15448 st_space_to_begining_of_file(struct scsi_tape *un) 15449 { 15450 int rval; 15451 15452 ST_FUNC(ST_DEVINFO, st_space_to_begining_of_file); 15453 15454 /* 15455 * Back space of the file at the begining of the file. 15456 */ 15457 rval = st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD); 15458 if (rval) { 15459 rval = EIO; 15460 return (rval); 15461 } 15462 15463 /* 15464 * Other interesting answers might be crashed BOT which isn't bad. 15465 */ 15466 if (un->un_status == SUN_KEY_BOT) { 15467 return (rval); 15468 } 15469 15470 un->un_running.pmode = invalid; 15471 15472 /* 15473 * Now we are on the BOP side of the filemark. Forward space to 15474 * the EOM side and we are at the begining of the file. 15475 */ 15476 rval = st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD); 15477 if (rval) { 15478 rval = EIO; 15479 } 15480 15481 return (rval); 15482 } 15483 15484 static int 15485 st_mtfsr_ioctl(struct scsi_tape *un, int64_t count) 15486 { 15487 15488 ST_FUNC(ST_DEVINFO, st_mtfsr_ioctl); 15489 15490 /* 15491 * forward space to inter-record gap 15492 * 15493 */ 15494 15495 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15496 "st_ioctl_fsr: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof); 15497 15498 if (un->un_pos.pmode == legacy) { 15499 /* 15500 * If were are at end of tape and count is forward. 15501 * Return blank check. 15502 */ 15503 if ((un->un_pos.eof >= ST_EOT) && (count > 0)) { 15504 /* we're at EOM */ 15505 un->un_err_resid = count; 15506 un->un_status = KEY_BLANK_CHECK; 15507 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15508 "st_mtfsr_ioctl: EIO : MTFSR eof > ST_EOT"); 15509 return (EIO); 15510 } 15511 15512 /* 15513 * If count is zero there is nothing to do. 15514 */ 15515 if (count == 0) { 15516 un->un_err_pos.fileno = un->un_pos.fileno; 15517 un->un_err_pos.blkno = un->un_pos.blkno; 15518 un->un_err_resid = 0; 15519 if (IN_EOF(un->un_pos) && SVR4_BEHAVIOR) { 15520 un->un_status = SUN_KEY_EOF; 15521 } 15522 return (0); 15523 } 15524 15525 /* 15526 * physical tape position may not be what we've been 15527 * telling the user; adjust the position accordingly 15528 */ 15529 if (IN_EOF(un->un_pos)) { 15530 daddr_t blkno = un->un_pos.blkno; 15531 int fileno = un->un_pos.fileno; 15532 15533 optype lastop = un->un_lastop; 15534 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD) 15535 == -1) { 15536 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15537 "st_mtfsr_ioctl:EIO:MTFSR count && IN_EOF"); 15538 return (EIO); 15539 } 15540 15541 un->un_pos.blkno = blkno; 15542 un->un_pos.fileno = fileno; 15543 un->un_lastop = lastop; 15544 } 15545 } 15546 15547 if (st_check_density_or_wfm(un->un_dev, 1, B_READ, STEPBACK)) { 15548 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15549 "st_mtfsr_ioctl: EIO : MTFSR st_check_den"); 15550 return (EIO); 15551 } 15552 15553 return (st_space_records(un, count)); 15554 } 15555 15556 static int 15557 st_space_records(struct scsi_tape *un, int64_t count) 15558 { 15559 int64_t dblk; 15560 int rval = 0; 15561 15562 ST_FUNC(ST_DEVINFO, st_space_records); 15563 15564 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15565 "st_space_records: count=%"PRIx64", eof=%x\n", 15566 count, un->un_pos.eof); 15567 15568 if (un->un_pos.pmode == logical) { 15569 rval = st_cmd(un, SCMD_SPACE, Blk(count), SYNC_CMD); 15570 if (rval != 0) { 15571 rval = EIO; 15572 } 15573 return (rval); 15574 } 15575 15576 dblk = count + un->un_pos.blkno; 15577 15578 /* Already there */ 15579 if (dblk == un->un_pos.blkno) { 15580 un->un_err_resid = 0; 15581 COPY_POS(&un->un_err_pos, &un->un_pos); 15582 return (0); 15583 } 15584 15585 /* 15586 * If the destination block is forward 15587 * or the drive will backspace records. 15588 */ 15589 if (un->un_pos.blkno < dblk || (un->un_dp->options & ST_BSR)) { 15590 /* 15591 * If we're spacing forward, or the device can 15592 * backspace records, we can just use the SPACE 15593 * command. 15594 */ 15595 dblk -= un->un_pos.blkno; 15596 if (st_cmd(un, SCMD_SPACE, Blk(dblk), SYNC_CMD)) { 15597 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15598 "st_space_records:EIO:space_records can't spc"); 15599 rval = EIO; 15600 } else if (un->un_pos.eof >= ST_EOF_PENDING) { 15601 /* 15602 * check if we hit BOT/EOT 15603 */ 15604 if (dblk < 0 && un->un_pos.eof == ST_EOM) { 15605 un->un_status = SUN_KEY_BOT; 15606 un->un_pos.eof = ST_NO_EOF; 15607 } else if (dblk < 0 && 15608 un->un_pos.eof == ST_EOF_PENDING) { 15609 int residue = un->un_err_resid; 15610 /* 15611 * we skipped over a filemark 15612 * and need to go forward again 15613 */ 15614 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 15615 ST_DEBUG2(ST_DEVINFO, st_label, 15616 SCSI_DEBUG, "st_space_records: EIO" 15617 " : can't space #2"); 15618 rval = EIO; 15619 } 15620 un->un_err_resid = residue; 15621 } 15622 if (rval == 0) { 15623 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15624 "st_space_records: EIO : space_rec rval" 15625 " == 0"); 15626 rval = EIO; 15627 } 15628 } 15629 } else { 15630 /* 15631 * else we rewind, space forward across filemarks to 15632 * the desired file, and then space records to the 15633 * desired block. 15634 */ 15635 15636 int dfile = un->un_pos.fileno; /* save current file */ 15637 15638 if (dblk < 0) { 15639 /* 15640 * Wups - we're backing up over a filemark 15641 */ 15642 if (un->un_pos.blkno != 0 && 15643 (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 15644 st_cmd(un, SCMD_SPACE, Fmk(dfile), SYNC_CMD))) { 15645 un->un_pos.pmode = invalid; 15646 } 15647 un->un_err_resid = -dblk; 15648 if (un->un_pos.fileno == 0 && un->un_pos.blkno == 0) { 15649 un->un_status = SUN_KEY_BOT; 15650 un->un_pos.eof = ST_NO_EOF; 15651 } else if (un->un_pos.fileno > 0) { 15652 un->un_status = SUN_KEY_EOF; 15653 un->un_pos.eof = ST_NO_EOF; 15654 } 15655 COPY_POS(&un->un_err_pos, &un->un_pos); 15656 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15657 "st_space_records:EIO:space_records : dblk < 0"); 15658 rval = EIO; 15659 } else if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 15660 st_cmd(un, SCMD_SPACE, Fmk(dfile), SYNC_CMD) || 15661 st_cmd(un, SCMD_SPACE, Blk(dblk), SYNC_CMD)) { 15662 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15663 "st_space_records: EIO :space_records : rewind " 15664 "and space failed"); 15665 un->un_pos.pmode = invalid; 15666 rval = EIO; 15667 } 15668 } 15669 15670 return (rval); 15671 } 15672 15673 static int 15674 st_mtbsf_ioctl(struct scsi_tape *un, int64_t files) 15675 { 15676 ST_FUNC(ST_DEVINFO, st_mtbsf_ioctl); 15677 15678 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15679 "st_mtbsf_ioctl: count=%"PRIx64", eof=%x\n", files, un->un_pos.eof); 15680 /* 15681 * backward space of file filemark (1/2" and 8mm) 15682 * tape position will end on the beginning of tape side 15683 * of the desired file mark 15684 */ 15685 if ((un->un_dp->options & ST_BSF) == 0) { 15686 return (ENOTTY); 15687 } 15688 15689 if (un->un_pos.pmode == legacy) { 15690 15691 /* 15692 * If a negative count (which implies a forward space op) 15693 * is specified, and we're at logical or physical eot, 15694 * bounce the request. 15695 */ 15696 15697 if (un->un_pos.eof >= ST_EOT && files < 0) { 15698 un->un_err_resid = files; 15699 un->un_status = SUN_KEY_EOT; 15700 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15701 "st_ioctl_mt_bsf : EIO : MTBSF : eof > ST_EOF"); 15702 return (EIO); 15703 } 15704 /* 15705 * physical tape position may not be what we've been 15706 * telling the user; adjust the request accordingly 15707 */ 15708 if (IN_EOF(un->un_pos)) { 15709 un->un_pos.fileno++; 15710 un->un_pos.blkno = 0; 15711 files++; 15712 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15713 "st_mtbsf_ioctl in eof: count=%"PRIx64", op=%x\n", 15714 files, MTBSF); 15715 15716 } 15717 } 15718 15719 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 15720 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15721 "st_ioctl : EIO : MTBSF : check den wfm"); 15722 return (EIO); 15723 } 15724 15725 if (files <= 0) { 15726 /* 15727 * for a negative count, we need to step forward 15728 * first and then step back again 15729 */ 15730 files = -files + 1; 15731 return (st_forward_space_files(un, files)); 15732 } 15733 return (st_backward_space_files(un, files, 1)); 15734 } 15735 15736 static int 15737 st_backward_space_files(struct scsi_tape *un, int64_t count, int infront) 15738 { 15739 int64_t end_fileno; 15740 int64_t skip_cnt; 15741 int rval = 0; 15742 15743 ST_FUNC(ST_DEVINFO, st_backward_space_files); 15744 15745 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15746 "st_backward_space_files: count=%"PRIx64" eof=%x\n", 15747 count, un->un_pos.eof); 15748 /* 15749 * Backspace files (MTNBSF): infront == 0 15750 * 15751 * For tapes that can backspace, backspace 15752 * count+1 filemarks and then run forward over 15753 * a filemark 15754 * 15755 * For tapes that can't backspace, 15756 * calculate desired filenumber 15757 * (un->un_pos.fileno - count), rewind, 15758 * and then space forward this amount 15759 * 15760 * Backspace filemarks (MTBSF) infront == 1 15761 * 15762 * For tapes that can backspace, backspace count 15763 * filemarks 15764 * 15765 * For tapes that can't backspace, calculate 15766 * desired filenumber (un->un_pos.fileno - count), 15767 * add 1, rewind, space forward this amount, 15768 * and mark state as ST_EOF_PENDING appropriately. 15769 */ 15770 15771 if (un->un_pos.pmode == logical) { 15772 15773 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15774 "st_backward_space_files: mt_op=%x count=%"PRIx64 15775 "lgclblkno=%"PRIx64"\n", infront?MTBSF:MTNBSF, count, 15776 un->un_pos.lgclblkno); 15777 15778 15779 /* In case a drive that won't back space gets in logical mode */ 15780 if ((un->un_dp->options & ST_BSF) == 0) { 15781 rval = EIO; 15782 return (rval); 15783 } 15784 if ((infront == 1) && 15785 (st_cmd(un, SCMD_SPACE, Fmk(-count), SYNC_CMD))) { 15786 rval = EIO; 15787 return (rval); 15788 } else if ((infront == 0) && 15789 (st_cmd(un, SCMD_SPACE, Fmk((-count)-1), SYNC_CMD)) && 15790 (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD))) { 15791 rval = EIO; 15792 return (rval); 15793 } 15794 return (rval); 15795 } 15796 15797 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15798 "st_backward_space_files: mt_op=%x count=%"PRIx64 15799 "fileno=%x blkno=%x\n", 15800 infront?MTBSF:MTNBSF, count, un->un_pos.fileno, un->un_pos.blkno); 15801 15802 15803 15804 /* 15805 * Handle the simple case of BOT 15806 * playing a role in these cmds. 15807 * We do this by calculating the 15808 * ending file number. If the ending 15809 * file is < BOT, rewind and set an 15810 * error and mark resid appropriately. 15811 * If we're backspacing a file (not a 15812 * filemark) and the target file is 15813 * the first file on the tape, just 15814 * rewind. 15815 */ 15816 15817 /* figure expected destination of this SPACE command */ 15818 end_fileno = un->un_pos.fileno - count; 15819 15820 /* 15821 * Would the end effect of this SPACE be the same as rewinding? 15822 * If so just rewind instead. 15823 */ 15824 if ((infront != 0) && (end_fileno < 0) || 15825 (infront == 0) && (end_fileno <= 0)) { 15826 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 15827 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15828 "st_backward_space_files: EIO : " 15829 "rewind in lou of BSF failed\n"); 15830 rval = EIO; 15831 } 15832 if (end_fileno < 0) { 15833 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15834 "st_backward_space_files: EIO : " 15835 "back space file greater then fileno\n"); 15836 rval = EIO; 15837 un->un_err_resid = -end_fileno; 15838 un->un_status = SUN_KEY_BOT; 15839 } 15840 return (rval); 15841 } 15842 15843 if (un->un_dp->options & ST_BSF) { 15844 skip_cnt = 1 - infront; 15845 /* 15846 * If we are going to end up at the beginning 15847 * of the file, we have to space one extra file 15848 * first, and then space forward later. 15849 */ 15850 end_fileno = -(count + skip_cnt); 15851 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 15852 "skip_cnt=%"PRIx64", tmp=%"PRIx64"\n", 15853 skip_cnt, end_fileno); 15854 if (st_cmd(un, SCMD_SPACE, Fmk(end_fileno), SYNC_CMD)) { 15855 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15856 "st_backward_space_files:EIO:back space fm failed"); 15857 rval = EIO; 15858 } 15859 } else { 15860 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 15861 rval = EIO; 15862 } else { 15863 skip_cnt = end_fileno + infront; 15864 } 15865 } 15866 15867 /* 15868 * If we have to space forward, do so... 15869 */ 15870 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 15871 "space forward skip_cnt=%"PRIx64", rval=%x\n", skip_cnt, rval); 15872 15873 if (rval == 0 && skip_cnt) { 15874 if (st_cmd(un, SCMD_SPACE, Fmk(skip_cnt), SYNC_CMD)) { 15875 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15876 "st_backward_space_files:EIO:space fm skip count"); 15877 rval = EIO; 15878 } else if (infront) { 15879 /* 15880 * If we had to space forward, and we're 15881 * not a tape that can backspace, mark state 15882 * as if we'd just seen a filemark during a 15883 * a read. 15884 */ 15885 if ((un->un_dp->options & ST_BSF) == 0) { 15886 un->un_pos.eof = ST_EOF_PENDING; 15887 un->un_pos.fileno -= 1; 15888 un->un_pos.blkno = LASTBLK; 15889 un->un_running.pmode = invalid; 15890 } 15891 } 15892 } 15893 15894 if (rval != 0) { 15895 un->un_pos.pmode = invalid; 15896 } 15897 15898 return (rval); 15899 } 15900 15901 static int 15902 st_mtnbsf_ioctl(struct scsi_tape *un, int64_t count) 15903 { 15904 int rval; 15905 15906 ST_FUNC(ST_DEVINFO, st_mtnbsf_ioctl); 15907 15908 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15909 "nbsf: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof); 15910 15911 if (un->un_pos.pmode == legacy) { 15912 /* 15913 * backward space file to beginning of file 15914 * 15915 * If a negative count (which implies a forward space op) 15916 * is specified, and we're at logical or physical eot, 15917 * bounce the request. 15918 */ 15919 15920 if (un->un_pos.eof >= ST_EOT && count < 0) { 15921 un->un_err_resid = count; 15922 un->un_status = SUN_KEY_EOT; 15923 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15924 "st_ioctl : EIO : > EOT and count < 0"); 15925 return (EIO); 15926 } 15927 /* 15928 * physical tape position may not be what we've been 15929 * telling the user; adjust the request accordingly 15930 */ 15931 if (IN_EOF(un->un_pos)) { 15932 un->un_pos.fileno++; 15933 un->un_pos.blkno = 0; 15934 count++; 15935 } 15936 } 15937 15938 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 15939 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15940 "st_ioctl : EIO : MTNBSF check den and wfm"); 15941 return (EIO); 15942 } 15943 15944 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15945 "mtnbsf: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof); 15946 15947 if (count <= 0) { 15948 rval = st_forward_space_files(un, -count); 15949 } else { 15950 rval = st_backward_space_files(un, count, 0); 15951 } 15952 return (rval); 15953 } 15954 15955 static int 15956 st_mtbsr_ioctl(struct scsi_tape *un, int64_t num) 15957 { 15958 ST_FUNC(ST_DEVINFO, st_mtbsr_ioctl); 15959 15960 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15961 "bsr: count=%"PRIx64", eof=%x\n", num, un->un_pos.eof); 15962 15963 if (un->un_pos.pmode == legacy) { 15964 /* 15965 * backward space into inter-record gap 15966 * 15967 * If a negative count (which implies a forward space op) 15968 * is specified, and we're at logical or physical eot, 15969 * bounce the request. 15970 */ 15971 if (un->un_pos.eof >= ST_EOT && num < 0) { 15972 un->un_err_resid = num; 15973 un->un_status = SUN_KEY_EOT; 15974 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15975 "st_ioctl : EIO : MTBSR > EOT"); 15976 return (EIO); 15977 } 15978 15979 if (num == 0) { 15980 COPY_POS(&un->un_err_pos, &un->un_pos); 15981 un->un_err_resid = 0; 15982 if (IN_EOF(un->un_pos) && SVR4_BEHAVIOR) { 15983 un->un_status = SUN_KEY_EOF; 15984 } 15985 return (0); 15986 } 15987 15988 /* 15989 * physical tape position may not be what we've been 15990 * telling the user; adjust the position accordingly. 15991 * bsr can not skip filemarks and continue to skip records 15992 * therefore if we are logically before the filemark but 15993 * physically at the EOT side of the filemark, we need to step 15994 * back; this allows fsr N where N > number of blocks in file 15995 * followed by bsr 1 to position at the beginning of last block 15996 */ 15997 if (IN_EOF(un->un_pos)) { 15998 tapepos_t save; 15999 optype lastop = un->un_lastop; 16000 16001 COPY_POS(&save, &un->un_pos); 16002 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD) == -1) { 16003 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16004 "st_mtbsr_ioctl: EIO : MTBSR can't space"); 16005 return (EIO); 16006 } 16007 16008 COPY_POS(&un->un_pos, &save); 16009 un->un_lastop = lastop; 16010 } 16011 } 16012 16013 un->un_pos.eof = ST_NO_EOF; 16014 16015 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 16016 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16017 "st_ioctl : EIO : MTBSR : can't set density or wfm"); 16018 return (EIO); 16019 } 16020 16021 num = -num; 16022 return (st_space_records(un, num)); 16023 } 16024 16025 static int 16026 st_mtfsfm_ioctl(struct scsi_tape *un, int64_t cnt) 16027 { 16028 int rval; 16029 16030 ST_FUNC(ST_DEVINFO, st_mtfsfm_ioctl); 16031 16032 rval = st_cmd(un, SCMD_SPACE, SPACE(SP_SQFLM, cnt), SYNC_CMD); 16033 if (rval == 0) { 16034 un->un_pos.pmode = logical; 16035 } else if ((un->un_status == KEY_ILLEGAL_REQUEST) && 16036 (un->un_sd->sd_sense->es_add_code == 0x24)) { 16037 /* 16038 * Drive says invalid field in cdb. 16039 * Doesn't like space multiple. Position isn't lost. 16040 */ 16041 un->un_err_resid = cnt; 16042 un->un_status = 0; 16043 rval = ENOTTY; 16044 } else { 16045 un->un_err_resid = cnt; 16046 un->un_pos.pmode = invalid; 16047 } 16048 return (rval); 16049 } 16050 16051 static int 16052 st_mtbsfm_ioctl(struct scsi_tape *un, int64_t cnt) 16053 { 16054 int rval; 16055 16056 ST_FUNC(ST_DEVINFO, st_mtbsfm_ioctl); 16057 16058 rval = st_cmd(un, SCMD_SPACE, SPACE(SP_SQFLM, -cnt), SYNC_CMD); 16059 if (rval == 0) { 16060 un->un_pos.pmode = logical; 16061 } else if ((un->un_status == KEY_ILLEGAL_REQUEST) && 16062 (un->un_sd->sd_sense->es_add_code == 0x24)) { 16063 /* 16064 * Drive says invalid field in cdb. 16065 * Doesn't like space multiple. Position isn't lost. 16066 */ 16067 un->un_err_resid = cnt; 16068 un->un_status = 0; 16069 rval = ENOTTY; 16070 } else { 16071 un->un_err_resid = cnt; 16072 un->un_pos.pmode = invalid; 16073 } 16074 return (rval); 16075 } 16076 16077 #ifdef __x86 16078 16079 /* 16080 * release contig_mem and wake up waiting thread, if any 16081 */ 16082 static void 16083 st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp) 16084 { 16085 mutex_enter(ST_MUTEX); 16086 16087 ST_FUNC(ST_DEVINFO, st_release_contig_mem); 16088 16089 cp->cm_next = un->un_contig_mem; 16090 un->un_contig_mem = cp; 16091 un->un_contig_mem_available_num++; 16092 cv_broadcast(&un->un_contig_mem_cv); 16093 16094 mutex_exit(ST_MUTEX); 16095 } 16096 16097 /* 16098 * St_get_contig_mem will return a contig_mem if there is one available 16099 * in current system. Otherwise, it will try to alloc one, if the total 16100 * number of contig_mem is within st_max_contig_mem_num. 16101 * It will sleep, if allowed by caller or return NULL, if no contig_mem 16102 * is available for now. 16103 */ 16104 static struct contig_mem * 16105 st_get_contig_mem(struct scsi_tape *un, size_t len, int alloc_flags) 16106 { 16107 size_t rlen; 16108 struct contig_mem *cp = NULL; 16109 ddi_acc_handle_t acc_hdl; 16110 caddr_t addr; 16111 int big_enough = 0; 16112 int (*dma_alloc_cb)() = (alloc_flags == KM_SLEEP) ? 16113 DDI_DMA_SLEEP : DDI_DMA_DONTWAIT; 16114 16115 /* Try to get one available contig_mem */ 16116 mutex_enter(ST_MUTEX); 16117 16118 ST_FUNC(ST_DEVINFO, st_get_contig_mem); 16119 16120 if (un->un_contig_mem_available_num > 0) { 16121 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 16122 } else if (un->un_contig_mem_total_num < st_max_contig_mem_num) { 16123 /* 16124 * we failed to get one. we're going to 16125 * alloc one more contig_mem for this I/O 16126 */ 16127 mutex_exit(ST_MUTEX); 16128 cp = (struct contig_mem *)kmem_zalloc( 16129 sizeof (struct contig_mem) + biosize(), 16130 alloc_flags); 16131 if (cp == NULL) { 16132 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16133 "alloc contig_mem failure\n"); 16134 return (NULL); /* cannot get one */ 16135 } 16136 cp->cm_bp = (struct buf *) 16137 (((caddr_t)cp) + sizeof (struct contig_mem)); 16138 bioinit(cp->cm_bp); 16139 mutex_enter(ST_MUTEX); 16140 un->un_contig_mem_total_num++; /* one more available */ 16141 } else { 16142 /* 16143 * we failed to get one and we're NOT allowed to 16144 * alloc more contig_mem 16145 */ 16146 if (alloc_flags == KM_SLEEP) { 16147 while (un->un_contig_mem_available_num <= 0) { 16148 cv_wait(&un->un_contig_mem_cv, ST_MUTEX); 16149 } 16150 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 16151 } else { 16152 mutex_exit(ST_MUTEX); 16153 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16154 "alloc contig_mem failure\n"); 16155 return (NULL); /* cannot get one */ 16156 } 16157 } 16158 mutex_exit(ST_MUTEX); 16159 16160 /* We need to check if this block of mem is big enough for this I/O */ 16161 if (cp->cm_len < len) { 16162 /* not big enough, need to alloc a new one */ 16163 if (ddi_dma_mem_alloc(un->un_contig_mem_hdl, len, &st_acc_attr, 16164 DDI_DMA_STREAMING, dma_alloc_cb, NULL, 16165 &addr, &rlen, &acc_hdl) != DDI_SUCCESS) { 16166 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16167 "alloc contig_mem failure: not enough mem\n"); 16168 st_release_contig_mem(un, cp); 16169 cp = NULL; 16170 } else { 16171 if (cp->cm_addr) { 16172 /* release previous one before attach new one */ 16173 ddi_dma_mem_free(&cp->cm_acc_hdl); 16174 } 16175 mutex_enter(ST_MUTEX); 16176 un->un_max_contig_mem_len = 16177 un->un_max_contig_mem_len >= len ? 16178 un->un_max_contig_mem_len : len; 16179 mutex_exit(ST_MUTEX); 16180 16181 /* attach new mem to this cp */ 16182 cp->cm_addr = addr; 16183 cp->cm_acc_hdl = acc_hdl; 16184 cp->cm_len = len; 16185 16186 goto alloc_ok; /* get one usable cp */ 16187 } 16188 } else { 16189 goto alloc_ok; /* get one usable cp */ 16190 } 16191 16192 /* cannot find/alloc a usable cp, when we get here */ 16193 16194 mutex_enter(ST_MUTEX); 16195 if ((un->un_max_contig_mem_len < len) || 16196 (alloc_flags != KM_SLEEP)) { 16197 mutex_exit(ST_MUTEX); 16198 return (NULL); 16199 } 16200 16201 /* 16202 * we're allowed to sleep, and there is one big enough 16203 * contig mem in the system, which is currently in use, 16204 * wait for it... 16205 */ 16206 big_enough = 1; 16207 do { 16208 cv_wait(&un->un_contig_mem_cv, ST_MUTEX); 16209 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 16210 } while (cp == NULL); 16211 mutex_exit(ST_MUTEX); 16212 16213 /* we get the big enough contig mem, finally */ 16214 16215 alloc_ok: 16216 /* init bp attached to this cp */ 16217 bioreset(cp->cm_bp); 16218 cp->cm_bp->b_un.b_addr = cp->cm_addr; 16219 cp->cm_bp->b_private = (void *)cp; 16220 16221 return (cp); 16222 } 16223 16224 /* 16225 * this is the biodone func for the bp used in big block I/O 16226 */ 16227 static int 16228 st_bigblk_xfer_done(struct buf *bp) 16229 { 16230 struct contig_mem *cp; 16231 struct buf *orig_bp; 16232 int ioerr; 16233 struct scsi_tape *un; 16234 16235 /* sanity check */ 16236 if (bp == NULL) { 16237 return (DDI_FAILURE); 16238 } 16239 16240 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 16241 if (un == NULL) { 16242 return (DDI_FAILURE); 16243 } 16244 16245 ST_FUNC(ST_DEVINFO, st_bigblk_xfer_done); 16246 16247 cp = (struct contig_mem *)bp->b_private; 16248 orig_bp = cp->cm_bp; /* get back the bp we have replaced */ 16249 cp->cm_bp = bp; 16250 16251 /* special handling for special I/O */ 16252 if (cp->cm_use_sbuf) { 16253 #ifndef __lock_lint 16254 ASSERT(un->un_sbuf_busy); 16255 #endif 16256 un->un_sbufp = orig_bp; 16257 cp->cm_use_sbuf = 0; 16258 } 16259 16260 orig_bp->b_resid = bp->b_resid; 16261 ioerr = geterror(bp); 16262 if (ioerr != 0) { 16263 bioerror(orig_bp, ioerr); 16264 } else if (orig_bp->b_flags & B_READ) { 16265 /* copy data back to original bp */ 16266 (void) bp_copyout(bp->b_un.b_addr, orig_bp, 0, 16267 bp->b_bcount - bp->b_resid); 16268 } 16269 16270 st_release_contig_mem(un, cp); 16271 16272 biodone(orig_bp); 16273 16274 return (DDI_SUCCESS); 16275 } 16276 16277 /* 16278 * We use this func to replace original bp that may not be able to do I/O 16279 * in big block size with one that can 16280 */ 16281 static struct buf * 16282 st_get_bigblk_bp(struct buf *bp) 16283 { 16284 struct contig_mem *cp; 16285 struct scsi_tape *un; 16286 struct buf *cont_bp; 16287 16288 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 16289 if (un == NULL) { 16290 return (bp); 16291 } 16292 16293 ST_FUNC(ST_DEVINFO, st_get_bigblk_bp); 16294 16295 /* try to get one contig_mem */ 16296 cp = st_get_contig_mem(un, bp->b_bcount, KM_SLEEP); 16297 if (!cp) { 16298 scsi_log(ST_DEVINFO, st_label, CE_WARN, 16299 "Cannot alloc contig buf for I/O for %lu blk size", 16300 bp->b_bcount); 16301 return (bp); 16302 } 16303 cont_bp = cp->cm_bp; 16304 cp->cm_bp = bp; 16305 16306 /* make sure that we "are" using un_sbufp for special I/O */ 16307 if (bp == un->un_sbufp) { 16308 #ifndef __lock_lint 16309 ASSERT(un->un_sbuf_busy); 16310 #endif 16311 un->un_sbufp = cont_bp; 16312 cp->cm_use_sbuf = 1; 16313 } 16314 16315 /* clone bp */ 16316 cont_bp->b_bcount = bp->b_bcount; 16317 cont_bp->b_resid = bp->b_resid; 16318 cont_bp->b_iodone = st_bigblk_xfer_done; 16319 cont_bp->b_file = bp->b_file; 16320 cont_bp->b_offset = bp->b_offset; 16321 cont_bp->b_dip = bp->b_dip; 16322 cont_bp->b_error = 0; 16323 cont_bp->b_proc = NULL; 16324 cont_bp->b_flags = bp->b_flags & ~(B_PAGEIO | B_PHYS | B_SHADOW); 16325 cont_bp->b_shadow = NULL; 16326 cont_bp->b_pages = NULL; 16327 cont_bp->b_edev = bp->b_edev; 16328 cont_bp->b_dev = bp->b_dev; 16329 cont_bp->b_lblkno = bp->b_lblkno; 16330 cont_bp->b_forw = bp->b_forw; 16331 cont_bp->b_back = bp->b_back; 16332 cont_bp->av_forw = bp->av_forw; 16333 cont_bp->av_back = bp->av_back; 16334 cont_bp->b_bufsize = bp->b_bufsize; 16335 16336 /* get data in original bp */ 16337 if (bp->b_flags & B_WRITE) { 16338 (void) bp_copyin(bp, cont_bp->b_un.b_addr, 0, bp->b_bcount); 16339 } 16340 16341 return (cont_bp); 16342 } 16343 #else 16344 #ifdef __lock_lint 16345 static int 16346 st_bigblk_xfer_done(struct buf *bp) 16347 { 16348 return (0); 16349 } 16350 #endif 16351 #endif 16352 16353 static const char *eof_status[] = 16354 { 16355 "NO_EOF", 16356 "EOF_PENDING", 16357 "EOF", 16358 "EOT_PENDING", 16359 "EOT", 16360 "EOM", 16361 "AFTER_EOM" 16362 }; 16363 static const char *mode[] = { 16364 "invalid", 16365 "legacy", 16366 "logical" 16367 }; 16368 16369 static void 16370 st_print_position(dev_info_t *dev, char *label, uint_t level, 16371 const char *comment, tapepos_t *pos) 16372 { 16373 ST_FUNC(dev, st_print_position); 16374 16375 scsi_log(dev, label, level, 16376 "%s Position data:\n", comment); 16377 scsi_log(dev, label, CE_CONT, 16378 "Positioning mode = %s", mode[pos->pmode]); 16379 scsi_log(dev, label, CE_CONT, 16380 "End Of File/Tape = %s", eof_status[pos->eof]); 16381 scsi_log(dev, label, CE_CONT, 16382 "File Number = 0x%x", pos->fileno); 16383 scsi_log(dev, label, CE_CONT, 16384 "Block Number = 0x%x", pos->blkno); 16385 scsi_log(dev, label, CE_CONT, 16386 "Logical Block = 0x%"PRIx64, pos->lgclblkno); 16387 scsi_log(dev, label, CE_CONT, 16388 "Partition Number = 0x%x", pos->partition); 16389 } 16390 static int 16391 st_check_if_media_changed(struct scsi_tape *un, caddr_t data, int size) 16392 { 16393 16394 int result = 0; 16395 int i; 16396 ST_FUNC(ST_DEVINFO, st_check_if_media_changed); 16397 16398 /* 16399 * find non alpha numeric working from the end. 16400 */ 16401 for (i = size - 1; i >= 0; i--) { 16402 if (ISALNUM(data[i]) == 0 || data[i] == ' ') { 16403 data[i] = 0; 16404 size = i; 16405 } 16406 } 16407 16408 if (size == 1) { 16409 /* 16410 * Drive seems to think its returning useful data 16411 * but it looks like all junk 16412 */ 16413 return (result); 16414 } 16415 16416 size++; 16417 16418 /* 16419 * Actually got a valid serial number. 16420 * If never stored one before alloc space for it. 16421 */ 16422 if (un->un_media_id_len == 0) { 16423 un->un_media_id = kmem_zalloc(size, KM_SLEEP); 16424 un->un_media_id_len = size; 16425 (void) strncpy(un->un_media_id, data, min(size, strlen(data))); 16426 un->un_media_id[min(size, strlen(data))] = 0; 16427 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 16428 "Found Media Id %s length = %d\n", un->un_media_id, size); 16429 } else if (size > un->un_media_id_len) { 16430 if (strncmp(un->un_media_id, data, size) != 0) { 16431 result = ESPIPE; 16432 } 16433 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 16434 "Longer Media Id old ID:%s new ID:%s\n", 16435 un->un_media_id, data); 16436 kmem_free(un->un_media_id, un->un_media_id_len); 16437 un->un_media_id = kmem_zalloc(size, KM_SLEEP); 16438 un->un_media_id_len = size; 16439 (void) strncpy(un->un_media_id, data, size); 16440 un->un_media_id[size] = 0; 16441 } else if (strncmp(data, un->un_media_id, 16442 min(size, un->un_media_id_len)) != 0) { 16443 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 16444 "Old Media Id %s length = %d New %s length = %d\n", 16445 un->un_media_id, un->un_media_id_len, data, size); 16446 bzero(un->un_media_id, un->un_media_id_len); 16447 (void) strncpy(un->un_media_id, data, min(size, strlen(data))); 16448 un->un_media_id[min(size, strlen(data))] = 0; 16449 result = ESPIPE; 16450 } else { 16451 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 16452 "Media Id still %s\n", un->un_media_id); 16453 } 16454 16455 ASSERT(strlen(un->un_media_id) <= size); 16456 16457 return (result); 16458 } 16459 #define ID_SIZE 32 16460 typedef struct 16461 { 16462 uchar_t avilable_data0; 16463 uchar_t avilable_data1; 16464 uchar_t avilable_data2; 16465 uchar_t avilable_data3; 16466 uchar_t attribute_msb; 16467 uchar_t attribute_lsb; 16468 #ifdef _BIT_FIELDS_LTOH 16469 uchar_t format : 2, 16470 : 5, 16471 read_only : 1; 16472 #else 16473 uchar_t read_only : 1, 16474 : 5, 16475 format : 2; 16476 #endif 16477 uchar_t attribute_len_msb; 16478 uchar_t attribute_len_lsb; 16479 }attribute_header; 16480 16481 typedef struct { 16482 attribute_header header; 16483 char data[1]; 16484 }mam_attribute; 16485 16486 static int 16487 st_handle_hex_media_id(struct scsi_tape *un, void *pnt, int size) 16488 { 16489 int result; 16490 int newsize = (size << 1) + 3; /* extra for leading 0x and null term */ 16491 int i; 16492 uchar_t byte; 16493 char *format; 16494 uchar_t *data = (uchar_t *)pnt; 16495 char *buf = kmem_alloc(newsize, KM_SLEEP); 16496 16497 ST_FUNC(ST_DEVINFO, st_handle_hex_media_id); 16498 16499 (void) sprintf(buf, "0x"); 16500 for (i = 0; i < size; i++) { 16501 byte = data[i]; 16502 if (byte < 0x10) 16503 format = "0%x"; 16504 else 16505 format = "%x"; 16506 (void) sprintf(&buf[(int)strlen(buf)], format, byte); 16507 } 16508 result = st_check_if_media_changed(un, buf, newsize); 16509 16510 kmem_free(buf, newsize); 16511 16512 return (result); 16513 } 16514 16515 16516 static int 16517 st_get_media_id_via_read_attribute(struct scsi_tape *un, ubufunc_t bufunc) 16518 { 16519 int result; 16520 mam_attribute *buffer; 16521 int size; 16522 int newsize; 16523 16524 ST_FUNC(ST_DEVINFO, st_get_media_id_via_read_attribute); 16525 size = sizeof (attribute_header) + max(un->un_media_id_len, ID_SIZE); 16526 again: 16527 buffer = kmem_zalloc(size, KM_SLEEP); 16528 result = st_read_attributes(un, 0x0401, buffer, size, bufunc); 16529 if (result == 0) { 16530 16531 newsize = (buffer->header.attribute_len_msb << 8) | 16532 buffer->header.attribute_len_lsb; 16533 16534 if (newsize + sizeof (attribute_header) > size) { 16535 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 16536 "resizing read attribute data from %d to %d format" 16537 " %d\n", size, (int)sizeof (attribute_header) + 16538 newsize, buffer->header.format); 16539 kmem_free(buffer, size); 16540 size = newsize + sizeof (attribute_header); 16541 goto again; 16542 } 16543 16544 un->un_media_id_method = st_get_media_id_via_read_attribute; 16545 if (buffer->header.format == 0) { 16546 result = 16547 st_handle_hex_media_id(un, buffer->data, newsize); 16548 } else { 16549 result = st_check_if_media_changed(un, buffer->data, 16550 newsize); 16551 } 16552 } else if (result == EINVAL && un->un_max_cdb_sz < CDB_GROUP4) { 16553 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 16554 "Read Attribute Command for Media Identification is not " 16555 "supported on the HBA that this drive is attached to."); 16556 result = ENOTTY; 16557 } 16558 16559 kmem_free(buffer, size); 16560 un->un_status = 0; 16561 16562 return (result); 16563 } 16564 16565 16566 static int 16567 st_get_media_id_via_media_serial_cmd(struct scsi_tape *un, ubufunc_t bufunc) 16568 { 16569 char cdb[CDB_GROUP5]; 16570 struct uscsi_cmd *ucmd; 16571 struct scsi_extended_sense sense; 16572 int rval; 16573 int size = max(un->un_media_id_len, ID_SIZE); 16574 caddr_t buf; 16575 16576 ST_FUNC(ST_DEVINFO, st_get_media_id_via_media_serial_cmd); 16577 16578 if (un->un_sd->sd_inq->inq_ansi < 3) { 16579 return (ENOTTY); 16580 } 16581 16582 ucmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 16583 upsize: 16584 buf = kmem_alloc(size, KM_SLEEP); 16585 16586 cdb[0] = (char)SCMD_SVC_ACTION_IN_G5; 16587 cdb[1] = SSVC_ACTION_READ_MEDIA_SERIAL; 16588 cdb[2] = 0; 16589 cdb[3] = 0; 16590 cdb[4] = 0; 16591 cdb[5] = 0; 16592 cdb[6] = (char)(size >> 24); 16593 cdb[7] = (char)(size >> 16); 16594 cdb[8] = (char)(size >> 8); 16595 cdb[9] = (char)(size); 16596 cdb[10] = 0; 16597 cdb[11] = 0; 16598 16599 ucmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE; 16600 ucmd->uscsi_timeout = un->un_dp->non_motion_timeout; 16601 ucmd->uscsi_cdb = &cdb[0]; 16602 ucmd->uscsi_cdblen = sizeof (cdb); 16603 ucmd->uscsi_bufaddr = buf; 16604 ucmd->uscsi_buflen = size; 16605 ucmd->uscsi_rqbuf = (caddr_t)&sense; 16606 ucmd->uscsi_rqlen = sizeof (sense); 16607 16608 rval = bufunc(un, ucmd, FKIOCTL); 16609 16610 if (rval || ucmd->uscsi_status != 0) { 16611 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 16612 "media serial command returned %d scsi_status %d" 16613 " rqstatus %d", rval, ucmd->uscsi_status, 16614 ucmd->uscsi_rqstatus); 16615 /* 16616 * If this returns invalid operation code don't try again. 16617 */ 16618 if (sense.es_key == KEY_ILLEGAL_REQUEST && 16619 sense.es_add_code == 0x20) { 16620 rval = ENOTTY; 16621 } else if (rval == 0) { 16622 rval = EIO; 16623 } 16624 un->un_status = 0; 16625 } else { 16626 int act_size; 16627 16628 /* 16629 * get reported size. 16630 */ 16631 act_size = (int)buf[3] | (int)(buf[2] << 8) | 16632 (int)(buf[1] << 16) | (int)(buf[0] << 24); 16633 16634 /* documentation says mod 4. */ 16635 while (act_size & 3) { 16636 act_size++; 16637 } 16638 16639 /* 16640 * If reported size is larger that we our buffer. 16641 * Free the old one and allocate one that is larger 16642 * enough and re-issuse the command. 16643 */ 16644 if (act_size + 4 > size) { 16645 kmem_free(buf, size); 16646 size = act_size + 4; 16647 goto upsize; 16648 } 16649 16650 if (act_size == 0) { 16651 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 16652 "media serial number is not available"); 16653 un->un_status = 0; 16654 rval = 0; 16655 } else { 16656 /* 16657 * set data pointer to point to the start 16658 * of that serial number. 16659 */ 16660 un->un_media_id_method = 16661 st_get_media_id_via_media_serial_cmd; 16662 rval = 16663 st_check_if_media_changed(un, &buf[4], act_size); 16664 } 16665 } 16666 16667 kmem_free(ucmd, sizeof (struct uscsi_cmd)); 16668 kmem_free(buf, size); 16669 16670 return (rval); 16671 } 16672 16673 16674 /* ARGSUSED */ 16675 static int 16676 st_bogus_media_id(struct scsi_tape *un, ubufunc_t bufunc) 16677 { 16678 ST_FUNC(ST_DEVINFO, st_bogus_media_id); 16679 16680 ASSERT(un->un_media_id == NULL || un->un_media_id == bogusID); 16681 ASSERT(un->un_media_id_len == 0); 16682 un->un_media_id = (char *)bogusID; 16683 un->un_media_id_len = 0; 16684 return (0); 16685 } 16686 16687 typedef int (*media_chk_function)(struct scsi_tape *, ubufunc_t bufunc); 16688 16689 media_chk_function media_chk_functions[] = { 16690 st_get_media_id_via_media_serial_cmd, 16691 st_get_media_id_via_read_attribute, 16692 st_bogus_media_id 16693 }; 16694 16695 static int 16696 st_get_media_identification(struct scsi_tape *un, ubufunc_t bufunc) 16697 { 16698 int result = 0; 16699 int i; 16700 16701 ST_FUNC(ST_DEVINFO, st_get_media_identification); 16702 16703 for (i = 0; i < ST_NUM_MEMBERS(media_chk_functions); i++) { 16704 if (result == ENOTTY) { 16705 /* 16706 * Last operation type not supported by this device. 16707 * Make so next time it doesn`t do that again. 16708 */ 16709 un->un_media_id_method = media_chk_functions[i]; 16710 } else if (un->un_media_id_method != media_chk_functions[i] && 16711 un->un_media_id_method != st_get_media_identification) { 16712 continue; 16713 } 16714 result = media_chk_functions[i](un, bufunc); 16715 /* 16716 * If result indicates the function was successful or 16717 * that the media is not the same as last known, break. 16718 */ 16719 if (result == 0 || result == ESPIPE) { 16720 break; 16721 } 16722 } 16723 16724 return (result); 16725 } 16726 16727 static errstate 16728 st_command_recovery(struct scsi_tape *un, struct scsi_pkt *pkt, 16729 errstate onentry) 16730 { 16731 16732 int ret; 16733 st_err_info *errinfo; 16734 recov_info *ri = (recov_info *)pkt->pkt_private; 16735 16736 ST_FUNC(ST_DEVINFO, st_command_recovery); 16737 16738 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 16739 16740 ASSERT(un->un_recov_buf_busy == 0); 16741 16742 /* 16743 * Don't try and recover a reset that this device sent. 16744 */ 16745 if (un->un_rsvd_status & ST_INITIATED_RESET && 16746 onentry == DEVICE_RESET) { 16747 return (COMMAND_DONE_ERROR); 16748 } 16749 16750 /* 16751 * See if expected position was passed with scsi_pkt. 16752 */ 16753 if (ri->privatelen == sizeof (recov_info)) { 16754 16755 /* 16756 * Not for this command. 16757 */ 16758 if (ri->cmd_attrib->do_not_recover) { 16759 return (COMMAND_DONE_ERROR); 16760 } 16761 16762 /* 16763 * Create structure to hold all error state info. 16764 */ 16765 errinfo = kmem_zalloc(ST_ERR_INFO_SIZE, KM_SLEEP); 16766 errinfo->ei_error_type = onentry; 16767 errinfo->ei_failing_bp = ri->cmd_bp; 16768 COPY_POS(&errinfo->ei_expected_pos, &ri->pos); 16769 } else { 16770 /* disabled */ 16771 return (COMMAND_DONE_ERROR); 16772 } 16773 16774 bcopy(pkt, &errinfo->ei_failed_pkt, scsi_pkt_size()); 16775 bcopy(pkt->pkt_scbp, &errinfo->ei_failing_status, SECMDS_STATUS_SIZE); 16776 ret = ddi_taskq_dispatch(un->un_recov_taskq, st_recover, errinfo, 16777 DDI_NOSLEEP); 16778 ASSERT(ret == DDI_SUCCESS); 16779 if (ret != DDI_SUCCESS) { 16780 kmem_free(errinfo, ST_ERR_INFO_SIZE); 16781 return (COMMAND_DONE_ERROR); 16782 } 16783 return (JUST_RETURN); /* release calling thread */ 16784 } 16785 16786 16787 static void 16788 st_recov_ret(struct scsi_tape *un, st_err_info *errinfo, errstate err) 16789 { 16790 int error_number; 16791 buf_t *bp; 16792 16793 16794 ST_FUNC(ST_DEVINFO, st_recov_ret); 16795 16796 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 16797 #if !defined(lint) 16798 _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex)) 16799 #endif 16800 16801 bp = errinfo->ei_failing_bp; 16802 kmem_free(errinfo, ST_ERR_INFO_SIZE); 16803 16804 switch (err) { 16805 case JUST_RETURN: 16806 mutex_exit(&un->un_sd->sd_mutex); 16807 return; 16808 16809 case COMMAND_DONE: 16810 case COMMAND_DONE_ERROR_RECOVERED: 16811 ST_DO_KSTATS(bp, kstat_runq_exit); 16812 error_number = 0; 16813 break; 16814 16815 default: 16816 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 16817 "st_recov_ret with unhandled errstat %d\n", err); 16818 /* FALLTHROUGH */ 16819 case COMMAND_DONE_ERROR: 16820 un->un_pos.pmode = invalid; 16821 un->un_running.pmode = invalid; 16822 /* FALLTHROUGH */ 16823 case COMMAND_DONE_EACCES: 16824 ST_DO_KSTATS(bp, kstat_waitq_exit); 16825 ST_DO_ERRSTATS(un, st_transerrs); 16826 error_number = EIO; 16827 st_set_pe_flag(un); 16828 break; 16829 16830 } 16831 16832 st_bioerror(bp, error_number); 16833 st_done_and_mutex_exit(un, bp); 16834 } 16835 16836 16837 static void 16838 st_recover(void *arg) 16839 { 16840 st_err_info *const errinfo = (st_err_info *)arg; 16841 uchar_t com = errinfo->ei_failed_pkt.pkt_cdbp[0]; 16842 struct scsi_tape *un; 16843 tapepos_t cur_pos; 16844 int rval; 16845 errstate status = COMMAND_DONE_ERROR; 16846 recov_info *rcv; 16847 buf_t *bp; 16848 16849 16850 rcv = errinfo->ei_failed_pkt.pkt_private; 16851 ASSERT(rcv->privatelen == sizeof (recov_info)); 16852 bp = rcv->cmd_bp; 16853 16854 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 16855 16856 ASSERT(un != NULL); 16857 16858 mutex_enter(ST_MUTEX); 16859 16860 ST_FUNC(ST_DEVINFO, st_recover); 16861 16862 ST_CDB(ST_DEVINFO, "Recovering command", 16863 (caddr_t)errinfo->ei_failed_pkt.pkt_cdbp); 16864 ST_SENSE(ST_DEVINFO, "sense status for failed command", 16865 (caddr_t)&errinfo->ei_failing_status, 16866 sizeof (struct scsi_arq_status)); 16867 ST_POS(ST_DEVINFO, rcv->cmd_attrib->recov_pos_type == POS_STARTING ? 16868 "starting position for recovery command" : 16869 "expected position for recovery command", 16870 &errinfo->ei_expected_pos); 16871 16872 rval = st_test_path_to_device(un); 16873 16874 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16875 "st_recover called with %s, TUR returned %d\n", 16876 errstatenames[errinfo->ei_error_type], rval); 16877 /* 16878 * If the drive responed to the TUR lets try and get it to sync 16879 * any data it might have in the buffer. 16880 */ 16881 if (rval == 0 && rcv->cmd_attrib->chg_tape_data) { 16882 rval = st_rcmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD); 16883 if (rval) { 16884 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16885 "st_recover failed to flush, returned %d\n", rval); 16886 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16887 return; 16888 } 16889 } 16890 switch (errinfo->ei_error_type) { 16891 case ATTEMPT_RETRY: 16892 case COMMAND_TIMEOUT: 16893 case DEVICE_RESET: 16894 case PATH_FAILED: 16895 /* 16896 * For now if we can't talk to the device we are done. 16897 * If the drive is reserved we can try to get it back. 16898 */ 16899 if (rval != 0 && rval != EACCES) { 16900 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16901 return; 16902 } 16903 16904 /* 16905 * If reservation conflict and do a preempt, fail it. 16906 */ 16907 if ((un->un_rsvd_status & 16908 (ST_APPLICATION_RESERVATIONS | ST_RESERVE)) != 0) { 16909 if ((errinfo->ei_failed_pkt.pkt_cdbp[0] == 16910 SCMD_PERSISTENT_RESERVE_OUT) && 16911 (errinfo->ei_failed_pkt.pkt_cdbp[1] == 16912 ST_SA_SCSI3_PREEMPT) && 16913 (SCBP_C(&errinfo->ei_failed_pkt) == 16914 STATUS_RESERVATION_CONFLICT)) { 16915 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16916 return; 16917 } 16918 } 16919 16920 /* 16921 * If we have already set a scsi II reserve and get a 16922 * conflict on a scsi III type reserve fail without 16923 * any attempt to recover. 16924 */ 16925 if ((un->un_rsvd_status & ST_RESERVE | ST_PRESERVE_RESERVE) && 16926 (errinfo->ei_failed_pkt.pkt_cdbp[0] == 16927 SCMD_PERSISTENT_RESERVE_OUT) || 16928 (errinfo->ei_failed_pkt.pkt_cdbp[0] == 16929 SCMD_PERSISTENT_RESERVE_IN)) { 16930 st_recov_ret(un, errinfo, COMMAND_DONE_EACCES); 16931 return; 16932 } 16933 16934 /* 16935 * If scsi II lost reserve try and get it back. 16936 */ 16937 if ((((un->un_rsvd_status & 16938 (ST_LOST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 16939 ST_LOST_RESERVE)) && 16940 (errinfo->ei_failed_pkt.pkt_cdbp[0] != SCMD_RELEASE)) { 16941 rval = st_reserve_release(un, ST_RESERVE, 16942 st_uscsi_rcmd); 16943 if (rval != 0) { 16944 if (st_take_ownership(un, st_uscsi_rcmd) != 0) { 16945 st_recov_ret(un, errinfo, 16946 COMMAND_DONE_EACCES); 16947 return; 16948 } 16949 } 16950 un->un_rsvd_status |= ST_RESERVE; 16951 un->un_rsvd_status &= ~(ST_RELEASE | ST_LOST_RESERVE | 16952 ST_RESERVATION_CONFLICT | ST_INITIATED_RESET); 16953 } 16954 rval = st_make_sure_mode_data_is_correct(un, st_uscsi_rcmd); 16955 if (rval) { 16956 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16957 return; 16958 } 16959 break; 16960 case DEVICE_TAMPER: 16961 /* 16962 * Check if the ASC/ASCQ says mode data has changed. 16963 */ 16964 if ((errinfo->ei_failing_status.sts_sensedata.es_add_code == 16965 0x2a) && 16966 (errinfo->ei_failing_status.sts_sensedata.es_qual_code == 16967 0x01)) { 16968 /* 16969 * See if mode sense changed. 16970 */ 16971 rval = st_make_sure_mode_data_is_correct(un, 16972 st_uscsi_rcmd); 16973 if (rval) { 16974 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16975 return; 16976 } 16977 } 16978 /* 16979 * if we have a media id and its not bogus. 16980 * Check to see if it the same. 16981 */ 16982 if (un->un_media_id != NULL && un->un_media_id != bogusID) { 16983 rval = st_get_media_identification(un, st_uscsi_rcmd); 16984 if (rval == ESPIPE) { 16985 st_recov_ret(un, errinfo, COMMAND_DONE_EACCES); 16986 return; 16987 } 16988 } 16989 break; 16990 default: 16991 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 16992 "Unhandled error type %s in st_recover() 0x%x\n", 16993 errstatenames[errinfo->ei_error_type], com); 16994 } 16995 16996 /* 16997 * if command is retriable retry it. 16998 * Special case here. The command attribute for SCMD_REQUEST_SENSE 16999 * does not say that it is retriable. That because if you reissue a 17000 * request sense and the target responds the sense data will have 17001 * been consumed and no long be valid. If we get a busy status on 17002 * request sense while the state is ST_STATE_SENSING this will 17003 * reissue that pkt. 17004 * 17005 * XXX If this request sense gets sent to a different port then 17006 * the original command that failed was sent on it will not get 17007 * valid sense data for that command. 17008 */ 17009 if (rcv->cmd_attrib->retriable || un->un_rqs_bp == bp) { 17010 status = st_recover_reissue_pkt(un, &errinfo->ei_failed_pkt); 17011 17012 /* 17013 * if drive doesn't support read position we are done 17014 */ 17015 } else if (un->un_read_pos_type == NO_POS) { 17016 status = COMMAND_DONE_ERROR; 17017 /* 17018 * If this command results in a changed tape position, 17019 * lets see where we are. 17020 */ 17021 } else if (rcv->cmd_attrib->chg_tape_pos) { 17022 /* 17023 * XXX May be a reason to choose a different type here. 17024 * Long format has file position information. 17025 * Short and Extended have information about whats 17026 * in the buffer. St's positioning assumes in the buffer 17027 * to be the same as on tape. 17028 */ 17029 rval = st_compare_expected_position(un, errinfo, 17030 rcv->cmd_attrib, &cur_pos); 17031 if (rval == 0) { 17032 status = COMMAND_DONE; 17033 } else if (rval == EAGAIN) { 17034 status = st_recover_reissue_pkt(un, 17035 &errinfo->ei_failed_pkt); 17036 } else { 17037 status = COMMAND_DONE_ERROR; 17038 } 17039 } else { 17040 ASSERT(0); 17041 } 17042 17043 st_recov_ret(un, errinfo, status); 17044 } 17045 17046 static void 17047 st_recov_cb(struct scsi_pkt *pkt) 17048 { 17049 struct scsi_tape *un; 17050 struct buf *bp; 17051 recov_info *rcv; 17052 errstate action = COMMAND_DONE_ERROR; 17053 int timout = ST_TRAN_BUSY_TIMEOUT; /* short (default) timeout */ 17054 17055 /* 17056 * Get the buf from the packet. 17057 */ 17058 rcv = pkt->pkt_private; 17059 ASSERT(rcv->privatelen == sizeof (recov_info)); 17060 bp = rcv->cmd_bp; 17061 17062 /* 17063 * get the unit from the buf. 17064 */ 17065 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 17066 ASSERT(un != NULL); 17067 17068 ST_FUNC(ST_DEVINFO, st_recov_cb); 17069 17070 mutex_enter(ST_MUTEX); 17071 17072 ASSERT(bp == un->un_recov_buf); 17073 17074 17075 switch (pkt->pkt_reason) { 17076 case CMD_CMPLT: 17077 if (un->un_arq_enabled && pkt->pkt_state & STATE_ARQ_DONE) { 17078 action = st_handle_autosense(un, bp, &rcv->pos); 17079 } else if ((SCBP(pkt)->sts_busy) || 17080 (SCBP(pkt)->sts_chk) || 17081 (SCBP(pkt)->sts_vu7)) { 17082 action = st_check_error(un, pkt); 17083 } else { 17084 action = COMMAND_DONE; 17085 } 17086 break; 17087 case CMD_TIMEOUT: 17088 action = COMMAND_TIMEOUT; 17089 break; 17090 case CMD_TRAN_ERR: 17091 action = QUE_COMMAND; 17092 break; 17093 case CMD_DEV_GONE: 17094 if (un->un_multipath) 17095 action = PATH_FAILED; 17096 else 17097 action = COMMAND_DONE_ERROR; 17098 break; 17099 default: 17100 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 17101 "pkt_reason not handled yet %s", 17102 scsi_rname(pkt->pkt_reason)); 17103 action = COMMAND_DONE_ERROR; 17104 } 17105 17106 /* 17107 * check for undetected path failover. 17108 */ 17109 if (un->un_multipath) { 17110 if (scsi_pkt_allocated_correctly(pkt) && 17111 (un->un_last_path_instance != pkt->pkt_path_instance)) { 17112 if (un->un_state > ST_STATE_OPENING) { 17113 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17114 "Failover detected in recovery, action is " 17115 "%s\n", errstatenames[action]); 17116 } 17117 un->un_last_path_instance = pkt->pkt_path_instance; 17118 } 17119 } 17120 17121 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 17122 "Recovery call back got %s status on %s\n", 17123 errstatenames[action], st_print_scsi_cmd(pkt->pkt_cdbp[0])); 17124 17125 switch (action) { 17126 case COMMAND_DONE: 17127 break; 17128 17129 case COMMAND_DONE_EACCES: 17130 bioerror(bp, EACCES); 17131 break; 17132 17133 case COMMAND_DONE_ERROR_RECOVERED: /* XXX maybe wrong */ 17134 ASSERT(0); 17135 break; 17136 17137 case COMMAND_TIMEOUT: 17138 case COMMAND_DONE_ERROR: 17139 bioerror(bp, EIO); 17140 break; 17141 17142 case DEVICE_RESET: 17143 case QUE_BUSY_COMMAND: 17144 case PATH_FAILED: 17145 /* longish timeout */ 17146 timout = ST_STATUS_BUSY_TIMEOUT; 17147 /* FALLTHRU */ 17148 case QUE_COMMAND: 17149 case DEVICE_TAMPER: 17150 case ATTEMPT_RETRY: 17151 /* 17152 * let st_handle_intr_busy put this bp back on waitq and make 17153 * checks to see if it is ok to requeue the command. 17154 */ 17155 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 17156 17157 /* 17158 * Save the throttle before setting up the timeout 17159 */ 17160 if (un->un_throttle) { 17161 un->un_last_throttle = un->un_throttle; 17162 } 17163 mutex_exit(ST_MUTEX); 17164 if (st_handle_intr_busy(un, bp, timout) == 0) { 17165 return; /* timeout is setup again */ 17166 } 17167 mutex_enter(ST_MUTEX); 17168 un->un_pos.pmode = invalid; 17169 un->un_err_resid = bp->b_resid = bp->b_bcount; 17170 st_bioerror(bp, EIO); 17171 st_set_pe_flag(un); 17172 break; 17173 17174 default: 17175 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 17176 "Unhandled recovery state 0x%x\n", action); 17177 un->un_pos.pmode = invalid; 17178 un->un_err_resid = bp->b_resid = bp->b_bcount; 17179 st_bioerror(bp, EIO); 17180 st_set_pe_flag(un); 17181 break; 17182 } 17183 17184 st_done_and_mutex_exit(un, bp); 17185 } 17186 17187 static int 17188 st_rcmd(struct scsi_tape *un, int com, int64_t count, int wait) 17189 { 17190 struct buf *bp; 17191 int err; 17192 17193 ST_FUNC(ST_DEVINFO, st_rcmd); 17194 17195 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 17196 "st_rcmd(un = 0x%p, com = 0x%x, count = %"PRIx64", wait = %d)\n", 17197 (void *)un, com, count, wait); 17198 17199 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 17200 ASSERT(mutex_owned(ST_MUTEX)); 17201 17202 #ifdef STDEBUG 17203 if ((st_debug & 0x7)) { 17204 st_debug_cmds(un, com, count, wait); 17205 } 17206 #endif 17207 17208 while (un->un_recov_buf_busy) 17209 cv_wait(&un->un_recov_buf_cv, ST_MUTEX); 17210 un->un_recov_buf_busy = 1; 17211 17212 bp = un->un_recov_buf; 17213 bzero(bp, sizeof (buf_t)); 17214 17215 bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC; 17216 17217 err = st_setup_cmd(un, bp, com, count); 17218 17219 un->un_recov_buf_busy = 0; 17220 17221 cv_signal(&un->un_recov_buf_cv); 17222 17223 return (err); 17224 } 17225 17226 /* args used */ 17227 static int 17228 st_uscsi_rcmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, int flag) 17229 { 17230 int rval; 17231 buf_t *bp; 17232 17233 ST_FUNC(ST_DEVINFO, st_uscsi_rcmd); 17234 ASSERT(flag == FKIOCTL); 17235 17236 /* 17237 * Get buffer resources... 17238 */ 17239 while (un->un_recov_buf_busy) 17240 cv_wait(&un->un_recov_buf_cv, ST_MUTEX); 17241 un->un_recov_buf_busy = 1; 17242 17243 bp = un->un_recov_buf; 17244 bzero(bp, sizeof (buf_t)); 17245 17246 bp->b_forw = (struct buf *)(uintptr_t)ucmd->uscsi_cdb[0]; 17247 bp->b_back = (struct buf *)ucmd; 17248 17249 mutex_exit(ST_MUTEX); 17250 rval = scsi_uscsi_handle_cmd(un->un_dev, UIO_SYSSPACE, ucmd, 17251 st_strategy, bp, NULL); 17252 mutex_enter(ST_MUTEX); 17253 17254 ucmd->uscsi_resid = bp->b_resid; 17255 17256 /* 17257 * Free resources 17258 */ 17259 un->un_recov_buf_busy = 0; 17260 cv_signal(&un->un_recov_buf_cv); 17261 17262 return (rval); 17263 } 17264 17265 /* 17266 * Add data to scsi_pkt to help know what to do if the command fails. 17267 */ 17268 static void 17269 st_add_recovery_info_to_pkt(struct scsi_tape *un, buf_t *bp, 17270 struct scsi_pkt *pkt) 17271 { 17272 uint64_t count; 17273 recov_info *rinfo = (recov_info *)pkt->pkt_private; 17274 17275 ST_FUNC(ST_DEVINFO, st_add_recovery_info_to_pkt); 17276 17277 ASSERT(rinfo->privatelen == sizeof (pkt_info) || 17278 rinfo->privatelen == sizeof (recov_info)); 17279 17280 SET_BP_PKT(bp, pkt); 17281 rinfo->cmd_bp = bp; 17282 17283 if (rinfo->privatelen != sizeof (recov_info)) { 17284 return; 17285 } 17286 17287 rinfo->cmd_bp = bp; 17288 17289 rinfo->cmd_attrib = NULL; 17290 17291 /* 17292 * lookup the command attributes and add them to the recovery info. 17293 */ 17294 rinfo->cmd_attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 17295 17296 ASSERT(rinfo->cmd_attrib); 17297 17298 /* 17299 * For commands that there is no way to figure the expected position 17300 * once completed, we save the position the command was started from 17301 * so that if they fail we can position back and try again. 17302 * This has already been done in st_cmd() or st_iscsi_cmd(). 17303 */ 17304 if (rinfo->cmd_attrib->recov_pos_type == POS_STARTING) { 17305 /* save current position as the starting position. */ 17306 COPY_POS(&rinfo->pos, &un->un_pos); 17307 un->un_running.pmode = invalid; 17308 return; 17309 } 17310 17311 /* 17312 * Don't want to update the running position for recovery. 17313 */ 17314 if (bp == un->un_recov_buf) { 17315 rinfo->pos.pmode = un->un_running.pmode; 17316 return; 17317 } 17318 /* 17319 * If running position is invalid copy the current position. 17320 * Running being set invalid means we are not in a read, write 17321 * or write filemark sequence. 17322 * We'll copy the current position and start from there. 17323 */ 17324 if (un->un_running.pmode == invalid) { 17325 COPY_POS(&un->un_running, &un->un_pos); 17326 COPY_POS(&rinfo->pos, &un->un_running); 17327 } else { 17328 COPY_POS(&rinfo->pos, &un->un_running); 17329 if (rinfo->pos.pmode == legacy) { 17330 /* 17331 * Always should be more logical blocks then 17332 * data blocks and files marks. 17333 */ 17334 ASSERT((rinfo->pos.blkno >= 0) ? 17335 rinfo->pos.lgclblkno >= 17336 (rinfo->pos.blkno + rinfo->pos.fileno) : 1); 17337 } 17338 } 17339 17340 /* 17341 * If the command is not expected to change the drive position 17342 * then the running position should be the expected position. 17343 */ 17344 if (rinfo->cmd_attrib->chg_tape_pos == 0) { 17345 ASSERT(rinfo->cmd_attrib->chg_tape_direction == DIR_NONE); 17346 return; 17347 } 17348 17349 if (rinfo->cmd_attrib->explicit_cmd_set) { 17350 ASSERT(rinfo->pos.pmode != invalid); 17351 ASSERT(rinfo->cmd_attrib->get_cnt); 17352 count = rinfo->cmd_attrib->get_cnt(pkt->pkt_cdbp); 17353 /* 17354 * This is a user generated CDB. 17355 */ 17356 if (bp == un->un_sbufp) { 17357 uint64_t lbn; 17358 17359 lbn = rinfo->cmd_attrib->get_lba(pkt->pkt_cdbp); 17360 17361 /* 17362 * See if this CDB will generate a locate or change 17363 * partition. 17364 */ 17365 if ((lbn != un->un_running.lgclblkno) || 17366 (pkt->pkt_cdbp[3] != un->un_running.partition)) { 17367 rinfo->pos.partition = pkt->pkt_cdbp[3]; 17368 rinfo->pos.pmode = logical; 17369 rinfo->pos.lgclblkno = lbn; 17370 un->un_running.partition = pkt->pkt_cdbp[3]; 17371 un->un_running.pmode = logical; 17372 un->un_running.lgclblkno = lbn; 17373 } 17374 } else { 17375 uint64_t lbn = un->un_running.lgclblkno; 17376 17377 pkt->pkt_cdbp[3] = (uchar_t)un->un_running.partition; 17378 17379 pkt->pkt_cdbp[4] = (uchar_t)(lbn >> 56); 17380 pkt->pkt_cdbp[5] = (uchar_t)(lbn >> 48); 17381 pkt->pkt_cdbp[6] = (uchar_t)(lbn >> 40); 17382 pkt->pkt_cdbp[7] = (uchar_t)(lbn >> 32); 17383 pkt->pkt_cdbp[8] = (uchar_t)(lbn >> 24); 17384 pkt->pkt_cdbp[9] = (uchar_t)(lbn >> 16); 17385 pkt->pkt_cdbp[10] = (uchar_t)(lbn >> 8); 17386 pkt->pkt_cdbp[11] = (uchar_t)(lbn); 17387 } 17388 rinfo->pos.lgclblkno += count; 17389 rinfo->pos.blkno += count; 17390 un->un_running.lgclblkno += count; 17391 return; 17392 } 17393 17394 if (rinfo->cmd_attrib->chg_tape_pos) { 17395 17396 /* should not have got an invalid position from running. */ 17397 if (un->un_mediastate == MTIO_INSERTED) { 17398 ASSERT(rinfo->pos.pmode != invalid); 17399 } 17400 17401 /* should have either a get count or or get lba function */ 17402 ASSERT(rinfo->cmd_attrib->get_cnt != NULL || 17403 rinfo->cmd_attrib->get_lba != NULL); 17404 17405 /* only explicit commands have both and they're handled above */ 17406 ASSERT(!(rinfo->cmd_attrib->get_cnt != NULL && 17407 rinfo->cmd_attrib->get_lba != NULL)); 17408 17409 /* if it has a get count function */ 17410 if (rinfo->cmd_attrib->get_cnt != NULL) { 17411 count = rinfo->cmd_attrib->get_cnt(pkt->pkt_cdbp); 17412 if (count == 0) { 17413 return; 17414 } 17415 /* 17416 * Changes position but doesn't transfer data. 17417 * i.e. rewind, write_file_mark and load. 17418 */ 17419 if (rinfo->cmd_attrib->transfers_data == TRAN_NONE) { 17420 switch (rinfo->cmd_attrib->chg_tape_direction) { 17421 case DIR_NONE: /* Erase */ 17422 ASSERT(rinfo->cmd_attrib->cmd == 17423 SCMD_ERASE); 17424 break; 17425 case DIR_FORW: /* write_file_mark */ 17426 rinfo->pos.fileno += count; 17427 rinfo->pos.lgclblkno += count; 17428 rinfo->pos.blkno = 0; 17429 un->un_running.fileno += count; 17430 un->un_running.lgclblkno += count; 17431 un->un_running.blkno = 0; 17432 break; 17433 case DIR_REVC: /* rewind */ 17434 rinfo->pos.fileno = 0; 17435 rinfo->pos.lgclblkno = 0; 17436 rinfo->pos.blkno = 0; 17437 rinfo->pos.eof = ST_NO_EOF; 17438 rinfo->pos.pmode = legacy; 17439 un->un_running.fileno = 0; 17440 un->un_running.lgclblkno = 0; 17441 un->un_running.blkno = 0; 17442 un->un_running.eof = ST_NO_EOF; 17443 if (un->un_running.pmode != legacy) 17444 un->un_running.pmode = legacy; 17445 break; 17446 case DIR_EITH: /* Load unload */ 17447 ASSERT(rinfo->cmd_attrib->cmd == 17448 SCMD_LOAD); 17449 switch (count & (LD_LOAD | LD_RETEN | 17450 LD_RETEN | LD_HOLD)) { 17451 case LD_UNLOAD: 17452 case LD_RETEN: 17453 case LD_HOLD: 17454 case LD_LOAD | LD_HOLD: 17455 case LD_EOT | LD_HOLD: 17456 case LD_RETEN | LD_HOLD: 17457 rinfo->pos.pmode = invalid; 17458 un->un_running.pmode = invalid; 17459 break; 17460 case LD_EOT: 17461 case LD_LOAD | LD_EOT: 17462 rinfo->pos.eof = ST_EOT; 17463 rinfo->pos.pmode = invalid; 17464 un->un_running.eof = ST_EOT; 17465 un->un_running.pmode = invalid; 17466 break; 17467 case LD_LOAD: 17468 case LD_RETEN | LD_LOAD: 17469 rinfo->pos.fileno = 0; 17470 rinfo->pos.lgclblkno = 0; 17471 rinfo->pos.blkno = 0; 17472 rinfo->pos.eof = ST_NO_EOF; 17473 rinfo->pos.pmode = legacy; 17474 un->un_running.fileno = 0; 17475 un->un_running.lgclblkno = 0; 17476 un->un_running.blkno = 0; 17477 un->un_running.eof = ST_NO_EOF; 17478 break; 17479 default: 17480 ASSERT(0); 17481 } 17482 break; 17483 default: 17484 ASSERT(0); 17485 break; 17486 } 17487 } else { 17488 /* 17489 * Changes position and does transfer data. 17490 * i.e. read or write. 17491 */ 17492 switch (rinfo->cmd_attrib->chg_tape_direction) { 17493 case DIR_FORW: 17494 rinfo->pos.lgclblkno += count; 17495 rinfo->pos.blkno += count; 17496 un->un_running.lgclblkno += count; 17497 un->un_running.blkno += count; 17498 break; 17499 case DIR_REVC: 17500 rinfo->pos.lgclblkno -= count; 17501 rinfo->pos.blkno -= count; 17502 un->un_running.lgclblkno -= count; 17503 un->un_running.blkno -= count; 17504 break; 17505 default: 17506 ASSERT(0); 17507 break; 17508 } 17509 } 17510 } else if (rinfo->cmd_attrib->get_lba != NULL) { 17511 /* Have a get LBA fuction. i.e. Locate */ 17512 ASSERT(rinfo->cmd_attrib->chg_tape_direction == 17513 DIR_EITH); 17514 count = rinfo->cmd_attrib->get_lba(pkt->pkt_cdbp); 17515 un->un_running.lgclblkno = count; 17516 un->un_running.blkno = 0; 17517 un->un_running.fileno = 0; 17518 un->un_running.pmode = logical; 17519 rinfo->pos.lgclblkno = count; 17520 rinfo->pos.pmode = invalid; 17521 } else { 17522 ASSERT(0); 17523 } 17524 return; 17525 } 17526 17527 ST_CDB(ST_DEVINFO, "Unhanded CDB for position prediction", 17528 (char *)pkt->pkt_cdbp); 17529 17530 } 17531 17532 static int 17533 st_make_sure_mode_data_is_correct(struct scsi_tape *un, ubufunc_t ubf) 17534 { 17535 int rval; 17536 17537 ST_FUNC(ST_DEVINFO, st_make_sure_mode_data_is_correct); 17538 17539 /* 17540 * check to see if mode data has changed. 17541 */ 17542 rval = st_check_mode_for_change(un, ubf); 17543 if (rval) { 17544 rval = st_gen_mode_select(un, ubf, un->un_mspl, 17545 sizeof (struct seq_mode)); 17546 } 17547 if (un->un_tlr_flag != TLR_NOT_SUPPORTED) { 17548 rval |= st_set_target_TLR_mode(un, ubf); 17549 } 17550 return (rval); 17551 } 17552 17553 static int 17554 st_check_mode_for_change(struct scsi_tape *un, ubufunc_t ubf) 17555 { 17556 struct seq_mode *current; 17557 int rval; 17558 int i; 17559 caddr_t this; 17560 caddr_t that; 17561 17562 ST_FUNC(ST_DEVINFO, st_check_mode_for_change); 17563 17564 /* recovery called with mode tamper before mode selection */ 17565 if (un->un_comp_page == (ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE)) { 17566 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17567 "Mode Select not done yet"); 17568 return (0); 17569 } 17570 17571 current = kmem_zalloc(sizeof (struct seq_mode), KM_SLEEP); 17572 17573 rval = st_gen_mode_sense(un, ubf, un->un_comp_page, current, 17574 sizeof (struct seq_mode)); 17575 if (rval != 0) { 17576 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17577 "Mode Sense for mode verification failed"); 17578 kmem_free(current, sizeof (struct seq_mode)); 17579 return (rval); 17580 } 17581 17582 this = (caddr_t)current; 17583 that = (caddr_t)un->un_mspl; 17584 17585 rval = bcmp(this, that, sizeof (struct seq_mode)); 17586 if (rval == 0) { 17587 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17588 "Found no changes in mode data"); 17589 } 17590 #ifdef STDEBUG 17591 else { 17592 for (i = 1; i < sizeof (struct seq_mode); i++) { 17593 if (this[i] != that[i]) { 17594 ST_RECOV(ST_DEVINFO, st_label, CE_CONT, 17595 "sense data changed at byte %d was " 17596 "0x%x now 0x%x", i, 17597 (uchar_t)that[i], (uchar_t)this[i]); 17598 } 17599 } 17600 } 17601 #endif 17602 kmem_free(current, sizeof (struct seq_mode)); 17603 17604 return (rval); 17605 } 17606 17607 static int 17608 st_test_path_to_device(struct scsi_tape *un) 17609 { 17610 int rval = 0; 17611 int limit = st_retry_count; 17612 17613 ST_FUNC(ST_DEVINFO, st_test_path_to_device); 17614 17615 /* 17616 * XXX Newer drives may not RESEVATION CONFLICT a TUR. 17617 */ 17618 do { 17619 if (rval != 0) { 17620 mutex_exit(ST_MUTEX); 17621 delay(drv_usectohz(1000000)); 17622 mutex_enter(ST_MUTEX); 17623 } 17624 rval = st_rcmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 17625 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17626 "ping TUR returned 0x%x", rval); 17627 limit--; 17628 } while (((rval == EACCES) || (rval == EBUSY)) && limit); 17629 17630 if (un->un_status == KEY_NOT_READY || un->un_mediastate == MTIO_EJECTED) 17631 rval = 0; 17632 17633 return (rval); 17634 } 17635 17636 /* 17637 * Does read position using recov_buf and doesn't update un_pos. 17638 * Does what ever kind of read position you want. 17639 */ 17640 static int 17641 st_recovery_read_pos(struct scsi_tape *un, read_p_types type, 17642 read_pos_data_t *raw) 17643 { 17644 int rval; 17645 struct uscsi_cmd cmd; 17646 struct scsi_arq_status status; 17647 char cdb[CDB_GROUP1]; 17648 17649 ST_FUNC(ST_DEVINFO, st_recovery_read_pos); 17650 bzero(&cmd, sizeof (cmd)); 17651 17652 cdb[0] = SCMD_READ_POSITION; 17653 cdb[1] = type; 17654 cdb[2] = 0; 17655 cdb[3] = 0; 17656 cdb[4] = 0; 17657 cdb[5] = 0; 17658 cdb[6] = 0; 17659 cdb[7] = 0; 17660 cdb[8] = (type == EXT_POS) ? 28 : 0; 17661 cdb[9] = 0; 17662 17663 cmd.uscsi_flags = USCSI_READ | USCSI_RQENABLE; 17664 cmd.uscsi_timeout = un->un_dp->non_motion_timeout; 17665 cmd.uscsi_cdb = cdb; 17666 cmd.uscsi_cdblen = sizeof (cdb); 17667 cmd.uscsi_rqlen = sizeof (status); 17668 cmd.uscsi_rqbuf = (caddr_t)&status; 17669 cmd.uscsi_bufaddr = (caddr_t)raw; 17670 switch (type) { 17671 case SHORT_POS: 17672 cmd.uscsi_buflen = sizeof (tape_position_t); 17673 break; 17674 case LONG_POS: 17675 cmd.uscsi_buflen = sizeof (tape_position_long_t); 17676 break; 17677 case EXT_POS: 17678 cmd.uscsi_buflen = sizeof (tape_position_ext_t); 17679 break; 17680 default: 17681 ASSERT(0); 17682 } 17683 17684 rval = st_uscsi_rcmd(un, &cmd, FKIOCTL); 17685 if (cmd.uscsi_status) { 17686 rval = EIO; 17687 } 17688 return (rval); 17689 } 17690 17691 static int 17692 st_recovery_get_position(struct scsi_tape *un, tapepos_t *read, 17693 read_pos_data_t *raw) 17694 { 17695 int rval; 17696 read_p_types type = un->un_read_pos_type; 17697 17698 ST_FUNC(ST_DEVINFO, st_recovery_get_position); 17699 17700 do { 17701 rval = st_recovery_read_pos(un, type, raw); 17702 if (rval != 0) { 17703 switch (type) { 17704 case SHORT_POS: 17705 type = NO_POS; 17706 break; 17707 17708 case LONG_POS: 17709 type = EXT_POS; 17710 break; 17711 17712 case EXT_POS: 17713 type = SHORT_POS; 17714 break; 17715 17716 default: 17717 type = LONG_POS; 17718 break; 17719 17720 } 17721 } else { 17722 if (type != un->un_read_pos_type) { 17723 un->un_read_pos_type = type; 17724 } 17725 break; 17726 } 17727 } while (type != NO_POS); 17728 17729 if (rval == 0) { 17730 rval = st_interpret_read_pos(un, read, type, 17731 sizeof (read_pos_data_t), (caddr_t)raw, 1); 17732 } 17733 return (rval); 17734 } 17735 17736 /* 17737 * based on the command do we retry, continue or give up? 17738 * possable return values? 17739 * zero do nothing looks fine. 17740 * EAGAIN retry. 17741 * EIO failed makes no sense. 17742 */ 17743 static int 17744 st_compare_expected_position(struct scsi_tape *un, st_err_info *ei, 17745 cmd_attribute const * cmd_att, tapepos_t *read) 17746 { 17747 int rval; 17748 read_pos_data_t *readp_datap; 17749 17750 ST_FUNC(ST_DEVINFO, st_compare_expected_position); 17751 17752 ASSERT(un != NULL); 17753 ASSERT(ei != NULL); 17754 ASSERT(read != NULL); 17755 ASSERT(cmd_att->chg_tape_pos); 17756 17757 COPY_POS(read, &ei->ei_expected_pos); 17758 17759 readp_datap = kmem_zalloc(sizeof (read_pos_data_t), KM_SLEEP); 17760 17761 rval = st_recovery_get_position(un, read, readp_datap); 17762 17763 kmem_free(readp_datap, sizeof (read_pos_data_t)); 17764 17765 if (rval != 0) { 17766 return (EIO); 17767 } 17768 17769 ST_POS(ST_DEVINFO, "st_compare_expected_position", read); 17770 17771 if ((read->pmode == invalid) || 17772 (ei->ei_expected_pos.pmode == invalid)) { 17773 return (EIO); 17774 } 17775 17776 /* 17777 * Command that changes tape position and have an expected position 17778 * if it were to chave completed sucessfully. 17779 */ 17780 if (cmd_att->recov_pos_type == POS_EXPECTED) { 17781 uint32_t count; 17782 int64_t difference; 17783 uchar_t reposition = 0; 17784 17785 ASSERT(cmd_att->get_cnt); 17786 count = cmd_att->get_cnt(ei->ei_failed_pkt.pkt_cdbp); 17787 17788 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17789 "Got count from CDB and it was %d\n", count); 17790 17791 /* 17792 * At expected? 17793 */ 17794 if (read->lgclblkno == ei->ei_expected_pos.lgclblkno) { 17795 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17796 "Found drive to be at expected position\n"); 17797 17798 /* 17799 * If the command should move tape and it got a busy 17800 * it shouldn't be in the expected position. 17801 */ 17802 if (ei->ei_failing_status.sts_status.sts_busy != 0) { 17803 reposition = 1; 17804 17805 /* 17806 * If the command doesn't transfer data should be good. 17807 */ 17808 } else if (cmd_att->transfers_data == TRAN_NONE) { 17809 return (0); /* Good */ 17810 17811 /* 17812 * Command transfers data, should have done so. 17813 */ 17814 } else if (ei->ei_failed_pkt.pkt_state & 17815 STATE_XFERRED_DATA) { 17816 return (0); /* Good */ 17817 } else { 17818 reposition = 1; 17819 } 17820 } 17821 17822 if (cmd_att->chg_tape_direction == DIR_FORW) { 17823 difference = 17824 ei->ei_expected_pos.lgclblkno - read->lgclblkno; 17825 17826 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17827 "difference between expected and actual is %" 17828 PRId64"\n", difference); 17829 if (count == difference && reposition == 0) { 17830 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17831 "Found failed FORW command, retrying\n"); 17832 return (EAGAIN); 17833 } 17834 17835 /* 17836 * If rewound or somewhere between the starting position 17837 * and the expected position (partial read or write). 17838 * Locate to the starting position and try the whole 17839 * thing over again. 17840 */ 17841 if ((read->lgclblkno == 0) || 17842 ((difference > 0) && (difference < count))) { 17843 rval = st_logical_block_locate(un, 17844 st_uscsi_rcmd, read, 17845 ei->ei_expected_pos.lgclblkno - count, 17846 ei->ei_expected_pos.partition); 17847 if (rval == 0) { 17848 ST_RECOV(ST_DEVINFO, st_label, 17849 CE_NOTE, "reestablished FORW" 17850 " command retrying\n"); 17851 return (EAGAIN); 17852 } 17853 /* 17854 * This handles flushed read ahead on the drive or 17855 * an aborted read that presents as a busy and advanced 17856 * the tape position. 17857 */ 17858 } else if ((cmd_att->transfers_data == TRAN_READ) && 17859 ((difference < 0) || (reposition == 1))) { 17860 rval = st_logical_block_locate(un, 17861 st_uscsi_rcmd, read, 17862 ei->ei_expected_pos.lgclblkno - count, 17863 ei->ei_expected_pos.partition); 17864 if (rval == 0) { 17865 ST_RECOV(ST_DEVINFO, st_label, 17866 CE_NOTE, "reestablished FORW" 17867 " read command retrying\n"); 17868 return (EAGAIN); 17869 } 17870 /* 17871 * XXX swag seeing difference of 2 on write filemark. 17872 * If the space to the starting position works on a 17873 * write that means the previous write made it to tape. 17874 * If not we lost data and have to give up. 17875 * 17876 * The plot thickens. Now I am attempting to cover a 17877 * count of 1 and a differance of 2 on a write. 17878 */ 17879 } else if ((difference > count) || (reposition == 1)) { 17880 rval = st_logical_block_locate(un, 17881 st_uscsi_rcmd, read, 17882 ei->ei_expected_pos.lgclblkno - count, 17883 ei->ei_expected_pos.partition); 17884 if (rval == 0) { 17885 ST_RECOV(ST_DEVINFO, st_label, 17886 CE_NOTE, "reestablished FORW" 17887 " write command retrying\n"); 17888 return (EAGAIN); 17889 } 17890 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17891 "Seek to block %"PRId64" returned %d\n", 17892 ei->ei_expected_pos.lgclblkno - count, 17893 rval); 17894 } else { 17895 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17896 "Not expected transfers_data = %d " 17897 "difference = %"PRId64, 17898 cmd_att->transfers_data, difference); 17899 } 17900 17901 return (EIO); 17902 17903 } else if (cmd_att->chg_tape_direction == DIR_REVC) { 17904 /* Don't think we can write backwards */ 17905 ASSERT(cmd_att->transfers_data != TRAN_WRTE); 17906 difference = 17907 read->lgclblkno - ei->ei_expected_pos.lgclblkno; 17908 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17909 "difference between expected and actual is %" 17910 PRId64"\n", difference); 17911 if (count == difference && reposition == 0) { 17912 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17913 "Found failed REVC command, retrying\n"); 17914 return (EAGAIN); 17915 } 17916 if ((read->lgclblkno == 0) || 17917 ((difference > 0) && (difference < count))) { 17918 rval = st_logical_block_locate(un, 17919 st_uscsi_rcmd, read, 17920 ei->ei_expected_pos.lgclblkno + count, 17921 ei->ei_expected_pos.partition); 17922 if (rval == 0) { 17923 ST_RECOV(ST_DEVINFO, st_label, 17924 CE_NOTE, "reestablished REVC" 17925 " command retrying\n"); 17926 return (EAGAIN); 17927 } 17928 /* This handles read ahead in reverse direction */ 17929 } else if ((cmd_att->transfers_data == TRAN_READ) && 17930 (difference < 0) || (reposition == 1)) { 17931 rval = st_logical_block_locate(un, 17932 st_uscsi_rcmd, read, 17933 ei->ei_expected_pos.lgclblkno - count, 17934 ei->ei_expected_pos.partition); 17935 if (rval == 0) { 17936 ST_RECOV(ST_DEVINFO, st_label, 17937 CE_NOTE, "reestablished REVC" 17938 " read command retrying\n"); 17939 return (EAGAIN); 17940 } 17941 } else { 17942 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17943 "Not expected transfers_data = %d " 17944 "difference = %"PRId64, 17945 cmd_att->transfers_data, difference); 17946 } 17947 return (EIO); 17948 17949 } else { 17950 /* 17951 * Commands that change tape position either 17952 * direction or don't change position should not 17953 * get here. 17954 */ 17955 ASSERT(0); 17956 } 17957 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17958 "Didn't find a recoverable position, Failing\n"); 17959 17960 /* 17961 * Command that changes tape position and can only be recovered 17962 * by going back to the point of origin and retrying. 17963 * 17964 * Example SCMD_SPACE. 17965 */ 17966 } else if (cmd_att->recov_pos_type == POS_STARTING) { 17967 /* 17968 * This type of command stores the starting position. 17969 * If the read position is the starting position, 17970 * reissue the command. 17971 */ 17972 if (ei->ei_expected_pos.lgclblkno == read->lgclblkno) { 17973 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17974 "Found Space command at starting position, " 17975 "Reissuing\n"); 17976 return (EAGAIN); 17977 } 17978 /* 17979 * Not in the position that the command was originally issued, 17980 * Attempt to locate to that position. 17981 */ 17982 rval = st_logical_block_locate(un, st_uscsi_rcmd, read, 17983 ei->ei_expected_pos.lgclblkno, 17984 ei->ei_expected_pos.partition); 17985 if (rval) { 17986 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17987 "Found Space at an unexpected position and locate " 17988 "back to starting position failed\n"); 17989 return (EIO); 17990 } 17991 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17992 "Found Space at an unexpected position and locate " 17993 "back to starting position worked, Reissuing\n"); 17994 return (EAGAIN); 17995 } 17996 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 17997 "Unhandled attribute/expected position", &ei->ei_expected_pos); 17998 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 17999 "Read position above did not make sense", read); 18000 ASSERT(0); 18001 return (EIO); 18002 } 18003 18004 static errstate 18005 st_recover_reissue_pkt(struct scsi_tape *un, struct scsi_pkt *oldpkt) 18006 { 18007 buf_t *bp; 18008 buf_t *pkt_bp; 18009 struct scsi_pkt *newpkt; 18010 cmd_attribute const *attrib; 18011 recov_info *rcv = oldpkt->pkt_private; 18012 uint_t cdblen; 18013 int queued = 0; 18014 int rval; 18015 int flags = 0; 18016 int stat_size = 18017 (un->un_arq_enabled ? sizeof (struct scsi_arq_status) : 1); 18018 18019 ST_FUNC(ST_DEVINFO, st_recover_reissue_pkt); 18020 18021 bp = rcv->cmd_bp; 18022 18023 if (rcv->privatelen == sizeof (recov_info)) { 18024 attrib = rcv->cmd_attrib; 18025 } else { 18026 attrib = st_lookup_cmd_attribute(oldpkt->pkt_cdbp[0]); 18027 } 18028 18029 /* 18030 * Some non-uscsi commands use the b_bcount for values that 18031 * have nothing to do with how much data is transfered. 18032 * In those cases we need to hide the buf_t from scsi_init_pkt(). 18033 */ 18034 if ((BP_UCMD(bp)) && (bp->b_bcount)) { 18035 pkt_bp = bp; 18036 } else if (attrib->transfers_data == TRAN_NONE) { 18037 pkt_bp = NULL; 18038 } else { 18039 pkt_bp = bp; 18040 } 18041 18042 /* 18043 * if this is a queued command make sure it the only one in the 18044 * run queue. 18045 */ 18046 if (bp != un->un_sbufp && bp != un->un_recov_buf) { 18047 ASSERT(un->un_runqf == un->un_runql); 18048 ASSERT(un->un_runqf == bp); 18049 queued = 1; 18050 } 18051 18052 cdblen = scsi_cdb_size[CDB_GROUPID(oldpkt->pkt_cdbp[0])]; 18053 18054 if (pkt_bp == un->un_rqs_bp) { 18055 flags |= PKT_CONSISTENT; 18056 stat_size = 1; 18057 } 18058 18059 newpkt = scsi_init_pkt(ROUTE, NULL, pkt_bp, cdblen, 18060 stat_size, rcv->privatelen, flags, NULL_FUNC, NULL); 18061 if (newpkt == NULL) { 18062 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 18063 "Reissue pkt scsi_init_pkt() failure\n"); 18064 return (COMMAND_DONE_ERROR); 18065 } 18066 18067 ASSERT(newpkt->pkt_resid == 0); 18068 bp->b_flags &= ~(B_DONE); 18069 bp->b_resid = 0; 18070 st_bioerror(bp, 0); 18071 18072 bcopy(oldpkt->pkt_private, newpkt->pkt_private, rcv->privatelen); 18073 18074 newpkt->pkt_comp = oldpkt->pkt_comp; 18075 newpkt->pkt_time = oldpkt->pkt_time; 18076 18077 bzero(newpkt->pkt_scbp, stat_size); 18078 bcopy(oldpkt->pkt_cdbp, newpkt->pkt_cdbp, cdblen); 18079 18080 newpkt->pkt_state = 0; 18081 newpkt->pkt_statistics = 0; 18082 18083 /* 18084 * oldpkt passed in was a copy of the original. 18085 * to distroy we need the address of the original. 18086 */ 18087 oldpkt = BP_PKT(bp); 18088 18089 if (oldpkt == un->un_rqs) { 18090 ASSERT(bp == un->un_rqs_bp); 18091 un->un_rqs = newpkt; 18092 } 18093 18094 SET_BP_PKT(bp, newpkt); 18095 18096 scsi_destroy_pkt(oldpkt); 18097 18098 rval = st_transport(un, newpkt); 18099 if (rval == TRAN_ACCEPT) { 18100 return (JUST_RETURN); 18101 } 18102 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 18103 "Reissue pkt st_transport(0x%x) failure\n", rval); 18104 if (rval != TRAN_BUSY) { 18105 return (COMMAND_DONE_ERROR); 18106 } 18107 mutex_exit(ST_MUTEX); 18108 rval = st_handle_start_busy(un, bp, ST_TRAN_BUSY_TIMEOUT, queued); 18109 mutex_enter(ST_MUTEX); 18110 if (rval) { 18111 return (COMMAND_DONE_ERROR); 18112 } 18113 18114 return (JUST_RETURN); 18115 } 18116 18117 static int 18118 st_transport(struct scsi_tape *un, struct scsi_pkt *pkt) 18119 { 18120 int status; 18121 18122 ST_FUNC(ST_DEVINFO, st_transport); 18123 18124 ST_CDB(ST_DEVINFO, "transport CDB", (caddr_t)pkt->pkt_cdbp); 18125 18126 mutex_exit(ST_MUTEX); 18127 18128 status = scsi_transport(pkt); 18129 18130 mutex_enter(ST_MUTEX); 18131 18132 return (status); 18133 } 18134 18135 /* 18136 * Removed the buf_t bp from the queue referenced to by head and tail. 18137 * Returns the buf_t pointer if it is found in the queue. 18138 * Returns NULL if it is not found. 18139 */ 18140 static buf_t * 18141 st_remove_from_queue(buf_t **head, buf_t **tail, buf_t *bp) 18142 { 18143 buf_t *runqbp; 18144 buf_t *prevbp = NULL; 18145 18146 for (runqbp = *head; runqbp != 0; runqbp = runqbp->av_forw) { 18147 if (runqbp == bp) { 18148 /* found it, is it at the head? */ 18149 if (runqbp == *head) { 18150 *head = bp->av_forw; 18151 } else { 18152 prevbp->av_forw = bp->av_forw; 18153 } 18154 if (*tail == bp) { 18155 *tail = prevbp; 18156 } 18157 bp->av_forw = NULL; 18158 return (bp); /* found and removed */ 18159 } 18160 prevbp = runqbp; 18161 } 18162 return (NULL); 18163 } 18164 18165 /* 18166 * Adds a buf_t to the queue pointed to by head and tail. 18167 * Adds it either to the head end or the tail end based on which 18168 * the passed variable end (head or tail) points at. 18169 */ 18170 static void 18171 st_add_to_queue(buf_t **head, buf_t **tail, buf_t *end, buf_t *bp) 18172 { 18173 18174 bp->av_forw = NULL; 18175 if (*head) { 18176 /* Queue is not empty */ 18177 if (end == *head) { 18178 /* Add at front of queue */ 18179 bp->av_forw = *head; 18180 *head = bp; 18181 } else if (end == *tail) { 18182 /* Add at end of queue */ 18183 (*tail)->av_forw = bp; 18184 *tail = bp; 18185 } else { 18186 ASSERT(0); 18187 } 18188 } else { 18189 /* Queue is empty */ 18190 *head = bp; 18191 *tail = bp; 18192 } 18193 } 18194 18195 18196 static uint64_t 18197 st_get_cdb_g0_rw_count(uchar_t *cdb) 18198 { 18199 uint64_t count; 18200 18201 if ((cdb[1]) & 1) { 18202 /* fixed block mode, the count is the number of blocks */ 18203 count = 18204 cdb[2] << 16 | 18205 cdb[3] << 8 | 18206 cdb[4]; 18207 } else { 18208 /* variable block mode, the count is the block size */ 18209 count = 1; 18210 } 18211 return (count); 18212 } 18213 18214 static uint64_t 18215 st_get_cdb_g0_sign_count(uchar_t *cdb) 18216 { 18217 uint64_t count; 18218 18219 count = 18220 cdb[2] << 16 | 18221 cdb[3] << 8 | 18222 cdb[4]; 18223 /* 18224 * If the sign bit of the 3 byte value is set, extended it. 18225 */ 18226 if (count & 0x800000) { 18227 count |= 0xffffffffff000000; 18228 } 18229 return (count); 18230 } 18231 18232 static uint64_t 18233 st_get_cdb_g0_count(uchar_t *cdb) 18234 { 18235 uint64_t count; 18236 18237 count = 18238 cdb[2] << 16 | 18239 cdb[3] << 8 | 18240 cdb[4]; 18241 return (count); 18242 } 18243 18244 static uint64_t 18245 st_get_cdb_g5_rw_cnt(uchar_t *cdb) 18246 { 18247 uint64_t count; 18248 18249 if ((cdb[1]) & 1) { 18250 /* fixed block mode */ 18251 count = 18252 cdb[12] << 16 | 18253 cdb[13] << 8 | 18254 cdb[14]; 18255 } else { 18256 /* variable block mode */ 18257 count = 1; 18258 } 18259 return (count); 18260 } 18261 18262 static uint64_t 18263 st_get_no_count(uchar_t *cdb) 18264 { 18265 ASSERT(cdb[0] == SCMD_REWIND); 18266 return ((uint64_t)cdb[0]); 18267 } 18268 18269 static uint64_t 18270 st_get_load_options(uchar_t *cdb) 18271 { 18272 return ((uint64_t)(cdb[4] | (LD_HOLD << 1))); 18273 } 18274 18275 static uint64_t 18276 st_get_erase_options(uchar_t *cdb) 18277 { 18278 return (cdb[1] | (cdb[0] << 8)); 18279 } 18280 18281 static uint64_t 18282 st_get_cdb_g1_lba(uchar_t *cdb) 18283 { 18284 uint64_t lba; 18285 18286 lba = 18287 cdb[3] << 24 | 18288 cdb[4] << 16 | 18289 cdb[5] << 8 | 18290 cdb[6]; 18291 return (lba); 18292 } 18293 18294 static uint64_t 18295 st_get_cdb_g5_count(uchar_t *cdb) 18296 { 18297 uint64_t count = 18298 cdb[12] << 16 | 18299 cdb[13] << 8 | 18300 cdb[14]; 18301 18302 return (count); 18303 } 18304 18305 static uint64_t 18306 st_get_cdb_g4g5_cnt(uchar_t *cdb) 18307 { 18308 uint64_t lba; 18309 18310 lba = 18311 (uint64_t)cdb[4] << 56 | 18312 (uint64_t)cdb[5] << 48 | 18313 (uint64_t)cdb[6] << 40 | 18314 (uint64_t)cdb[7] << 32 | 18315 (uint64_t)cdb[8] << 24 | 18316 (uint64_t)cdb[9] << 16 | 18317 (uint64_t)cdb[10] << 8 | 18318 (uint64_t)cdb[11]; 18319 return (lba); 18320 } 18321 18322 static const cmd_attribute cmd_attributes[] = { 18323 { SCMD_READ, 18324 1, 0, 1, 0, 0, DIR_FORW, TRAN_READ, POS_EXPECTED, 18325 0, 0, 0, st_get_cdb_g0_rw_count }, 18326 { SCMD_WRITE, 18327 1, 0, 1, 1, 0, DIR_FORW, TRAN_WRTE, POS_EXPECTED, 18328 0, 0, 0, st_get_cdb_g0_rw_count }, 18329 { SCMD_TEST_UNIT_READY, 18330 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18331 0, 0, 0 }, 18332 { SCMD_REWIND, 18333 1, 1, 1, 0, 0, DIR_REVC, TRAN_NONE, POS_EXPECTED, 18334 0, 0, 0, st_get_no_count }, 18335 { SCMD_REQUEST_SENSE, 18336 0, 0, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18337 0, 0, 0 }, 18338 { SCMD_READ_BLKLIM, 18339 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18340 0, 0, 0 }, 18341 { SCMD_READ_G4, 18342 1, 0, 1, 0, 1, DIR_FORW, TRAN_READ, POS_EXPECTED, 18343 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 18344 { SCMD_WRITE_G4, 18345 1, 0, 1, 1, 1, DIR_FORW, TRAN_WRTE, POS_EXPECTED, 18346 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 18347 { SCMD_READ_REVERSE, 18348 1, 0, 1, 1, 0, DIR_REVC, TRAN_READ, POS_EXPECTED, 18349 0, 0, 0, st_get_cdb_g0_rw_count }, 18350 { SCMD_READ_REVERSE_G4, 18351 1, 0, 1, 1, 1, DIR_REVC, TRAN_READ, POS_EXPECTED, 18352 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 18353 { SCMD_WRITE_FILE_MARK, 18354 1, 0, 1, 1, 0, DIR_FORW, TRAN_NONE, POS_EXPECTED, 18355 0, 0, 0, st_get_cdb_g0_count }, 18356 { SCMD_WRITE_FILE_MARK_G4, 18357 1, 0, 1, 1, 1, DIR_FORW, TRAN_NONE, POS_EXPECTED, 18358 0, 0, 0, st_get_cdb_g5_count, st_get_cdb_g4g5_cnt }, 18359 { SCMD_SPACE, 18360 1, 0, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_STARTING, 18361 0, 0, 0, st_get_cdb_g0_sign_count }, 18362 { SCMD_SPACE_G4, 18363 1, 0, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_STARTING, 18364 0, 0, 0, st_get_cdb_g4g5_cnt }, 18365 { SCMD_INQUIRY, 18366 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18367 0, 0, 0 }, 18368 { SCMD_VERIFY_G0, 18369 1, 0, 1, 0, 0, DIR_FORW, TRAN_NONE, POS_EXPECTED, 18370 0, 0, 0, st_get_cdb_g0_rw_count }, 18371 { SCMD_VERIFY_G4, 18372 1, 0, 1, 0, 1, DIR_FORW, TRAN_NONE, POS_EXPECTED, 18373 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 18374 { SCMD_RECOVER_BUF, 18375 1, 0, 1, 1, 0, DIR_REVC, TRAN_READ, POS_EXPECTED, 18376 0, 0, 0 }, 18377 { SCMD_MODE_SELECT, 18378 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18379 0, 0, 0 }, 18380 { SCMD_RESERVE, 18381 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18382 0, 0, 0 }, 18383 { SCMD_RELEASE, 18384 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18385 0, 0, 0 }, 18386 { SCMD_ERASE, 18387 1, 0, 1, 1, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18388 0, 0, 0, st_get_erase_options }, 18389 { SCMD_MODE_SENSE, 18390 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18391 0, 0, 0 }, 18392 { SCMD_LOAD, 18393 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 18394 0, 0, 0, st_get_load_options }, 18395 { SCMD_GDIAG, 18396 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18397 1, 0, 0 }, 18398 { SCMD_SDIAG, 18399 1, 0, 1, 1, 0, DIR_EITH, TRAN_WRTE, POS_EXPECTED, 18400 1, 0, 0 }, 18401 { SCMD_DOORLOCK, 18402 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18403 0, 4, 3 }, 18404 { SCMD_LOCATE, 18405 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 18406 0, 0, 0, NULL, st_get_cdb_g1_lba }, 18407 { SCMD_READ_POSITION, 18408 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18409 0, 0, 0 }, 18410 { SCMD_WRITE_BUFFER, 18411 1, 0, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18412 1, 0, 0 }, 18413 { SCMD_READ_BUFFER, 18414 1, 0, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18415 1, 0, 0 }, 18416 { SCMD_REPORT_DENSITIES, 18417 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18418 0, 0, 0 }, 18419 { SCMD_LOG_SELECT_G1, 18420 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18421 0, 0, 0 }, 18422 { SCMD_LOG_SENSE_G1, 18423 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18424 0, 0, 0 }, 18425 { SCMD_PRIN, 18426 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18427 0, 0, 0 }, 18428 { SCMD_PROUT, 18429 0, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18430 0, 0, 0 }, 18431 { SCMD_READ_ATTRIBUTE, 18432 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18433 0, 0, 0 }, 18434 { SCMD_WRITE_ATTRIBUTE, 18435 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18436 0, 0, 0 }, 18437 { SCMD_LOCATE_G4, 18438 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 18439 0, 0, 0, NULL, st_get_cdb_g4g5_cnt }, 18440 { SCMD_REPORT_LUNS, 18441 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18442 0, 0, 0 }, 18443 { SCMD_SVC_ACTION_IN_G5, 18444 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18445 0, 0, 0 }, 18446 { SCMD_MAINTENANCE_IN, 18447 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18448 0, 0, 0 }, 18449 { SCMD_MAINTENANCE_OUT, 18450 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18451 0, 0, 0 }, 18452 { 0xff, /* Default attribute for unsupported commands */ 18453 1, 0, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_STARTING, 18454 1, 0, 0, NULL, NULL } 18455 }; 18456 18457 static const cmd_attribute * 18458 st_lookup_cmd_attribute(unsigned char cmd) 18459 { 18460 int i; 18461 cmd_attribute const *attribute; 18462 18463 for (i = 0; i < ST_NUM_MEMBERS(cmd_attributes); i++) { 18464 attribute = &cmd_attributes[i]; 18465 if (attribute->cmd == cmd) { 18466 return (attribute); 18467 } 18468 } 18469 ASSERT(attribute); 18470 return (attribute); 18471 } 18472 18473 static int 18474 st_reset(struct scsi_tape *un, int reset_type) 18475 { 18476 int rval; 18477 18478 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 18479 18480 ST_FUNC(ST_DEVINFO, st_reset); 18481 un->un_rsvd_status |= ST_INITIATED_RESET; 18482 mutex_exit(ST_MUTEX); 18483 do { 18484 rval = scsi_reset(&un->un_sd->sd_address, reset_type); 18485 if (rval == 0) { 18486 switch (reset_type) { 18487 case RESET_LUN: 18488 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 18489 "LUN reset failed trying target reset"); 18490 reset_type = RESET_TARGET; 18491 break; 18492 case RESET_TARGET: 18493 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 18494 "target reset failed trying bus reset"); 18495 reset_type = RESET_BUS; 18496 break; 18497 case RESET_BUS: 18498 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 18499 "bus reset failed trying all reset"); 18500 reset_type = RESET_ALL; 18501 default: 18502 mutex_enter(ST_MUTEX); 18503 return (rval); 18504 } 18505 } 18506 } while (rval == 0); 18507 mutex_enter(ST_MUTEX); 18508 return (rval); 18509 } 18510 18511 #define SAS_TLR_MOD_LEN sizeof (struct seq_mode) 18512 static int 18513 st_set_target_TLR_mode(struct scsi_tape *un, ubufunc_t ubf) 18514 { 18515 int ret; 18516 int amount = SAS_TLR_MOD_LEN; 18517 struct seq_mode *mode_data; 18518 18519 ST_FUNC(ST_DEVINFO, st_set_target_TLR_mode); 18520 18521 mode_data = kmem_zalloc(SAS_TLR_MOD_LEN, KM_SLEEP); 18522 ret = st_gen_mode_sense(un, ubf, 0x18, mode_data, amount); 18523 if (ret != DDI_SUCCESS) { 18524 if (ret != EACCES) 18525 un->un_tlr_flag = TLR_NOT_SUPPORTED; 18526 goto out; 18527 } 18528 if (mode_data->data_len != amount + 1) { 18529 amount = mode_data->data_len + 1; 18530 } 18531 /* Must be SAS protocol */ 18532 if (mode_data->page.saslun.protocol_id != 6) { 18533 un->un_tlr_flag = TLR_NOT_SUPPORTED; 18534 ret = ENOTSUP; 18535 goto out; 18536 } 18537 if (un->un_tlr_flag == TLR_SAS_ONE_DEVICE) { 18538 if (mode_data->page.saslun.tran_layer_ret == 1) 18539 goto out; 18540 mode_data->page.saslun.tran_layer_ret = 1; 18541 } else { 18542 if (mode_data->page.saslun.tran_layer_ret == 0) 18543 goto out; 18544 mode_data->page.saslun.tran_layer_ret = 0; 18545 } 18546 ret = st_gen_mode_select(un, ubf, mode_data, amount); 18547 if (ret != DDI_SUCCESS) { 18548 if (ret != EACCES) 18549 un->un_tlr_flag = TLR_NOT_SUPPORTED; 18550 } else { 18551 if (mode_data->page.saslun.tran_layer_ret == 0) 18552 un->un_tlr_flag = TLR_NOT_KNOWN; 18553 else 18554 un->un_tlr_flag = TLR_SAS_ONE_DEVICE; 18555 } 18556 #ifdef STDEBUG 18557 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, "TLR data sent", 18558 (char *)mode_data, amount); 18559 #endif 18560 out: 18561 kmem_free(mode_data, SAS_TLR_MOD_LEN); 18562 return (ret); 18563 } 18564 18565 18566 static void 18567 st_reset_notification(caddr_t arg) 18568 { 18569 struct scsi_tape *un = (struct scsi_tape *)arg; 18570 18571 ST_FUNC(ST_DEVINFO, st_reset_notification); 18572 mutex_enter(ST_MUTEX); 18573 18574 un->un_unit_attention_flags |= 2; 18575 if ((un->un_rsvd_status & (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 18576 ST_RESERVE) { 18577 un->un_rsvd_status |= ST_LOST_RESERVE; 18578 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 18579 "Lost Reservation notification"); 18580 } else { 18581 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 18582 "reset notification"); 18583 } 18584 18585 if ((un->un_restore_pos == 0) && 18586 (un->un_state == ST_STATE_CLOSED) || 18587 (un->un_state == ST_STATE_OPEN_PENDING_IO) || 18588 (un->un_state == ST_STATE_CLOSING)) { 18589 un->un_restore_pos = 1; 18590 } 18591 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 18592 "reset and state was %d\n", un->un_state); 18593 mutex_exit(ST_MUTEX); 18594 }