1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2011 Bayard G. Bell. All rights reserved. 25 */ 26 27 /* 28 * SCSI SCSA-compliant and not-so-DDI-compliant Tape Driver 29 */ 30 31 #if defined(lint) && !defined(DEBUG) 32 #define DEBUG 1 33 #endif 34 35 #include <sys/modctl.h> 36 #include <sys/scsi/scsi.h> 37 #include <sys/mtio.h> 38 #include <sys/scsi/targets/stdef.h> 39 #include <sys/file.h> 40 #include <sys/kstat.h> 41 #include <sys/ddidmareq.h> 42 #include <sys/ddi.h> 43 #include <sys/sunddi.h> 44 #include <sys/byteorder.h> 45 46 #define IOSP KSTAT_IO_PTR(un->un_stats) 47 /* 48 * stats maintained only for reads/writes as commands 49 * like rewind etc skew the wait/busy times 50 */ 51 #define IS_RW(bp) ((bp)->b_bcount > 0) 52 #define ST_DO_KSTATS(bp, kstat_function) \ 53 if ((bp != un->un_sbufp) && un->un_stats && IS_RW(bp)) { \ 54 kstat_function(IOSP); \ 55 } 56 57 #define ST_DO_ERRSTATS(un, x) \ 58 if (un->un_errstats) { \ 59 struct st_errstats *stp; \ 60 stp = (struct st_errstats *)un->un_errstats->ks_data; \ 61 stp->x.value.ul++; \ 62 } 63 64 #define FILL_SCSI1_LUN(devp, pkt) \ 65 if ((devp)->sd_inq->inq_ansi == 0x1) { \ 66 int _lun; \ 67 _lun = ddi_prop_get_int(DDI_DEV_T_ANY, (devp)->sd_dev, \ 68 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0); \ 69 if (_lun > 0) { \ 70 ((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun = \ 71 _lun; \ 72 } \ 73 } 74 75 /* 76 * get an available contig mem header, cp. 77 * when big_enough is true, we will return NULL, if no big enough 78 * contig mem is found. 79 * when big_enough is false, we will try to find cp containing big 80 * enough contig mem. if not found, we will ruturn the last cp available. 81 * 82 * used by st_get_contig_mem() 83 */ 84 #define ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough) { \ 85 struct contig_mem *tmp_cp = NULL; \ 86 for ((cp) = (un)->un_contig_mem; \ 87 (cp) != NULL; \ 88 tmp_cp = (cp), (cp) = (cp)->cm_next) { \ 89 if (((cp)->cm_len >= (len)) || \ 90 (!(big_enough) && ((cp)->cm_next == NULL))) { \ 91 if (tmp_cp == NULL) { \ 92 (un)->un_contig_mem = (cp)->cm_next; \ 93 } else { \ 94 tmp_cp->cm_next = (cp)->cm_next; \ 95 } \ 96 (cp)->cm_next = NULL; \ 97 (un)->un_contig_mem_available_num--; \ 98 break; \ 99 } \ 100 } \ 101 } 102 103 #define ST_NUM_MEMBERS(array) (sizeof (array) / sizeof (array[0])) 104 #define COPY_POS(dest, source) bcopy(source, dest, sizeof (tapepos_t)) 105 #define ISALNUM(byte) \ 106 (((byte) >= 'a' && (byte) <= 'z') || \ 107 ((byte) >= 'A' && (byte) <= 'Z') || \ 108 ((byte) >= '0' && (byte) <= '9')) 109 110 #define ONE_K 1024 111 112 #define MAX_SPACE_CNT(cnt) if (cnt >= 0) { \ 113 if (cnt > MIN(SP_CNT_MASK, INT32_MAX)) \ 114 return (EINVAL); \ 115 } else { \ 116 if (-(cnt) > MIN(SP_CNT_MASK, INT32_MAX)) \ 117 return (EINVAL); \ 118 } \ 119 120 /* 121 * Global External Data Definitions 122 */ 123 extern struct scsi_key_strings scsi_cmds[]; 124 extern uchar_t scsi_cdb_size[]; 125 126 /* 127 * Local Static Data 128 */ 129 static void *st_state; 130 static char *const st_label = "st"; 131 static volatile int st_recov_sz = sizeof (recov_info); 132 static const char mp_misconf[] = { 133 "St Tape is misconfigured, MPxIO enabled and " 134 "tape-command-recovery-disable set in st.conf\n" 135 }; 136 137 #ifdef __x86 138 /* 139 * We need to use below DMA attr to alloc physically contiguous 140 * memory to do I/O in big block size 141 */ 142 static ddi_dma_attr_t st_contig_mem_dma_attr = { 143 DMA_ATTR_V0, /* version number */ 144 0x0, /* lowest usable address */ 145 0xFFFFFFFFull, /* high DMA address range */ 146 0xFFFFFFFFull, /* DMA counter register */ 147 1, /* DMA address alignment */ 148 1, /* DMA burstsizes */ 149 1, /* min effective DMA size */ 150 0xFFFFFFFFull, /* max DMA xfer size */ 151 0xFFFFFFFFull, /* segment boundary */ 152 1, /* s/g list length */ 153 1, /* granularity of device */ 154 0 /* DMA transfer flags */ 155 }; 156 157 static ddi_device_acc_attr_t st_acc_attr = { 158 DDI_DEVICE_ATTR_V0, 159 DDI_NEVERSWAP_ACC, 160 DDI_STRICTORDER_ACC 161 }; 162 163 /* set limitation for the number of contig_mem */ 164 static int st_max_contig_mem_num = ST_MAX_CONTIG_MEM_NUM; 165 #endif 166 167 /* 168 * Tunable parameters 169 * 170 * DISCLAIMER 171 * ---------- 172 * These parameters are intended for use only in system testing; if you use 173 * them in production systems, you do so at your own risk. Altering any 174 * variable not listed below may cause unpredictable system behavior. 175 * 176 * st_check_media_time 177 * 178 * Three second state check 179 * 180 * st_allow_large_xfer 181 * 182 * Gated with ST_NO_RECSIZE_LIMIT 183 * 184 * 0 - Transfers larger than 64KB will not be allowed 185 * regardless of the setting of ST_NO_RECSIZE_LIMIT 186 * 1 - Transfers larger than 64KB will be allowed 187 * if ST_NO_RECSIZE_LIMIT is TRUE for the drive 188 * 189 * st_report_soft_errors_on_close 190 * 191 * Gated with ST_SOFT_ERROR_REPORTING 192 * 193 * 0 - Errors will not be reported on close regardless 194 * of the setting of ST_SOFT_ERROR_REPORTING 195 * 196 * 1 - Errors will be reported on close if 197 * ST_SOFT_ERROR_REPORTING is TRUE for the drive 198 */ 199 static int st_selection_retry_count = ST_SEL_RETRY_COUNT; 200 static int st_retry_count = ST_RETRY_COUNT; 201 202 static int st_io_time = ST_IO_TIME; 203 static int st_long_timeout_x = ST_LONG_TIMEOUT_X; 204 205 static int st_space_time = ST_SPACE_TIME; 206 static int st_long_space_time_x = ST_LONG_SPACE_TIME_X; 207 208 static int st_error_level = SCSI_ERR_RETRYABLE; 209 static int st_check_media_time = 3000000; /* 3 Second State Check */ 210 211 static int st_max_throttle = ST_MAX_THROTTLE; 212 213 static clock_t st_wait_cmds_complete = ST_WAIT_CMDS_COMPLETE; 214 215 static int st_allow_large_xfer = 1; 216 static int st_report_soft_errors_on_close = 1; 217 218 /* 219 * End of tunable parameters list 220 */ 221 222 223 224 /* 225 * Asynchronous I/O and persistent errors, refer to PSARC/1995/228 226 * 227 * Asynchronous I/O's main offering is that it is a non-blocking way to do 228 * reads and writes. The driver will queue up all the requests it gets and 229 * have them ready to transport to the HBA. Unfortunately, we cannot always 230 * just ship the I/O requests to the HBA, as there errors and exceptions 231 * that may happen when we don't want the HBA to continue. Therein comes 232 * the flush-on-errors capability. If the HBA supports it, then st will 233 * send in st_max_throttle I/O requests at the same time. 234 * 235 * Persistent errors : This was also reasonably simple. In the interrupt 236 * routines, if there was an error or exception (FM, LEOT, media error, 237 * transport error), the persistent error bits are set and shuts everything 238 * down, but setting the throttle to zero. If we hit and exception in the 239 * HBA, and flush-on-errors were set, we wait for all outstanding I/O's to 240 * come back (with CMD_ABORTED), then flush all bp's in the wait queue with 241 * the appropriate error, and this will preserve order. Of course, depending 242 * on the exception we have to show a zero read or write before we show 243 * errors back to the application. 244 */ 245 246 extern const int st_ndrivetypes; /* defined in st_conf.c */ 247 extern const struct st_drivetype st_drivetypes[]; 248 extern const char st_conf_version[]; 249 250 #ifdef STDEBUG 251 static int st_soft_error_report_debug = 0; 252 volatile int st_debug = 0; 253 static volatile dev_info_t *st_lastdev; 254 static kmutex_t st_debug_mutex; 255 #endif 256 257 #define ST_MT02_NAME "Emulex MT02 QIC-11/24 " 258 259 static const struct vid_drivetype { 260 char *vid; 261 char type; 262 } st_vid_dt[] = { 263 {"LTO-CVE ", MT_LTO}, 264 {"QUANTUM ", MT_ISDLT}, 265 {"SONY ", MT_ISAIT}, 266 {"STK ", MT_ISSTK9840} 267 }; 268 269 static const struct driver_minor_data { 270 char *name; 271 int minor; 272 } st_minor_data[] = { 273 /* 274 * The top 4 entries are for the default densities, 275 * don't alter their position. 276 */ 277 {"", 0}, 278 {"n", MT_NOREWIND}, 279 {"b", MT_BSD}, 280 {"bn", MT_NOREWIND | MT_BSD}, 281 {"l", MT_DENSITY1}, 282 {"m", MT_DENSITY2}, 283 {"h", MT_DENSITY3}, 284 {"c", MT_DENSITY4}, 285 {"u", MT_DENSITY4}, 286 {"ln", MT_DENSITY1 | MT_NOREWIND}, 287 {"mn", MT_DENSITY2 | MT_NOREWIND}, 288 {"hn", MT_DENSITY3 | MT_NOREWIND}, 289 {"cn", MT_DENSITY4 | MT_NOREWIND}, 290 {"un", MT_DENSITY4 | MT_NOREWIND}, 291 {"lb", MT_DENSITY1 | MT_BSD}, 292 {"mb", MT_DENSITY2 | MT_BSD}, 293 {"hb", MT_DENSITY3 | MT_BSD}, 294 {"cb", MT_DENSITY4 | MT_BSD}, 295 {"ub", MT_DENSITY4 | MT_BSD}, 296 {"lbn", MT_DENSITY1 | MT_NOREWIND | MT_BSD}, 297 {"mbn", MT_DENSITY2 | MT_NOREWIND | MT_BSD}, 298 {"hbn", MT_DENSITY3 | MT_NOREWIND | MT_BSD}, 299 {"cbn", MT_DENSITY4 | MT_NOREWIND | MT_BSD}, 300 {"ubn", MT_DENSITY4 | MT_NOREWIND | MT_BSD} 301 }; 302 303 /* strings used in many debug and warning messages */ 304 static const char wr_str[] = "write"; 305 static const char rd_str[] = "read"; 306 static const char wrg_str[] = "writing"; 307 static const char rdg_str[] = "reading"; 308 static const char *space_strs[] = { 309 "records", 310 "filemarks", 311 "sequential filemarks", 312 "eod", 313 "setmarks", 314 "sequential setmarks", 315 "Reserved", 316 "Reserved" 317 }; 318 static const char *load_strs[] = { 319 "unload", /* LD_UNLOAD 0 */ 320 "load", /* LD_LOAD 1 */ 321 "retension", /* LD_RETEN 2 */ 322 "load reten", /* LD_LOAD | LD_RETEN 3 */ 323 "eod", /* LD_EOT 4 */ 324 "load EOD", /* LD_LOAD | LD_EOT 5 */ 325 "reten EOD", /* LD_RETEN | LD_EOT 6 */ 326 "load reten EOD" /* LD_LOAD|LD_RETEN|LD_EOT 7 */ 327 "hold", /* LD_HOLD 8 */ 328 "load and hold" /* LD_LOAD | LD_HOLD 9 */ 329 }; 330 331 static const char *errstatenames[] = { 332 "COMMAND_DONE", 333 "COMMAND_DONE_ERROR", 334 "COMMAND_DONE_ERROR_RECOVERED", 335 "QUE_COMMAND", 336 "QUE_BUSY_COMMAND", 337 "QUE_SENSE", 338 "JUST_RETURN", 339 "COMMAND_DONE_EACCES", 340 "QUE_LAST_COMMAND", 341 "COMMAND_TIMEOUT", 342 "PATH_FAILED", 343 "DEVICE_RESET", 344 "DEVICE_TAMPER", 345 "ATTEMPT_RETRY" 346 }; 347 348 const char *bogusID = "Unknown Media ID"; 349 350 /* default density offsets in the table above */ 351 #define DEF_BLANK 0 352 #define DEF_NOREWIND 1 353 #define DEF_BSD 2 354 #define DEF_BSD_NR 3 355 356 /* Sense Key, ASC/ASCQ for which tape ejection is needed */ 357 358 static struct tape_failure_code { 359 uchar_t key; 360 uchar_t add_code; 361 uchar_t qual_code; 362 } st_tape_failure_code[] = { 363 { KEY_HARDWARE_ERROR, 0x15, 0x01}, 364 { KEY_HARDWARE_ERROR, 0x44, 0x00}, 365 { KEY_HARDWARE_ERROR, 0x53, 0x00}, 366 { KEY_HARDWARE_ERROR, 0x53, 0x01}, 367 { KEY_NOT_READY, 0x53, 0x00}, 368 { 0xff} 369 }; 370 371 /* clean bit position and mask */ 372 373 static struct cln_bit_position { 374 ushort_t cln_bit_byte; 375 uchar_t cln_bit_mask; 376 } st_cln_bit_position[] = { 377 { 21, 0x08}, 378 { 70, 0xc0}, 379 { 18, 0x81} /* 80 bit indicates in bit mode, 1 bit clean light is on */ 380 }; 381 382 /* 383 * architecture dependent allocation restrictions. For x86, we'll set 384 * dma_attr_addr_hi to st_max_phys_addr and dma_attr_sgllen to 385 * st_sgl_size during _init(). 386 */ 387 #if defined(__sparc) 388 static ddi_dma_attr_t st_alloc_attr = { 389 DMA_ATTR_V0, /* version number */ 390 0x0, /* lowest usable address */ 391 0xFFFFFFFFull, /* high DMA address range */ 392 0xFFFFFFFFull, /* DMA counter register */ 393 1, /* DMA address alignment */ 394 1, /* DMA burstsizes */ 395 1, /* min effective DMA size */ 396 0xFFFFFFFFull, /* max DMA xfer size */ 397 0xFFFFFFFFull, /* segment boundary */ 398 1, /* s/g list length */ 399 512, /* granularity of device */ 400 0 /* DMA transfer flags */ 401 }; 402 #elif defined(__x86) 403 static ddi_dma_attr_t st_alloc_attr = { 404 DMA_ATTR_V0, /* version number */ 405 0x0, /* lowest usable address */ 406 0x0, /* high DMA address range [set in _init()] */ 407 0xFFFFull, /* DMA counter register */ 408 512, /* DMA address alignment */ 409 1, /* DMA burstsizes */ 410 1, /* min effective DMA size */ 411 0xFFFFFFFFull, /* max DMA xfer size */ 412 0xFFFFFFFFull, /* segment boundary */ 413 0, /* s/g list length */ 414 512, /* granularity of device [set in _init()] */ 415 0 /* DMA transfer flags */ 416 }; 417 uint64_t st_max_phys_addr = 0xFFFFFFFFull; 418 int st_sgl_size = 0xF; 419 420 #endif 421 422 /* 423 * Configuration Data: 424 * 425 * Device driver ops vector 426 */ 427 static int st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p); 428 static int st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p); 429 static int st_read(dev_t dev, struct uio *uio_p, cred_t *cred_p); 430 static int st_write(dev_t dev, struct uio *uio_p, cred_t *cred_p); 431 static int st_open(dev_t *devp, int flag, int otyp, cred_t *cred_p); 432 static int st_close(dev_t dev, int flag, int otyp, cred_t *cred_p); 433 static int st_strategy(struct buf *bp); 434 static int st_queued_strategy(buf_t *bp); 435 static int st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, 436 cred_t *cred_p, int *rval_p); 437 extern int nulldev(), nodev(); 438 439 static struct cb_ops st_cb_ops = { 440 st_open, /* open */ 441 st_close, /* close */ 442 st_queued_strategy, /* strategy Not Block device but async checks */ 443 nodev, /* print */ 444 nodev, /* dump */ 445 st_read, /* read */ 446 st_write, /* write */ 447 st_ioctl, /* ioctl */ 448 nodev, /* devmap */ 449 nodev, /* mmap */ 450 nodev, /* segmap */ 451 nochpoll, /* poll */ 452 ddi_prop_op, /* cb_prop_op */ 453 0, /* streamtab */ 454 D_64BIT | D_MP | D_NEW | D_HOTPLUG | 455 D_OPEN_RETURNS_EINTR, /* cb_flag */ 456 CB_REV, /* cb_rev */ 457 st_aread, /* async I/O read entry point */ 458 st_awrite /* async I/O write entry point */ 459 460 }; 461 462 static int st_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 463 void **result); 464 static int st_probe(dev_info_t *dev); 465 static int st_attach(dev_info_t *dev, ddi_attach_cmd_t cmd); 466 static int st_detach(dev_info_t *dev, ddi_detach_cmd_t cmd); 467 468 static struct dev_ops st_ops = { 469 DEVO_REV, /* devo_rev, */ 470 0, /* refcnt */ 471 st_info, /* info */ 472 nulldev, /* identify */ 473 st_probe, /* probe */ 474 st_attach, /* attach */ 475 st_detach, /* detach */ 476 nodev, /* reset */ 477 &st_cb_ops, /* driver operations */ 478 (struct bus_ops *)0, /* bus operations */ 479 nulldev, /* power */ 480 ddi_quiesce_not_needed, /* devo_quiesce */ 481 }; 482 483 /* 484 * Local Function Declarations 485 */ 486 static char *st_print_scsi_cmd(char cmd); 487 static void st_print_cdb(dev_info_t *dip, char *label, uint_t level, 488 char *title, char *cdb); 489 static void st_clean_print(dev_info_t *dev, char *label, uint_t level, 490 char *title, char *data, int len); 491 static int st_doattach(struct scsi_device *devp, int (*canwait)()); 492 static void st_known_tape_type(struct scsi_tape *un); 493 static int st_get_conf_from_st_dot_conf(struct scsi_tape *, char *, 494 struct st_drivetype *); 495 static int st_get_conf_from_st_conf_dot_c(struct scsi_tape *, char *, 496 struct st_drivetype *); 497 static int st_get_conf_from_tape_drive(struct scsi_tape *, char *, 498 struct st_drivetype *); 499 static int st_get_densities_from_tape_drive(struct scsi_tape *, 500 struct st_drivetype *); 501 static int st_get_timeout_values_from_tape_drive(struct scsi_tape *, 502 struct st_drivetype *); 503 static int st_get_timeouts_value(struct scsi_tape *, uchar_t, ushort_t *, 504 ushort_t); 505 static int st_get_default_conf(struct scsi_tape *, char *, 506 struct st_drivetype *); 507 static int st_rw(dev_t dev, struct uio *uio, int flag); 508 static int st_arw(dev_t dev, struct aio_req *aio, int flag); 509 static int st_find_eod(struct scsi_tape *un); 510 static int st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag); 511 static int st_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *, int flag); 512 static int st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag); 513 static int st_mtiocltop(struct scsi_tape *un, intptr_t arg, int flag); 514 static int st_do_mtioctop(struct scsi_tape *un, struct mtlop *mtop); 515 static void st_start(struct scsi_tape *un); 516 static int st_handle_start_busy(struct scsi_tape *un, struct buf *bp, 517 clock_t timeout_interval, int queued); 518 static int st_handle_intr_busy(struct scsi_tape *un, struct buf *bp, 519 clock_t timeout_interval); 520 static int st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp); 521 static void st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp); 522 static void st_init(struct scsi_tape *un); 523 static void st_make_cmd(struct scsi_tape *un, struct buf *bp, 524 int (*func)(caddr_t)); 525 static void st_make_uscsi_cmd(struct scsi_tape *, struct uscsi_cmd *, 526 struct buf *bp, int (*func)(caddr_t)); 527 static void st_intr(struct scsi_pkt *pkt); 528 static void st_set_state(struct scsi_tape *un, buf_t *bp); 529 static void st_test_append(struct buf *bp); 530 static int st_runout(caddr_t); 531 static int st_cmd(struct scsi_tape *un, int com, int64_t count, int wait); 532 static int st_setup_cmd(struct scsi_tape *un, buf_t *bp, int com, 533 int64_t count); 534 static int st_set_compression(struct scsi_tape *un); 535 static int st_write_fm(dev_t dev, int wfm); 536 static int st_determine_generic(struct scsi_tape *un); 537 static int st_determine_density(struct scsi_tape *un, int rw); 538 static int st_get_density(struct scsi_tape *un); 539 static int st_set_density(struct scsi_tape *un); 540 static int st_loadtape(struct scsi_tape *un); 541 static int st_modesense(struct scsi_tape *un); 542 static int st_modeselect(struct scsi_tape *un); 543 static errstate st_handle_incomplete(struct scsi_tape *un, struct buf *bp); 544 static int st_wrongtapetype(struct scsi_tape *un); 545 static errstate st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt); 546 static errstate st_handle_sense(struct scsi_tape *un, struct buf *bp, 547 tapepos_t *); 548 static errstate st_handle_autosense(struct scsi_tape *un, struct buf *bp, 549 tapepos_t *); 550 static int st_get_error_entry(struct scsi_tape *un, intptr_t arg, int flag); 551 static void st_update_error_stack(struct scsi_tape *un, struct scsi_pkt *pkt, 552 struct scsi_arq_status *cmd); 553 static void st_empty_error_stack(struct scsi_tape *un); 554 static errstate st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt, 555 struct scsi_arq_status *, tapepos_t *); 556 static int st_report_soft_errors(dev_t dev, int flag); 557 static void st_delayed_cv_broadcast(void *arg); 558 static int st_check_media(dev_t dev, enum mtio_state state); 559 static int st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp); 560 static void st_intr_restart(void *arg); 561 static void st_start_restart(void *arg); 562 static int st_gen_mode_sense(struct scsi_tape *un, ubufunc_t ubf, int page, 563 struct seq_mode *page_data, int page_size); 564 static int st_change_block_size(struct scsi_tape *un, uint32_t nblksz); 565 static int st_gen_mode_select(struct scsi_tape *un, ubufunc_t ubf, 566 struct seq_mode *page_data, int page_size); 567 static int st_read_block_limits(struct scsi_tape *un, 568 struct read_blklim *read_blk); 569 static int st_report_density_support(struct scsi_tape *un, 570 uchar_t *density_data, size_t buflen); 571 static int st_report_supported_operation(struct scsi_tape *un, 572 uchar_t *oper_data, uchar_t option_code, ushort_t service_action); 573 static int st_tape_init(struct scsi_tape *un); 574 static void st_flush(struct scsi_tape *un); 575 static void st_set_pe_errno(struct scsi_tape *un); 576 static void st_hba_unflush(struct scsi_tape *un); 577 static void st_turn_pe_on(struct scsi_tape *un); 578 static void st_turn_pe_off(struct scsi_tape *un); 579 static void st_set_pe_flag(struct scsi_tape *un); 580 static void st_clear_pe(struct scsi_tape *un); 581 static void st_wait_for_io(struct scsi_tape *un); 582 static int st_set_devconfig_page(struct scsi_tape *un, int compression_on); 583 static int st_set_datacomp_page(struct scsi_tape *un, int compression_on); 584 static int st_reserve_release(struct scsi_tape *un, int command, ubufunc_t ubf); 585 static int st_check_cdb_for_need_to_reserve(struct scsi_tape *un, uchar_t *cdb); 586 static int st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd, 587 int count); 588 static int st_take_ownership(struct scsi_tape *un, ubufunc_t ubf); 589 static int st_check_asc_ascq(struct scsi_tape *un); 590 static int st_check_clean_bit(struct scsi_tape *un); 591 static int st_check_alert_flags(struct scsi_tape *un); 592 static int st_check_sequential_clean_bit(struct scsi_tape *un); 593 static int st_check_sense_clean_bit(struct scsi_tape *un); 594 static int st_clear_unit_attentions(dev_t dev_instance, int max_trys); 595 static void st_calculate_timeouts(struct scsi_tape *un); 596 static writablity st_is_drive_worm(struct scsi_tape *un); 597 static int st_read_attributes(struct scsi_tape *un, uint16_t attribute, 598 void *buf, size_t size, ubufunc_t bufunc); 599 static int st_get_special_inquiry(struct scsi_tape *un, uchar_t size, 600 caddr_t dest, uchar_t page); 601 static int st_update_block_pos(struct scsi_tape *un, bufunc_t bf, 602 int post_space); 603 static int st_interpret_read_pos(struct scsi_tape const *un, tapepos_t *dest, 604 read_p_types type, size_t data_sz, const caddr_t responce, int post_space); 605 static int st_get_read_pos(struct scsi_tape *un, buf_t *bp); 606 static int st_logical_block_locate(struct scsi_tape *un, ubufunc_t ubf, 607 tapepos_t *pos, uint64_t lblk, uchar_t partition); 608 static int st_mtfsf_ioctl(struct scsi_tape *un, int64_t files); 609 static int st_mtfsr_ioctl(struct scsi_tape *un, int64_t count); 610 static int st_mtbsf_ioctl(struct scsi_tape *un, int64_t files); 611 static int st_mtnbsf_ioctl(struct scsi_tape *un, int64_t count); 612 static int st_mtbsr_ioctl(struct scsi_tape *un, int64_t num); 613 static int st_mtfsfm_ioctl(struct scsi_tape *un, int64_t cnt); 614 static int st_mtbsfm_ioctl(struct scsi_tape *un, int64_t cnt); 615 static int st_backward_space_files(struct scsi_tape *un, int64_t count, 616 int infront); 617 static int st_forward_space_files(struct scsi_tape *un, int64_t files); 618 static int st_scenic_route_to_begining_of_file(struct scsi_tape *un, 619 int32_t fileno); 620 static int st_space_to_begining_of_file(struct scsi_tape *un); 621 static int st_space_records(struct scsi_tape *un, int64_t records); 622 static int st_get_media_identification(struct scsi_tape *un, ubufunc_t bufunc); 623 static errstate st_command_recovery(struct scsi_tape *un, struct scsi_pkt *pkt, 624 errstate onentry); 625 static void st_recover(void *arg); 626 static void st_recov_cb(struct scsi_pkt *pkt); 627 static int st_rcmd(struct scsi_tape *un, int com, int64_t count, int wait); 628 static int st_uscsi_rcmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, 629 int flag); 630 static void st_add_recovery_info_to_pkt(struct scsi_tape *un, buf_t *bp, 631 struct scsi_pkt *cmd); 632 static int st_check_mode_for_change(struct scsi_tape *un, ubufunc_t ubf); 633 static int st_test_path_to_device(struct scsi_tape *un); 634 static int st_recovery_read_pos(struct scsi_tape *un, read_p_types type, 635 read_pos_data_t *raw); 636 static int st_recovery_get_position(struct scsi_tape *un, tapepos_t *read, 637 read_pos_data_t *raw); 638 static int st_compare_expected_position(struct scsi_tape *un, st_err_info *ei, 639 cmd_attribute const * cmd_att, tapepos_t *read); 640 static errstate st_recover_reissue_pkt(struct scsi_tape *us, 641 struct scsi_pkt *pkt); 642 static int st_transport(struct scsi_tape *un, struct scsi_pkt *pkt); 643 static buf_t *st_remove_from_queue(buf_t **head, buf_t **tail, buf_t *bp); 644 static void st_add_to_queue(buf_t **head, buf_t **tail, buf_t *end, buf_t *bp); 645 static int st_reset(struct scsi_tape *un, int reset_type); 646 static void st_reset_notification(caddr_t arg); 647 static const cmd_attribute *st_lookup_cmd_attribute(unsigned char cmd); 648 649 static int st_set_target_TLR_mode(struct scsi_tape *un, ubufunc_t ubf); 650 static int st_make_sure_mode_data_is_correct(struct scsi_tape *un, 651 ubufunc_t ubf); 652 653 #ifdef __x86 654 /* 655 * routines for I/O in big block size 656 */ 657 static void st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp); 658 static struct contig_mem *st_get_contig_mem(struct scsi_tape *un, size_t len, 659 int alloc_flags); 660 static int st_bigblk_xfer_done(struct buf *bp); 661 static struct buf *st_get_bigblk_bp(struct buf *bp); 662 #endif 663 static void st_print_position(dev_info_t *dev, char *label, uint_t level, 664 const char *comment, tapepos_t *pos); 665 666 /* 667 * error statistics create/update functions 668 */ 669 static int st_create_errstats(struct scsi_tape *, int); 670 static int st_validate_tapemarks(struct scsi_tape *un, ubufunc_t ubf, 671 tapepos_t *pos); 672 673 #ifdef STDEBUG 674 static void st_debug_cmds(struct scsi_tape *un, int com, int count, int wait); 675 #endif /* STDEBUG */ 676 static char *st_dev_name(dev_t dev); 677 678 #if !defined(lint) 679 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", 680 scsi_pkt buf uio scsi_cdb uscsi_cmd)) 681 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_extended_sense scsi_status)) 682 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", recov_info)) 683 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device)) 684 _NOTE(DATA_READABLE_WITHOUT_LOCK(st_drivetype scsi_address)) 685 #endif 686 687 /* 688 * autoconfiguration routines. 689 */ 690 691 static struct modldrv modldrv = { 692 &mod_driverops, /* Type of module. This one is a driver */ 693 "SCSI tape Driver", /* Name of the module. */ 694 &st_ops /* driver ops */ 695 }; 696 697 static struct modlinkage modlinkage = { 698 MODREV_1, &modldrv, NULL 699 }; 700 701 /* 702 * Notes on Post Reset Behavior in the tape driver: 703 * 704 * When the tape drive is opened, the driver attempts to make sure that 705 * the tape head is positioned exactly where it was left when it was last 706 * closed provided the medium is not changed. If the tape drive is 707 * opened in O_NDELAY mode, the repositioning (if necessary for any loss 708 * of position due to reset) will happen when the first tape operation or 709 * I/O occurs. The repositioning (if required) may not be possible under 710 * certain situations such as when the device firmware not able to report 711 * the medium change in the REQUEST SENSE data because of a reset or a 712 * misbehaving bus not allowing the reposition to happen. In such 713 * extraordinary situations, where the driver fails to position the head 714 * at its original position, it will fail the open the first time, to 715 * save the applications from overwriting the data. All further attempts 716 * to open the tape device will result in the driver attempting to load 717 * the tape at BOT (beginning of tape). Also a warning message to 718 * indicate that further attempts to open the tape device may result in 719 * the tape being loaded at BOT will be printed on the console. If the 720 * tape device is opened in O_NDELAY mode, failure to restore the 721 * original tape head position, will result in the failure of the first 722 * tape operation or I/O, Further, the driver will invalidate its 723 * internal tape position which will necessitate the applications to 724 * validate the position by using either a tape positioning ioctl (such 725 * as MTREW) or closing and reopening the tape device. 726 * 727 */ 728 729 int 730 _init(void) 731 { 732 int e; 733 734 if (((e = ddi_soft_state_init(&st_state, 735 sizeof (struct scsi_tape), ST_MAXUNIT)) != 0)) { 736 return (e); 737 } 738 739 if ((e = mod_install(&modlinkage)) != 0) { 740 ddi_soft_state_fini(&st_state); 741 } else { 742 #ifdef STDEBUG 743 mutex_init(&st_debug_mutex, NULL, MUTEX_DRIVER, NULL); 744 #endif 745 746 #if defined(__x86) 747 /* set the max physical address for iob allocs on x86 */ 748 st_alloc_attr.dma_attr_addr_hi = st_max_phys_addr; 749 750 /* 751 * set the sgllen for iob allocs on x86. If this is set less 752 * than the number of pages the buffer will take 753 * (taking into account alignment), it would force the 754 * allocator to try and allocate contiguous pages. 755 */ 756 st_alloc_attr.dma_attr_sgllen = st_sgl_size; 757 #endif 758 } 759 760 return (e); 761 } 762 763 int 764 _fini(void) 765 { 766 int e; 767 768 if ((e = mod_remove(&modlinkage)) != 0) { 769 return (e); 770 } 771 772 #ifdef STDEBUG 773 mutex_destroy(&st_debug_mutex); 774 #endif 775 776 ddi_soft_state_fini(&st_state); 777 778 return (e); 779 } 780 781 int 782 _info(struct modinfo *modinfop) 783 { 784 return (mod_info(&modlinkage, modinfop)); 785 } 786 787 788 static int 789 st_probe(dev_info_t *devi) 790 { 791 int instance; 792 struct scsi_device *devp; 793 int rval; 794 795 #if !defined(__sparc) 796 char *tape_prop; 797 int tape_prop_len; 798 #endif 799 800 ST_ENTR(devi, st_probe); 801 802 /* If self identifying device */ 803 if (ddi_dev_is_sid(devi) == DDI_SUCCESS) { 804 return (DDI_PROBE_DONTCARE); 805 } 806 807 #if !defined(__sparc) 808 /* 809 * Since some x86 HBAs have devnodes that look like SCSI as 810 * far as we can tell but aren't really SCSI (DADK, like mlx) 811 * we check for the presence of the "tape" property. 812 */ 813 if (ddi_prop_op(DDI_DEV_T_NONE, devi, PROP_LEN_AND_VAL_ALLOC, 814 DDI_PROP_CANSLEEP, "tape", 815 (caddr_t)&tape_prop, &tape_prop_len) != DDI_PROP_SUCCESS) { 816 return (DDI_PROBE_FAILURE); 817 } 818 if (strncmp(tape_prop, "sctp", tape_prop_len) != 0) { 819 kmem_free(tape_prop, tape_prop_len); 820 return (DDI_PROBE_FAILURE); 821 } 822 kmem_free(tape_prop, tape_prop_len); 823 #endif 824 825 devp = ddi_get_driver_private(devi); 826 instance = ddi_get_instance(devi); 827 828 if (ddi_get_soft_state(st_state, instance) != NULL) { 829 return (DDI_PROBE_PARTIAL); 830 } 831 832 833 /* 834 * Turn around and call probe routine to see whether 835 * we actually have a tape at this SCSI nexus. 836 */ 837 if (scsi_probe(devp, NULL_FUNC) == SCSIPROBE_EXISTS) { 838 839 /* 840 * In checking the whole inq_dtype byte we are looking at both 841 * the Peripheral Qualifier and the Peripheral Device Type. 842 * For this driver we are only interested in sequential devices 843 * that are connected or capable if connecting to this logical 844 * unit. 845 */ 846 if (devp->sd_inq->inq_dtype == 847 (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) { 848 ST_DEBUG6(devi, st_label, SCSI_DEBUG, 849 "probe exists\n"); 850 rval = DDI_PROBE_SUCCESS; 851 } else { 852 rval = DDI_PROBE_FAILURE; 853 } 854 } else { 855 ST_DEBUG6(devi, st_label, SCSI_DEBUG, 856 "probe failure: nothing there\n"); 857 rval = DDI_PROBE_FAILURE; 858 } 859 scsi_unprobe(devp); 860 return (rval); 861 } 862 863 static int 864 st_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 865 { 866 int instance; 867 int wide; 868 int dev_instance; 869 int ret_status; 870 struct scsi_device *devp; 871 int node_ix; 872 struct scsi_tape *un; 873 874 ST_ENTR(devi, st_attach); 875 876 devp = ddi_get_driver_private(devi); 877 instance = ddi_get_instance(devi); 878 879 switch (cmd) { 880 case DDI_ATTACH: 881 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 882 "tape-command-recovery-disable", 0) != 0) { 883 st_recov_sz = sizeof (pkt_info); 884 } 885 if (st_doattach(devp, SLEEP_FUNC) == DDI_FAILURE) { 886 return (DDI_FAILURE); 887 } 888 break; 889 case DDI_RESUME: 890 /* 891 * Suspend/Resume 892 * 893 * When the driver suspended, there might be 894 * outstanding cmds and therefore we need to 895 * reset the suspended flag and resume the scsi 896 * watch thread and restart commands and timeouts 897 */ 898 899 if (!(un = ddi_get_soft_state(st_state, instance))) { 900 return (DDI_FAILURE); 901 } 902 dev_instance = ((un->un_dev == 0) ? MTMINOR(instance) : 903 un->un_dev); 904 905 mutex_enter(ST_MUTEX); 906 907 un->un_throttle = un->un_max_throttle; 908 un->un_tids_at_suspend = 0; 909 un->un_pwr_mgmt = ST_PWR_NORMAL; 910 911 if (un->un_swr_token) { 912 scsi_watch_resume(un->un_swr_token); 913 } 914 915 /* 916 * Restart timeouts 917 */ 918 if ((un->un_tids_at_suspend & ST_DELAY_TID) != 0) { 919 mutex_exit(ST_MUTEX); 920 un->un_delay_tid = timeout( 921 st_delayed_cv_broadcast, un, 922 drv_usectohz((clock_t) 923 MEDIA_ACCESS_DELAY)); 924 mutex_enter(ST_MUTEX); 925 } 926 927 if (un->un_tids_at_suspend & ST_HIB_TID) { 928 mutex_exit(ST_MUTEX); 929 un->un_hib_tid = timeout(st_intr_restart, un, 930 ST_STATUS_BUSY_TIMEOUT); 931 mutex_enter(ST_MUTEX); 932 } 933 934 ret_status = st_clear_unit_attentions(dev_instance, 5); 935 936 /* 937 * now check if we need to restore the tape position 938 */ 939 if ((un->un_suspend_pos.pmode != invalid) && 940 ((un->un_suspend_pos.fileno > 0) || 941 (un->un_suspend_pos.blkno > 0)) || 942 (un->un_suspend_pos.lgclblkno > 0)) { 943 if (ret_status != 0) { 944 /* 945 * tape didn't get good TUR 946 * just print out error messages 947 */ 948 scsi_log(ST_DEVINFO, st_label, CE_WARN, 949 "st_attach-RESUME: tape failure " 950 " tape position will be lost"); 951 } else { 952 /* this prints errors */ 953 (void) st_validate_tapemarks(un, 954 st_uscsi_cmd, &un->un_suspend_pos); 955 } 956 /* 957 * there are no retries, if there is an error 958 * we don't know if the tape has changed 959 */ 960 un->un_suspend_pos.pmode = invalid; 961 } 962 963 /* now we are ready to start up any queued I/Os */ 964 if (un->un_ncmds || un->un_quef) { 965 st_start(un); 966 } 967 968 cv_broadcast(&un->un_suspend_cv); 969 mutex_exit(ST_MUTEX); 970 return (DDI_SUCCESS); 971 972 default: 973 return (DDI_FAILURE); 974 } 975 976 un = ddi_get_soft_state(st_state, instance); 977 978 ST_DEBUG(devi, st_label, SCSI_DEBUG, 979 "st_attach: instance=%x\n", instance); 980 981 /* 982 * Add a zero-length attribute to tell the world we support 983 * kernel ioctls (for layered drivers) 984 */ 985 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, 986 DDI_KERNEL_IOCTL, NULL, 0); 987 988 ddi_report_dev((dev_info_t *)devi); 989 990 /* 991 * If it's a SCSI-2 tape drive which supports wide, 992 * tell the host adapter to use wide. 993 */ 994 wide = ((devp->sd_inq->inq_rdf == RDF_SCSI2) && 995 (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) ? 1 : 0; 996 997 if (scsi_ifsetcap(ROUTE, "wide-xfer", wide, 1) == 1) { 998 ST_DEBUG(devi, st_label, SCSI_DEBUG, 999 "Wide Transfer %s\n", wide ? "enabled" : "disabled"); 1000 } 1001 1002 /* 1003 * enable autorequest sense; keep the rq packet around in case 1004 * the autorequest sense fails because of a busy condition 1005 * do a getcap first in case the capability is not variable 1006 */ 1007 if (scsi_ifgetcap(ROUTE, "auto-rqsense", 1) == 1) { 1008 un->un_arq_enabled = 1; 1009 } else { 1010 un->un_arq_enabled = 1011 ((scsi_ifsetcap(ROUTE, "auto-rqsense", 1, 1) == 1) ? 1 : 0); 1012 } 1013 1014 ST_DEBUG(devi, st_label, SCSI_DEBUG, "auto request sense %s\n", 1015 (un->un_arq_enabled ? "enabled" : "disabled")); 1016 1017 un->un_untagged_qing = 1018 (scsi_ifgetcap(ROUTE, "untagged-qing", 0) == 1); 1019 1020 /* 1021 * XXX - This is just for 2.6. to tell users that write buffering 1022 * has gone away. 1023 */ 1024 if (un->un_arq_enabled && un->un_untagged_qing) { 1025 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 1026 "tape-driver-buffering", 0) != 0) { 1027 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1028 "Write Data Buffering has been depricated. Your " 1029 "applications should continue to work normally.\n" 1030 " But, they should ported to use Asynchronous " 1031 " I/O\n" 1032 " For more information, read about " 1033 " tape-driver-buffering " 1034 "property in the st(7d) man page\n"); 1035 } 1036 } 1037 1038 un->un_max_throttle = un->un_throttle = un->un_last_throttle = 1; 1039 un->un_flush_on_errors = 0; 1040 un->un_mkr_pkt = (struct scsi_pkt *)NULL; 1041 1042 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1043 "throttle=%x, max_throttle = %x\n", 1044 un->un_throttle, un->un_max_throttle); 1045 1046 /* initialize persistent errors to nil */ 1047 un->un_persistence = 0; 1048 un->un_persist_errors = 0; 1049 1050 /* 1051 * Get dma-max from HBA driver. If it is not defined, use 64k 1052 */ 1053 un->un_maxdma = scsi_ifgetcap(&devp->sd_address, "dma-max", 1); 1054 if (un->un_maxdma == -1) { 1055 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1056 "Received a value that looked like -1. Using 64k maxdma"); 1057 un->un_maxdma = (64 * ONE_K); 1058 } 1059 1060 #ifdef __x86 1061 /* 1062 * for x86, the device may be able to DMA more than the system will 1063 * allow under some circumstances. We need account for both the HBA's 1064 * and system's contraints. 1065 * 1066 * Get the maximum DMA under worse case conditions. e.g. looking at the 1067 * device constraints, the max copy buffer size, and the worse case 1068 * fragmentation. NOTE: this may differ from dma-max since dma-max 1069 * doesn't take the worse case framentation into account. 1070 * 1071 * e.g. a device may be able to DMA 16MBytes, but can only DMA 1MByte 1072 * if none of the pages are contiguous. Keeping track of both of these 1073 * values allows us to support larger tape block sizes on some devices. 1074 */ 1075 un->un_maxdma_arch = scsi_ifgetcap(&devp->sd_address, "dma-max-arch", 1076 1); 1077 1078 /* 1079 * If the dma-max-arch capability is not implemented, or the value 1080 * comes back higher than what was reported in dma-max, use dma-max. 1081 */ 1082 if ((un->un_maxdma_arch == -1) || 1083 ((uint_t)un->un_maxdma < (uint_t)un->un_maxdma_arch)) { 1084 un->un_maxdma_arch = un->un_maxdma; 1085 } 1086 #endif 1087 1088 /* 1089 * Get the max allowable cdb size 1090 */ 1091 un->un_max_cdb_sz = 1092 scsi_ifgetcap(&devp->sd_address, "max-cdb-length", 1); 1093 if (un->un_max_cdb_sz < CDB_GROUP0) { 1094 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1095 "HBA reported max-cdb-length as %d\n", un->un_max_cdb_sz); 1096 un->un_max_cdb_sz = CDB_GROUP4; /* optimistic default */ 1097 } 1098 1099 if (strcmp(ddi_driver_name(ddi_get_parent(ST_DEVINFO)), "scsi_vhci")) { 1100 un->un_multipath = 0; 1101 } else { 1102 un->un_multipath = 1; 1103 } 1104 1105 un->un_maxbsize = MAXBSIZE_UNKNOWN; 1106 1107 un->un_mediastate = MTIO_NONE; 1108 un->un_HeadClean = TAPE_ALERT_SUPPORT_UNKNOWN; 1109 1110 /* 1111 * initialize kstats 1112 */ 1113 un->un_stats = kstat_create("st", instance, NULL, "tape", 1114 KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT); 1115 if (un->un_stats) { 1116 un->un_stats->ks_lock = ST_MUTEX; 1117 kstat_install(un->un_stats); 1118 } 1119 (void) st_create_errstats(un, instance); 1120 1121 /* 1122 * find the drive type for this target 1123 */ 1124 mutex_enter(ST_MUTEX); 1125 un->un_dev = MTMINOR(instance); 1126 st_known_tape_type(un); 1127 un->un_dev = 0; 1128 mutex_exit(ST_MUTEX); 1129 1130 for (node_ix = 0; node_ix < ST_NUM_MEMBERS(st_minor_data); node_ix++) { 1131 int minor; 1132 char *name; 1133 1134 name = st_minor_data[node_ix].name; 1135 minor = st_minor_data[node_ix].minor; 1136 1137 /* 1138 * For default devices set the density to the 1139 * preferred default density for this device. 1140 */ 1141 if (node_ix <= DEF_BSD_NR) { 1142 minor |= un->un_dp->default_density; 1143 } 1144 minor |= MTMINOR(instance); 1145 1146 if (ddi_create_minor_node(devi, name, S_IFCHR, minor, 1147 DDI_NT_TAPE, NULL) == DDI_SUCCESS) { 1148 continue; 1149 } 1150 1151 ddi_remove_minor_node(devi, NULL); 1152 1153 (void) scsi_reset_notify(ROUTE, SCSI_RESET_CANCEL, 1154 st_reset_notification, (caddr_t)un); 1155 cv_destroy(&un->un_clscv); 1156 cv_destroy(&un->un_sbuf_cv); 1157 cv_destroy(&un->un_queue_cv); 1158 cv_destroy(&un->un_state_cv); 1159 #ifdef __x86 1160 cv_destroy(&un->un_contig_mem_cv); 1161 #endif 1162 cv_destroy(&un->un_suspend_cv); 1163 cv_destroy(&un->un_tape_busy_cv); 1164 cv_destroy(&un->un_recov_buf_cv); 1165 if (un->un_recov_taskq) { 1166 ddi_taskq_destroy(un->un_recov_taskq); 1167 } 1168 if (un->un_sbufp) { 1169 freerbuf(un->un_sbufp); 1170 } 1171 if (un->un_recov_buf) { 1172 freerbuf(un->un_recov_buf); 1173 } 1174 if (un->un_uscsi_rqs_buf) { 1175 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1176 } 1177 if (un->un_mspl) { 1178 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1179 } 1180 if (un->un_dp_size) { 1181 kmem_free(un->un_dp, un->un_dp_size); 1182 } 1183 if (un->un_state) { 1184 kstat_delete(un->un_stats); 1185 } 1186 if (un->un_errstats) { 1187 kstat_delete(un->un_errstats); 1188 } 1189 1190 scsi_destroy_pkt(un->un_rqs); 1191 scsi_free_consistent_buf(un->un_rqs_bp); 1192 ddi_soft_state_free(st_state, instance); 1193 devp->sd_private = NULL; 1194 devp->sd_sense = NULL; 1195 1196 ddi_prop_remove_all(devi); 1197 return (DDI_FAILURE); 1198 } 1199 1200 return (DDI_SUCCESS); 1201 } 1202 1203 /* 1204 * st_detach: 1205 * 1206 * we allow a detach if and only if: 1207 * - no tape is currently inserted 1208 * - tape position is at BOT or unknown 1209 * (if it is not at BOT then a no rewind 1210 * device was opened and we have to preserve state) 1211 * - it must be in a closed state : no timeouts or scsi_watch requests 1212 * will exist if it is closed, so we don't need to check for 1213 * them here. 1214 */ 1215 /*ARGSUSED*/ 1216 static int 1217 st_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) 1218 { 1219 int instance; 1220 int result; 1221 struct scsi_device *devp; 1222 struct scsi_tape *un; 1223 clock_t wait_cmds_complete; 1224 1225 ST_ENTR(devi, st_detach); 1226 1227 instance = ddi_get_instance(devi); 1228 1229 if (!(un = ddi_get_soft_state(st_state, instance))) { 1230 return (DDI_FAILURE); 1231 } 1232 1233 mutex_enter(ST_MUTEX); 1234 1235 /* 1236 * Clear error entry stack 1237 */ 1238 st_empty_error_stack(un); 1239 1240 mutex_exit(ST_MUTEX); 1241 1242 switch (cmd) { 1243 1244 case DDI_DETACH: 1245 /* 1246 * Undo what we did in st_attach & st_doattach, 1247 * freeing resources and removing things we installed. 1248 * The system framework guarantees we are not active 1249 * with this devinfo node in any other entry points at 1250 * this time. 1251 */ 1252 1253 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1254 "st_detach: instance=%x, un=%p\n", instance, 1255 (void *)un); 1256 1257 if (((un->un_dp->options & ST_UNLOADABLE) == 0) || 1258 ((un->un_rsvd_status & ST_APPLICATION_RESERVATIONS) != 0) || 1259 (un->un_ncmds != 0) || (un->un_quef != NULL) || 1260 (un->un_state != ST_STATE_CLOSED)) { 1261 /* 1262 * we cannot unload some targets because the 1263 * inquiry returns junk unless immediately 1264 * after a reset 1265 */ 1266 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 1267 "cannot unload instance %x\n", instance); 1268 un->un_unit_attention_flags |= 4; 1269 return (DDI_FAILURE); 1270 } 1271 1272 /* 1273 * if the tape has been removed then we may unload; 1274 * do a test unit ready and if it returns NOT READY 1275 * then we assume that it is safe to unload. 1276 * as a side effect, pmode may be set to invalid if the 1277 * the test unit ready fails; 1278 * also un_state may be set to non-closed, so reset it 1279 */ 1280 if ((un->un_dev) && /* Been opened since attach */ 1281 ((un->un_pos.pmode == legacy) && 1282 (un->un_pos.fileno > 0) || /* Known position not rewound */ 1283 (un->un_pos.blkno != 0)) || /* Or within first file */ 1284 ((un->un_pos.pmode == logical) && 1285 (un->un_pos.lgclblkno > 0))) { 1286 mutex_enter(ST_MUTEX); 1287 /* 1288 * Send Test Unit Ready in the hopes that if 1289 * the drive is not in the state we think it is. 1290 * And the state will be changed so it can be detached. 1291 * If the command fails to reach the device and 1292 * the drive was not rewound or unloaded we want 1293 * to fail the detach till a user command fails 1294 * where after the detach will succead. 1295 */ 1296 result = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 1297 /* 1298 * After TUR un_state may be set to non-closed, 1299 * so reset it back. 1300 */ 1301 un->un_state = ST_STATE_CLOSED; 1302 mutex_exit(ST_MUTEX); 1303 } 1304 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1305 "un_status=%x, fileno=%x, blkno=%x\n", 1306 un->un_status, un->un_pos.fileno, un->un_pos.blkno); 1307 1308 /* 1309 * check again: 1310 * if we are not at BOT then it is not safe to unload 1311 */ 1312 if ((un->un_dev) && /* Been opened since attach */ 1313 (result != EACCES) && /* drive is use by somebody */ 1314 ((((un->un_pos.pmode == legacy) && 1315 (un->un_pos.fileno > 0) || /* Known position not rewound */ 1316 (un->un_pos.blkno != 0)) || /* Or within first file */ 1317 ((un->un_pos.pmode == logical) && 1318 (un->un_pos.lgclblkno > 0))) && 1319 ((un->un_state == ST_STATE_CLOSED) && 1320 (un->un_laststate == ST_STATE_CLOSING)))) { 1321 1322 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1323 "cannot detach: pmode=%d fileno=0x%x, blkno=0x%x" 1324 " lgclblkno=0x%"PRIx64"\n", un->un_pos.pmode, 1325 un->un_pos.fileno, un->un_pos.blkno, 1326 un->un_pos.lgclblkno); 1327 un->un_unit_attention_flags |= 4; 1328 return (DDI_FAILURE); 1329 } 1330 1331 /* 1332 * Just To make sure that we have released the 1333 * tape unit . 1334 */ 1335 if (un->un_dev && (un->un_rsvd_status & ST_RESERVE) && 1336 !DEVI_IS_DEVICE_REMOVED(devi)) { 1337 mutex_enter(ST_MUTEX); 1338 (void) st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 1339 mutex_exit(ST_MUTEX); 1340 } 1341 1342 /* 1343 * now remove other data structures allocated in st_doattach() 1344 */ 1345 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1346 "destroying/freeing\n"); 1347 1348 (void) scsi_reset_notify(ROUTE, SCSI_RESET_CANCEL, 1349 st_reset_notification, (caddr_t)un); 1350 cv_destroy(&un->un_clscv); 1351 cv_destroy(&un->un_sbuf_cv); 1352 cv_destroy(&un->un_queue_cv); 1353 cv_destroy(&un->un_suspend_cv); 1354 cv_destroy(&un->un_tape_busy_cv); 1355 cv_destroy(&un->un_recov_buf_cv); 1356 1357 if (un->un_recov_taskq) { 1358 ddi_taskq_destroy(un->un_recov_taskq); 1359 } 1360 1361 if (un->un_hib_tid) { 1362 (void) untimeout(un->un_hib_tid); 1363 un->un_hib_tid = 0; 1364 } 1365 1366 if (un->un_delay_tid) { 1367 (void) untimeout(un->un_delay_tid); 1368 un->un_delay_tid = 0; 1369 } 1370 cv_destroy(&un->un_state_cv); 1371 1372 #ifdef __x86 1373 cv_destroy(&un->un_contig_mem_cv); 1374 1375 if (un->un_contig_mem_hdl != NULL) { 1376 ddi_dma_free_handle(&un->un_contig_mem_hdl); 1377 } 1378 #endif 1379 if (un->un_sbufp) { 1380 freerbuf(un->un_sbufp); 1381 } 1382 if (un->un_recov_buf) { 1383 freerbuf(un->un_recov_buf); 1384 } 1385 if (un->un_uscsi_rqs_buf) { 1386 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1387 } 1388 if (un->un_mspl) { 1389 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1390 } 1391 if (un->un_rqs) { 1392 scsi_destroy_pkt(un->un_rqs); 1393 scsi_free_consistent_buf(un->un_rqs_bp); 1394 } 1395 if (un->un_mkr_pkt) { 1396 scsi_destroy_pkt(un->un_mkr_pkt); 1397 } 1398 if (un->un_arq_enabled) { 1399 (void) scsi_ifsetcap(ROUTE, "auto-rqsense", 0, 1); 1400 } 1401 if (un->un_dp_size) { 1402 kmem_free(un->un_dp, un->un_dp_size); 1403 } 1404 if (un->un_stats) { 1405 kstat_delete(un->un_stats); 1406 un->un_stats = (kstat_t *)0; 1407 } 1408 if (un->un_errstats) { 1409 kstat_delete(un->un_errstats); 1410 un->un_errstats = (kstat_t *)0; 1411 } 1412 if (un->un_media_id_len) { 1413 kmem_free(un->un_media_id, un->un_media_id_len); 1414 } 1415 devp = ST_SCSI_DEVP; 1416 ddi_soft_state_free(st_state, instance); 1417 devp->sd_private = NULL; 1418 devp->sd_sense = NULL; 1419 scsi_unprobe(devp); 1420 ddi_prop_remove_all(devi); 1421 ddi_remove_minor_node(devi, NULL); 1422 ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach done\n"); 1423 return (DDI_SUCCESS); 1424 1425 case DDI_SUSPEND: 1426 1427 /* 1428 * Suspend/Resume 1429 * 1430 * To process DDI_SUSPEND, we must do the following: 1431 * 1432 * - check ddi_removing_power to see if power will be turned 1433 * off. if so, return DDI_FAILURE 1434 * - check if we are already suspended, 1435 * if so, return DDI_FAILURE 1436 * - check if device state is CLOSED, 1437 * if not, return DDI_FAILURE. 1438 * - wait until outstanding operations complete 1439 * - save tape state 1440 * - block new operations 1441 * - cancel pending timeouts 1442 * 1443 */ 1444 1445 if (ddi_removing_power(devi)) { 1446 return (DDI_FAILURE); 1447 } 1448 1449 if (un->un_dev == 0) 1450 un->un_dev = MTMINOR(instance); 1451 1452 mutex_enter(ST_MUTEX); 1453 1454 /* 1455 * Shouldn't already be suspended, if so return failure 1456 */ 1457 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 1458 mutex_exit(ST_MUTEX); 1459 return (DDI_FAILURE); 1460 } 1461 if (un->un_state != ST_STATE_CLOSED) { 1462 mutex_exit(ST_MUTEX); 1463 return (DDI_FAILURE); 1464 } 1465 1466 /* 1467 * Wait for all outstanding I/O's to complete 1468 * 1469 * we wait on both ncmds and the wait queue for times 1470 * when we are flushing after persistent errors are 1471 * flagged, which is when ncmds can be 0, and the 1472 * queue can still have I/O's. This way we preserve 1473 * order of biodone's. 1474 */ 1475 wait_cmds_complete = ddi_get_lbolt(); 1476 wait_cmds_complete += 1477 st_wait_cmds_complete * drv_usectohz(1000000); 1478 while (un->un_ncmds || un->un_quef || 1479 (un->un_state == ST_STATE_RESOURCE_WAIT)) { 1480 1481 if (cv_timedwait(&un->un_tape_busy_cv, ST_MUTEX, 1482 wait_cmds_complete) == -1) { 1483 /* 1484 * Time expired then cancel the command 1485 */ 1486 if (st_reset(un, RESET_LUN) == 0) { 1487 if (un->un_last_throttle) { 1488 un->un_throttle = 1489 un->un_last_throttle; 1490 } 1491 mutex_exit(ST_MUTEX); 1492 return (DDI_FAILURE); 1493 } else { 1494 break; 1495 } 1496 } 1497 } 1498 1499 /* 1500 * DDI_SUSPEND says that the system "may" power down, we 1501 * remember the file and block number before rewinding. 1502 * we also need to save state before issuing 1503 * any WRITE_FILE_MARK command. 1504 */ 1505 (void) st_update_block_pos(un, st_cmd, 0); 1506 COPY_POS(&un->un_suspend_pos, &un->un_pos); 1507 1508 1509 /* 1510 * Issue a zero write file fmk command to tell the drive to 1511 * flush any buffered tape marks 1512 */ 1513 (void) st_cmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD); 1514 1515 /* 1516 * Because not all tape drives correctly implement buffer 1517 * flushing with the zero write file fmk command, issue a 1518 * synchronous rewind command to force data flushing. 1519 * st_validate_tapemarks() will do a rewind during DDI_RESUME 1520 * anyway. 1521 */ 1522 (void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 1523 1524 /* stop any new operations */ 1525 un->un_pwr_mgmt = ST_PWR_SUSPENDED; 1526 un->un_throttle = 0; 1527 1528 /* 1529 * cancel any outstanding timeouts 1530 */ 1531 if (un->un_delay_tid) { 1532 timeout_id_t temp_id = un->un_delay_tid; 1533 un->un_delay_tid = 0; 1534 un->un_tids_at_suspend |= ST_DELAY_TID; 1535 mutex_exit(ST_MUTEX); 1536 (void) untimeout(temp_id); 1537 mutex_enter(ST_MUTEX); 1538 } 1539 1540 if (un->un_hib_tid) { 1541 timeout_id_t temp_id = un->un_hib_tid; 1542 un->un_hib_tid = 0; 1543 un->un_tids_at_suspend |= ST_HIB_TID; 1544 mutex_exit(ST_MUTEX); 1545 (void) untimeout(temp_id); 1546 mutex_enter(ST_MUTEX); 1547 } 1548 1549 /* 1550 * Suspend the scsi_watch_thread 1551 */ 1552 if (un->un_swr_token) { 1553 opaque_t temp_token = un->un_swr_token; 1554 mutex_exit(ST_MUTEX); 1555 scsi_watch_suspend(temp_token); 1556 } else { 1557 mutex_exit(ST_MUTEX); 1558 } 1559 1560 return (DDI_SUCCESS); 1561 1562 default: 1563 ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach failed\n"); 1564 return (DDI_FAILURE); 1565 } 1566 } 1567 1568 1569 /* ARGSUSED */ 1570 static int 1571 st_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 1572 { 1573 dev_t dev; 1574 struct scsi_tape *un; 1575 int instance, error; 1576 1577 ST_ENTR(dip, st_info); 1578 1579 switch (infocmd) { 1580 case DDI_INFO_DEVT2DEVINFO: 1581 dev = (dev_t)arg; 1582 instance = MTUNIT(dev); 1583 if ((un = ddi_get_soft_state(st_state, instance)) == NULL) 1584 return (DDI_FAILURE); 1585 *result = (void *) ST_DEVINFO; 1586 error = DDI_SUCCESS; 1587 break; 1588 case DDI_INFO_DEVT2INSTANCE: 1589 dev = (dev_t)arg; 1590 instance = MTUNIT(dev); 1591 *result = (void *)(uintptr_t)instance; 1592 error = DDI_SUCCESS; 1593 break; 1594 default: 1595 error = DDI_FAILURE; 1596 } 1597 return (error); 1598 } 1599 1600 static int 1601 st_doattach(struct scsi_device *devp, int (*canwait)()) 1602 { 1603 struct scsi_tape *un = NULL; 1604 recov_info *ri; 1605 int km_flags = (canwait != NULL_FUNC) ? KM_SLEEP : KM_NOSLEEP; 1606 int instance; 1607 size_t rlen; 1608 1609 ST_FUNC(devp->sd_dev, st_doattach); 1610 /* 1611 * Call the routine scsi_probe to do some of the dirty work. 1612 * If the INQUIRY command succeeds, the field sd_inq in the 1613 * device structure will be filled in. 1614 */ 1615 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1616 "st_doattach(): probing\n"); 1617 1618 if (scsi_probe(devp, canwait) == SCSIPROBE_EXISTS) { 1619 1620 /* 1621 * In checking the whole inq_dtype byte we are looking at both 1622 * the Peripheral Qualifier and the Peripheral Device Type. 1623 * For this driver we are only interested in sequential devices 1624 * that are connected or capable if connecting to this logical 1625 * unit. 1626 */ 1627 if (devp->sd_inq->inq_dtype == 1628 (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) { 1629 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1630 "probe exists\n"); 1631 } else { 1632 /* Something there but not a tape device */ 1633 scsi_unprobe(devp); 1634 return (DDI_FAILURE); 1635 } 1636 } else { 1637 /* Nothing there */ 1638 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1639 "probe failure: nothing there\n"); 1640 scsi_unprobe(devp); 1641 return (DDI_FAILURE); 1642 } 1643 1644 1645 /* 1646 * The actual unit is present. 1647 * Now is the time to fill in the rest of our info.. 1648 */ 1649 instance = ddi_get_instance(devp->sd_dev); 1650 1651 if (ddi_soft_state_zalloc(st_state, instance) != DDI_SUCCESS) { 1652 goto error; 1653 } 1654 un = ddi_get_soft_state(st_state, instance); 1655 1656 ASSERT(un != NULL); 1657 1658 un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL, 1659 MAX_SENSE_LENGTH, B_READ, canwait, NULL); 1660 if (un->un_rqs_bp == NULL) { 1661 goto error; 1662 } 1663 un->un_rqs = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp, 1664 CDB_GROUP0, 1, st_recov_sz, PKT_CONSISTENT, canwait, NULL); 1665 if (!un->un_rqs) { 1666 goto error; 1667 } 1668 ASSERT(un->un_rqs->pkt_resid == 0); 1669 devp->sd_sense = 1670 (struct scsi_extended_sense *)un->un_rqs_bp->b_un.b_addr; 1671 ASSERT(geterror(un->un_rqs_bp) == NULL); 1672 1673 (void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs->pkt_cdbp, 1674 SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0); 1675 FILL_SCSI1_LUN(devp, un->un_rqs); 1676 un->un_rqs->pkt_flags |= (FLAG_SENSING | FLAG_HEAD | FLAG_NODISCON); 1677 un->un_rqs->pkt_time = st_io_time; 1678 un->un_rqs->pkt_comp = st_intr; 1679 ri = (recov_info *)un->un_rqs->pkt_private; 1680 if (st_recov_sz == sizeof (recov_info)) { 1681 ri->privatelen = sizeof (recov_info); 1682 } else { 1683 ri->privatelen = sizeof (pkt_info); 1684 } 1685 1686 un->un_sbufp = getrbuf(km_flags); 1687 un->un_recov_buf = getrbuf(km_flags); 1688 1689 un->un_uscsi_rqs_buf = kmem_alloc(SENSE_LENGTH, KM_SLEEP); 1690 1691 /* 1692 * use i_ddi_mem_alloc() for now until we have an interface to allocate 1693 * memory for DMA which doesn't require a DMA handle. 1694 */ 1695 (void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr, 1696 sizeof (struct seq_mode), ((km_flags == KM_SLEEP) ? 1 : 0), 0, 1697 NULL, (caddr_t *)&un->un_mspl, &rlen, NULL); 1698 1699 (void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr, 1700 sizeof (read_pos_data_t), ((km_flags == KM_SLEEP) ? 1 : 0), 0, 1701 NULL, (caddr_t *)&un->un_read_pos_data, &rlen, NULL); 1702 1703 if (!un->un_sbufp || !un->un_mspl || !un->un_read_pos_data) { 1704 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, 1705 "probe partial failure: no space\n"); 1706 goto error; 1707 } 1708 1709 bzero(un->un_mspl, sizeof (struct seq_mode)); 1710 1711 cv_init(&un->un_sbuf_cv, NULL, CV_DRIVER, NULL); 1712 cv_init(&un->un_queue_cv, NULL, CV_DRIVER, NULL); 1713 cv_init(&un->un_clscv, NULL, CV_DRIVER, NULL); 1714 cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL); 1715 #ifdef __x86 1716 cv_init(&un->un_contig_mem_cv, NULL, CV_DRIVER, NULL); 1717 #endif 1718 1719 /* Initialize power managemnet condition variable */ 1720 cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL); 1721 cv_init(&un->un_tape_busy_cv, NULL, CV_DRIVER, NULL); 1722 cv_init(&un->un_recov_buf_cv, NULL, CV_DRIVER, NULL); 1723 1724 un->un_recov_taskq = ddi_taskq_create(devp->sd_dev, 1725 "un_recov_taskq", 1, TASKQ_DEFAULTPRI, km_flags); 1726 1727 ASSERT(un->un_recov_taskq != NULL); 1728 1729 un->un_pos.pmode = invalid; 1730 un->un_sd = devp; 1731 un->un_swr_token = (opaque_t)NULL; 1732 un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE; 1733 un->un_wormable = st_is_drive_worm; 1734 un->un_media_id_method = st_get_media_identification; 1735 /* 1736 * setting long a initial as it contains logical file info. 1737 * support for long format is mandatory but many drive don't do it. 1738 */ 1739 un->un_read_pos_type = LONG_POS; 1740 1741 un->un_suspend_pos.pmode = invalid; 1742 1743 st_add_recovery_info_to_pkt(un, un->un_rqs_bp, un->un_rqs); 1744 1745 #ifdef __x86 1746 if (ddi_dma_alloc_handle(ST_DEVINFO, &st_contig_mem_dma_attr, 1747 DDI_DMA_SLEEP, NULL, &un->un_contig_mem_hdl) != DDI_SUCCESS) { 1748 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, 1749 "allocation of contiguous memory dma handle failed!"); 1750 un->un_contig_mem_hdl = NULL; 1751 goto error; 1752 } 1753 #endif 1754 1755 /* 1756 * Since this driver manages devices with "remote" hardware, 1757 * i.e. the devices themselves have no "reg" properties, 1758 * the SUSPEND/RESUME commands in detach/attach will not be 1759 * called by the power management framework unless we request 1760 * it by creating a "pm-hardware-state" property and setting it 1761 * to value "needs-suspend-resume". 1762 */ 1763 if (ddi_prop_update_string(DDI_DEV_T_NONE, devp->sd_dev, 1764 "pm-hardware-state", "needs-suspend-resume") != 1765 DDI_PROP_SUCCESS) { 1766 1767 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1768 "ddi_prop_update(\"pm-hardware-state\") failed\n"); 1769 goto error; 1770 } 1771 1772 if (ddi_prop_create(DDI_DEV_T_NONE, devp->sd_dev, DDI_PROP_CANSLEEP, 1773 "no-involuntary-power-cycles", NULL, 0) != DDI_PROP_SUCCESS) { 1774 1775 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1776 "ddi_prop_create(\"no-involuntary-power-cycles\") " 1777 "failed\n"); 1778 goto error; 1779 } 1780 1781 (void) scsi_reset_notify(ROUTE, SCSI_RESET_NOTIFY, 1782 st_reset_notification, (caddr_t)un); 1783 1784 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, "attach success\n"); 1785 return (DDI_SUCCESS); 1786 1787 error: 1788 devp->sd_sense = NULL; 1789 1790 ddi_remove_minor_node(devp->sd_dev, NULL); 1791 if (un) { 1792 if (un->un_mspl) { 1793 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1794 } 1795 if (un->un_read_pos_data) { 1796 i_ddi_mem_free((caddr_t)un->un_read_pos_data, 0); 1797 } 1798 if (un->un_sbufp) { 1799 freerbuf(un->un_sbufp); 1800 } 1801 if (un->un_recov_buf) { 1802 freerbuf(un->un_recov_buf); 1803 } 1804 if (un->un_uscsi_rqs_buf) { 1805 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1806 } 1807 #ifdef __x86 1808 if (un->un_contig_mem_hdl != NULL) { 1809 ddi_dma_free_handle(&un->un_contig_mem_hdl); 1810 } 1811 #endif 1812 if (un->un_rqs) { 1813 scsi_destroy_pkt(un->un_rqs); 1814 } 1815 1816 if (un->un_rqs_bp) { 1817 scsi_free_consistent_buf(un->un_rqs_bp); 1818 } 1819 1820 ddi_soft_state_free(st_state, instance); 1821 devp->sd_private = NULL; 1822 } 1823 1824 if (devp->sd_inq) { 1825 scsi_unprobe(devp); 1826 } 1827 return (DDI_FAILURE); 1828 } 1829 1830 typedef int 1831 (*cfg_functp)(struct scsi_tape *, char *vidpid, struct st_drivetype *); 1832 1833 static cfg_functp config_functs[] = { 1834 st_get_conf_from_st_dot_conf, 1835 st_get_conf_from_st_conf_dot_c, 1836 st_get_conf_from_tape_drive, 1837 st_get_default_conf 1838 }; 1839 1840 1841 /* 1842 * determine tape type, using tape-config-list or built-in table or 1843 * use a generic tape config entry 1844 */ 1845 static void 1846 st_known_tape_type(struct scsi_tape *un) 1847 { 1848 struct st_drivetype *dp; 1849 cfg_functp *config_funct; 1850 uchar_t reserved; 1851 1852 ST_FUNC(ST_DEVINFO, st_known_tape_type); 1853 1854 reserved = (un->un_rsvd_status & ST_RESERVE) ? ST_RESERVE 1855 : ST_RELEASE; 1856 1857 /* 1858 * XXX: Emulex MT-02 (and emulators) predates SCSI-1 and has 1859 * no vid & pid inquiry data. So, we provide one. 1860 */ 1861 if (ST_INQUIRY->inq_len == 0 || 1862 (bcmp("\0\0\0\0\0\0\0\0", ST_INQUIRY->inq_vid, 8) == 0)) { 1863 (void) strcpy((char *)ST_INQUIRY->inq_vid, ST_MT02_NAME); 1864 } 1865 1866 if (un->un_dp_size == 0) { 1867 un->un_dp_size = sizeof (struct st_drivetype); 1868 dp = kmem_zalloc((size_t)un->un_dp_size, KM_SLEEP); 1869 un->un_dp = dp; 1870 } else { 1871 dp = un->un_dp; 1872 } 1873 1874 un->un_dp->non_motion_timeout = st_io_time; 1875 /* 1876 * Loop through the configuration methods till one works. 1877 */ 1878 for (config_funct = &config_functs[0]; ; config_funct++) { 1879 if ((*config_funct)(un, ST_INQUIRY->inq_vid, dp)) { 1880 break; 1881 } 1882 } 1883 1884 /* 1885 * If we didn't just make up this configuration and 1886 * all the density codes are the same.. 1887 * Set Auto Density over ride. 1888 */ 1889 if (*config_funct != st_get_default_conf) { 1890 /* 1891 * If this device is one that is configured and all 1892 * densities are the same, This saves doing gets and set 1893 * that yield nothing. 1894 */ 1895 if ((dp->densities[0]) == (dp->densities[1]) && 1896 (dp->densities[0]) == (dp->densities[2]) && 1897 (dp->densities[0]) == (dp->densities[3])) { 1898 1899 dp->options |= ST_AUTODEN_OVERRIDE; 1900 } 1901 } 1902 1903 1904 /* 1905 * Store tape drive characteristics. 1906 */ 1907 un->un_status = 0; 1908 un->un_attached = 1; 1909 un->un_init_options = dp->options; 1910 1911 /* setup operation time-outs based on options */ 1912 st_calculate_timeouts(un); 1913 1914 /* TLR support */ 1915 if (un->un_dp->type != ST_TYPE_INVALID) { 1916 int result; 1917 1918 /* try and enable TLR */ 1919 un->un_tlr_flag = TLR_SAS_ONE_DEVICE; 1920 result = st_set_target_TLR_mode(un, st_uscsi_cmd); 1921 if (result == EACCES) { 1922 /* 1923 * From attach command failed. 1924 * Set dp type so is run again on open. 1925 */ 1926 un->un_dp->type = ST_TYPE_INVALID; 1927 un->un_tlr_flag = TLR_NOT_KNOWN; 1928 } else if (result == 0) { 1929 if (scsi_ifgetcap(&un->un_sd->sd_address, 1930 "tran-layer-retries", 1) == -1) { 1931 un->un_tlr_flag = TLR_NOT_SUPPORTED; 1932 (void) st_set_target_TLR_mode(un, st_uscsi_cmd); 1933 } else { 1934 un->un_tlr_flag = TLR_SAS_ONE_DEVICE; 1935 } 1936 } else { 1937 un->un_tlr_flag = TLR_NOT_SUPPORTED; 1938 } 1939 } 1940 1941 /* make sure if we are supposed to be variable, make it variable */ 1942 if (dp->options & ST_VARIABLE) { 1943 dp->bsize = 0; 1944 } 1945 1946 if (reserved != ((un->un_rsvd_status & ST_RESERVE) ? ST_RESERVE 1947 : ST_RELEASE)) { 1948 (void) st_reserve_release(un, reserved, st_uscsi_cmd); 1949 } 1950 1951 un->un_unit_attention_flags |= 1; 1952 1953 scsi_log(ST_DEVINFO, st_label, CE_NOTE, "?<%s>\n", dp->name); 1954 1955 } 1956 1957 1958 typedef struct { 1959 int mask; 1960 int bottom; 1961 int top; 1962 char *name; 1963 } conf_limit; 1964 1965 static const conf_limit conf_limits[] = { 1966 1967 -1, 1, 2, "conf version", 1968 -1, MT_ISTS, ST_LAST_TYPE, "drive type", 1969 -1, 0, 0xffffff, "block size", 1970 ST_VALID_OPTS, 0, ST_VALID_OPTS, "options", 1971 -1, 0, 4, "number of densities", 1972 -1, 0, UINT8_MAX, "density code", 1973 -1, 0, 3, "default density", 1974 -1, 0, UINT16_MAX, "non motion timeout", 1975 -1, 0, UINT16_MAX, "I/O timeout", 1976 -1, 0, UINT16_MAX, "space timeout", 1977 -1, 0, UINT16_MAX, "load timeout", 1978 -1, 0, UINT16_MAX, "unload timeout", 1979 -1, 0, UINT16_MAX, "erase timeout", 1980 0, 0, 0, NULL 1981 }; 1982 1983 static int 1984 st_validate_conf_data(struct scsi_tape *un, int *list, int list_len, 1985 const char *conf_name) 1986 { 1987 int dens; 1988 int ndens; 1989 int value; 1990 int type; 1991 int count; 1992 const conf_limit *limit = &conf_limits[0]; 1993 1994 ST_FUNC(ST_DEVINFO, st_validate_conf_data); 1995 1996 ST_DEBUG3(ST_DEVINFO, st_label, CE_NOTE, 1997 "Checking %d entrys total with %d densities\n", list_len, list[4]); 1998 1999 count = list_len; 2000 type = *list; 2001 for (; count && limit->name; count--, list++, limit++) { 2002 2003 value = *list; 2004 if (value & ~limit->mask) { 2005 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2006 "%s %s value invalid bits set: 0x%X\n", 2007 conf_name, limit->name, value & ~limit->mask); 2008 *list &= limit->mask; 2009 } else if (value < limit->bottom) { 2010 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2011 "%s %s value too low: value = %d limit %d\n", 2012 conf_name, limit->name, value, limit->bottom); 2013 } else if (value > limit->top) { 2014 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2015 "%s %s value too high: value = %d limit %d\n", 2016 conf_name, limit->name, value, limit->top); 2017 } else { 2018 ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT, 2019 "%s %s value = 0x%X\n", 2020 conf_name, limit->name, value); 2021 } 2022 2023 /* If not the number of densities continue */ 2024 if (limit != &conf_limits[4]) { 2025 continue; 2026 } 2027 2028 /* If number of densities is not in range can't use config */ 2029 if (value < limit->bottom || value > limit->top) { 2030 return (-1); 2031 } 2032 2033 ndens = min(value, NDENSITIES); 2034 if ((type == 1) && (list_len - ndens) != 6) { 2035 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2036 "%s conf version 1 with %d densities has %d items" 2037 " should have %d", 2038 conf_name, ndens, list_len, 6 + ndens); 2039 } else if ((type == 2) && (list_len - ndens) != 13) { 2040 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2041 "%s conf version 2 with %d densities has %d items" 2042 " should have %d", 2043 conf_name, ndens, list_len, 13 + ndens); 2044 } 2045 2046 limit++; 2047 for (dens = 0; dens < ndens && count; dens++) { 2048 count--; 2049 list++; 2050 value = *list; 2051 if (value < limit->bottom) { 2052 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2053 "%s density[%d] value too low: value =" 2054 " 0x%X limit 0x%X\n", 2055 conf_name, dens, value, limit->bottom); 2056 } else if (value > limit->top) { 2057 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 2058 "%s density[%d] value too high: value =" 2059 " 0x%X limit 0x%X\n", 2060 conf_name, dens, value, limit->top); 2061 } else { 2062 ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT, 2063 "%s density[%d] value = 0x%X\n", 2064 conf_name, dens, value); 2065 } 2066 } 2067 } 2068 2069 return (0); 2070 } 2071 2072 static int 2073 st_get_conf_from_st_dot_conf(struct scsi_tape *un, char *vidpid, 2074 struct st_drivetype *dp) 2075 { 2076 caddr_t config_list = NULL; 2077 caddr_t data_list = NULL; 2078 int *data_ptr; 2079 caddr_t vidptr, prettyptr, datanameptr; 2080 size_t vidlen, prettylen, datanamelen, tripletlen = 0; 2081 int config_list_len, data_list_len, len, i; 2082 int version; 2083 int found = 0; 2084 2085 ST_FUNC(ST_DEVINFO, st_get_conf_from_st_dot_conf); 2086 2087 /* 2088 * Determine type of tape controller. Type is determined by 2089 * checking the vendor ids of the earlier inquiry command and 2090 * comparing those with vids in tape-config-list defined in st.conf 2091 */ 2092 if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, DDI_PROP_DONTPASS, 2093 "tape-config-list", (caddr_t)&config_list, &config_list_len) 2094 != DDI_PROP_SUCCESS) { 2095 return (found); 2096 } 2097 2098 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 2099 "st_get_conf_from_st_dot_conf(): st.conf has tape-config-list\n"); 2100 2101 /* 2102 * Compare vids in each triplet - if it matches, get value for 2103 * data_name and contruct a st_drivetype struct 2104 * tripletlen is not set yet! 2105 */ 2106 for (len = config_list_len, vidptr = config_list; 2107 len > 0; 2108 vidptr += tripletlen, len -= tripletlen) { 2109 2110 vidlen = strlen(vidptr); 2111 prettyptr = vidptr + vidlen + 1; 2112 prettylen = strlen(prettyptr); 2113 datanameptr = prettyptr + prettylen + 1; 2114 datanamelen = strlen(datanameptr); 2115 tripletlen = vidlen + prettylen + datanamelen + 3; 2116 2117 if (vidlen == 0) { 2118 continue; 2119 } 2120 2121 /* 2122 * If inquiry vid dosen't match this triplets vid, 2123 * try the next. 2124 */ 2125 if (strncasecmp(vidpid, vidptr, vidlen)) { 2126 continue; 2127 } 2128 2129 /* 2130 * if prettylen is zero then use the vid string 2131 */ 2132 if (prettylen == 0) { 2133 prettyptr = vidptr; 2134 prettylen = vidlen; 2135 } 2136 2137 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2138 "vid = %s, pretty=%s, dataname = %s\n", 2139 vidptr, prettyptr, datanameptr); 2140 2141 /* 2142 * get the data list 2143 */ 2144 if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, 0, 2145 datanameptr, (caddr_t)&data_list, 2146 &data_list_len) != DDI_PROP_SUCCESS) { 2147 /* 2148 * Error in getting property value 2149 * print warning! 2150 */ 2151 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2152 "data property (%s) has no value\n", 2153 datanameptr); 2154 continue; 2155 } 2156 2157 /* 2158 * now initialize the st_drivetype struct 2159 */ 2160 (void) strncpy(dp->name, prettyptr, ST_NAMESIZE - 1); 2161 dp->length = (int)min(vidlen, (VIDPIDLEN - 1)); 2162 (void) strncpy(dp->vid, vidptr, dp->length); 2163 data_ptr = (int *)data_list; 2164 /* 2165 * check if data is enough for version, type, 2166 * bsize, options, # of densities, density1, 2167 * density2, ..., default_density 2168 */ 2169 if ((data_list_len < 5 * sizeof (int)) || 2170 (data_list_len < 6 * sizeof (int) + 2171 *(data_ptr + 4) * sizeof (int))) { 2172 /* 2173 * print warning and skip to next triplet. 2174 */ 2175 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2176 "data property (%s) incomplete\n", 2177 datanameptr); 2178 kmem_free(data_list, data_list_len); 2179 continue; 2180 } 2181 2182 if (st_validate_conf_data(un, data_ptr, 2183 data_list_len / sizeof (int), datanameptr)) { 2184 kmem_free(data_list, data_list_len); 2185 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2186 "data property (%s) rejected\n", 2187 datanameptr); 2188 continue; 2189 } 2190 2191 /* 2192 * check version 2193 */ 2194 version = *data_ptr++; 2195 if (version != 1 && version != 2) { 2196 /* print warning but accept it */ 2197 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2198 "Version # for data property (%s) " 2199 "not set to 1 or 2\n", datanameptr); 2200 } 2201 2202 dp->type = *data_ptr++; 2203 dp->bsize = *data_ptr++; 2204 dp->options = *data_ptr++; 2205 dp->options |= ST_DYNAMIC; 2206 len = *data_ptr++; 2207 for (i = 0; i < NDENSITIES; i++) { 2208 if (i < len) { 2209 dp->densities[i] = *data_ptr++; 2210 } 2211 } 2212 dp->default_density = *data_ptr << 3; 2213 if (version == 2 && 2214 data_list_len >= (13 + len) * sizeof (int)) { 2215 data_ptr++; 2216 dp->non_motion_timeout = *data_ptr++; 2217 dp->io_timeout = *data_ptr++; 2218 dp->rewind_timeout = *data_ptr++; 2219 dp->space_timeout = *data_ptr++; 2220 dp->load_timeout = *data_ptr++; 2221 dp->unload_timeout = *data_ptr++; 2222 dp->erase_timeout = *data_ptr++; 2223 } 2224 kmem_free(data_list, data_list_len); 2225 found = 1; 2226 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2227 "found in st.conf: vid = %s, pretty=%s\n", 2228 dp->vid, dp->name); 2229 break; 2230 } 2231 2232 /* 2233 * free up the memory allocated by ddi_getlongprop 2234 */ 2235 if (config_list) { 2236 kmem_free(config_list, config_list_len); 2237 } 2238 return (found); 2239 } 2240 2241 static int 2242 st_get_conf_from_st_conf_dot_c(struct scsi_tape *un, char *vidpid, 2243 struct st_drivetype *dp) 2244 { 2245 int i; 2246 2247 ST_FUNC(ST_DEVINFO, st_get_conf_from_st_conf_dot_c); 2248 /* 2249 * Determine type of tape controller. Type is determined by 2250 * checking the result of the earlier inquiry command and 2251 * comparing vendor ids with strings in a table declared in st_conf.c. 2252 */ 2253 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2254 "st_get_conf_from_st_conf_dot_c(): looking at st_drivetypes\n"); 2255 2256 for (i = 0; i < st_ndrivetypes; i++) { 2257 if (st_drivetypes[i].length == 0) { 2258 continue; 2259 } 2260 if (strncasecmp(vidpid, st_drivetypes[i].vid, 2261 st_drivetypes[i].length)) { 2262 continue; 2263 } 2264 bcopy(&st_drivetypes[i], dp, sizeof (st_drivetypes[i])); 2265 return (1); 2266 } 2267 return (0); 2268 } 2269 2270 static int 2271 st_get_conf_from_tape_drive(struct scsi_tape *un, char *vidpid, 2272 struct st_drivetype *dp) 2273 { 2274 int bsize; 2275 ulong_t maxbsize; 2276 caddr_t buf; 2277 struct st_drivetype *tem_dp; 2278 struct read_blklim *blklim; 2279 int rval; 2280 int i; 2281 2282 ST_FUNC(ST_DEVINFO, st_get_conf_from_tape_drive); 2283 2284 /* 2285 * Determine the type of tape controller. Type is determined by 2286 * sending SCSI commands to tape drive and deriving the type from 2287 * the returned data. 2288 */ 2289 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2290 "st_get_conf_from_tape_drive(): asking tape drive\n"); 2291 2292 tem_dp = kmem_zalloc(sizeof (struct st_drivetype), KM_SLEEP); 2293 2294 /* 2295 * Make up a name 2296 */ 2297 bcopy(vidpid, tem_dp->name, VIDPIDLEN); 2298 tem_dp->name[VIDPIDLEN] = '\0'; 2299 tem_dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1)); 2300 (void) strncpy(tem_dp->vid, ST_INQUIRY->inq_vid, tem_dp->length); 2301 /* 2302 * 'clean' vendor and product strings of non-printing chars 2303 */ 2304 for (i = 0; i < VIDPIDLEN - 1; i ++) { 2305 if (tem_dp->name[i] < ' ' || tem_dp->name[i] > '~') { 2306 tem_dp->name[i] = '.'; 2307 } 2308 } 2309 2310 /* 2311 * MODE SENSE to determine block size. 2312 */ 2313 un->un_dp->options |= ST_MODE_SEL_COMP | ST_UNLOADABLE; 2314 rval = st_modesense(un); 2315 if (rval) { 2316 if (rval == EACCES) { 2317 un->un_dp->type = ST_TYPE_INVALID; 2318 rval = 1; 2319 } else { 2320 un->un_dp->options &= ~ST_MODE_SEL_COMP; 2321 rval = 0; 2322 } 2323 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2324 "st_get_conf_from_tape_drive(): fail to mode sense\n"); 2325 goto exit; 2326 } 2327 2328 /* Can mode sense page 0x10 or 0xf */ 2329 tem_dp->options |= ST_MODE_SEL_COMP; 2330 bsize = (un->un_mspl->high_bl << 16) | 2331 (un->un_mspl->mid_bl << 8) | 2332 (un->un_mspl->low_bl); 2333 2334 if (bsize == 0) { 2335 tem_dp->options |= ST_VARIABLE; 2336 tem_dp->bsize = 0; 2337 } else if (bsize > ST_MAXRECSIZE_FIXED) { 2338 rval = st_change_block_size(un, 0); 2339 if (rval) { 2340 if (rval == EACCES) { 2341 un->un_dp->type = ST_TYPE_INVALID; 2342 rval = 1; 2343 } else { 2344 rval = 0; 2345 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2346 "st_get_conf_from_tape_drive(): " 2347 "Fixed record size is too large and" 2348 "cannot switch to variable record size"); 2349 } 2350 goto exit; 2351 } 2352 tem_dp->options |= ST_VARIABLE; 2353 } else { 2354 rval = st_change_block_size(un, 0); 2355 if (rval == 0) { 2356 tem_dp->options |= ST_VARIABLE; 2357 tem_dp->bsize = 0; 2358 } else if (rval != EACCES) { 2359 tem_dp->bsize = bsize; 2360 } else { 2361 un->un_dp->type = ST_TYPE_INVALID; 2362 rval = 1; 2363 goto exit; 2364 } 2365 } 2366 2367 /* 2368 * If READ BLOCk LIMITS works and upper block size limit is 2369 * more than 64K, ST_NO_RECSIZE_LIMIT is supported. 2370 */ 2371 blklim = kmem_zalloc(sizeof (struct read_blklim), KM_SLEEP); 2372 rval = st_read_block_limits(un, blklim); 2373 if (rval) { 2374 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2375 "st_get_conf_from_tape_drive(): " 2376 "fail to read block limits.\n"); 2377 rval = 0; 2378 kmem_free(blklim, sizeof (struct read_blklim)); 2379 goto exit; 2380 } 2381 maxbsize = (blklim->max_hi << 16) + 2382 (blklim->max_mid << 8) + blklim->max_lo; 2383 if (maxbsize > ST_MAXRECSIZE_VARIABLE) { 2384 tem_dp->options |= ST_NO_RECSIZE_LIMIT; 2385 } 2386 kmem_free(blklim, sizeof (struct read_blklim)); 2387 2388 /* 2389 * Inquiry VPD page 0xb0 to see if the tape drive supports WORM 2390 */ 2391 buf = kmem_zalloc(6, KM_SLEEP); 2392 rval = st_get_special_inquiry(un, 6, buf, 0xb0); 2393 if (rval) { 2394 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2395 "st_get_conf_from_tape_drive(): " 2396 "fail to read vitial inquiry.\n"); 2397 rval = 0; 2398 kmem_free(buf, 6); 2399 goto exit; 2400 } 2401 if (buf[4] & 1) { 2402 tem_dp->options |= ST_WORMABLE; 2403 } 2404 kmem_free(buf, 6); 2405 2406 /* Assume BSD BSR KNOWS_EOD */ 2407 tem_dp->options |= ST_BSF | ST_BSR | ST_KNOWS_EOD | ST_UNLOADABLE; 2408 tem_dp->max_rretries = -1; 2409 tem_dp->max_wretries = -1; 2410 2411 /* 2412 * Decide the densities supported by tape drive by sending 2413 * REPORT DENSITY SUPPORT command. 2414 */ 2415 if (st_get_densities_from_tape_drive(un, tem_dp) == 0) { 2416 goto exit; 2417 } 2418 2419 /* 2420 * Decide the timeout values for several commands by sending 2421 * REPORT SUPPORTED OPERATION CODES command. 2422 */ 2423 rval = st_get_timeout_values_from_tape_drive(un, tem_dp); 2424 if (rval == 0 || ((rval == 1) && (tem_dp->type == ST_TYPE_INVALID))) { 2425 goto exit; 2426 } 2427 2428 bcopy(tem_dp, dp, sizeof (struct st_drivetype)); 2429 rval = 1; 2430 2431 exit: 2432 un->un_status = KEY_NO_SENSE; 2433 kmem_free(tem_dp, sizeof (struct st_drivetype)); 2434 return (rval); 2435 } 2436 2437 static int 2438 st_get_densities_from_tape_drive(struct scsi_tape *un, 2439 struct st_drivetype *dp) 2440 { 2441 int i, p; 2442 size_t buflen; 2443 ushort_t des_len; 2444 uchar_t *den_header; 2445 uchar_t num_den; 2446 uchar_t den[NDENSITIES]; 2447 uchar_t deflt[NDENSITIES]; 2448 struct report_density_desc *den_desc; 2449 2450 ST_FUNC(ST_DEVINFO, st_get_densities_from_type_drive); 2451 2452 /* 2453 * Since we have no idea how many densitiy support entries 2454 * will be returned, we send the command firstly assuming 2455 * there is only one. Then we can decide the number of 2456 * entries by available density support length. If multiple 2457 * entries exist, we will resend the command with enough 2458 * buffer size. 2459 */ 2460 buflen = sizeof (struct report_density_header) + 2461 sizeof (struct report_density_desc); 2462 den_header = kmem_zalloc(buflen, KM_SLEEP); 2463 if (st_report_density_support(un, den_header, buflen) != 0) { 2464 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2465 "st_get_conf_from_tape_drive(): fail to report density.\n"); 2466 kmem_free(den_header, buflen); 2467 return (0); 2468 } 2469 des_len = 2470 BE_16(((struct report_density_header *)den_header)->ava_dens_len); 2471 num_den = (des_len - 2) / sizeof (struct report_density_desc); 2472 2473 if (num_den > 1) { 2474 kmem_free(den_header, buflen); 2475 buflen = sizeof (struct report_density_header) + 2476 sizeof (struct report_density_desc) * num_den; 2477 den_header = kmem_zalloc(buflen, KM_SLEEP); 2478 if (st_report_density_support(un, den_header, buflen) != 0) { 2479 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2480 "st_get_conf_from_tape_drive(): " 2481 "fail to report density.\n"); 2482 kmem_free(den_header, buflen); 2483 return (0); 2484 } 2485 } 2486 2487 den_desc = (struct report_density_desc *)(den_header 2488 + sizeof (struct report_density_header)); 2489 2490 /* 2491 * Decide the drive type by assigning organization 2492 */ 2493 for (i = 0; i < ST_NUM_MEMBERS(st_vid_dt); i ++) { 2494 if (strncmp(st_vid_dt[i].vid, (char *)(den_desc->ass_org), 2495 8) == 0) { 2496 dp->type = st_vid_dt[i].type; 2497 break; 2498 } 2499 } 2500 if (i == ST_NUM_MEMBERS(st_vid_dt)) { 2501 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2502 "st_get_conf_from_tape_drive(): " 2503 "can't find match of assigned ort.\n"); 2504 kmem_free(den_header, buflen); 2505 return (0); 2506 } 2507 2508 /* 2509 * The tape drive may support many tape formats, but the st driver 2510 * supports only the four highest densities. Since density code 2511 * values are returned by ascending sequence, we start from the 2512 * last entry of density support data block descriptor. 2513 */ 2514 p = 0; 2515 den_desc += num_den - 1; 2516 for (i = 0; i < num_den && p < NDENSITIES; i ++, den_desc --) { 2517 if ((den_desc->pri_den != 0) && (den_desc->wrtok)) { 2518 if (p != 0) { 2519 if (den_desc->pri_den >= den[p - 1]) { 2520 continue; 2521 } 2522 } 2523 den[p] = den_desc->pri_den; 2524 deflt[p] = den_desc->deflt; 2525 p ++; 2526 } 2527 } 2528 2529 switch (p) { 2530 case 0: 2531 bzero(dp->densities, NDENSITIES); 2532 dp->options |= ST_AUTODEN_OVERRIDE; 2533 dp->default_density = MT_DENSITY4; 2534 break; 2535 2536 case 1: 2537 (void) memset(dp->densities, den[0], NDENSITIES); 2538 dp->options |= ST_AUTODEN_OVERRIDE; 2539 dp->default_density = MT_DENSITY4; 2540 break; 2541 2542 case 2: 2543 dp->densities[0] = den[1]; 2544 dp->densities[1] = den[1]; 2545 dp->densities[2] = den[0]; 2546 dp->densities[3] = den[0]; 2547 if (deflt[0]) { 2548 dp->default_density = MT_DENSITY4; 2549 } else { 2550 dp->default_density = MT_DENSITY2; 2551 } 2552 break; 2553 2554 case 3: 2555 dp->densities[0] = den[2]; 2556 dp->densities[1] = den[1]; 2557 dp->densities[2] = den[0]; 2558 dp->densities[3] = den[0]; 2559 if (deflt[0]) { 2560 dp->default_density = MT_DENSITY4; 2561 } else if (deflt[1]) { 2562 dp->default_density = MT_DENSITY2; 2563 } else { 2564 dp->default_density = MT_DENSITY1; 2565 } 2566 break; 2567 2568 default: 2569 for (i = p; i > p - NDENSITIES; i --) { 2570 dp->densities[i - 1] = den[p - i]; 2571 } 2572 if (deflt[0]) { 2573 dp->default_density = MT_DENSITY4; 2574 } else if (deflt[1]) { 2575 dp->default_density = MT_DENSITY3; 2576 } else if (deflt[2]) { 2577 dp->default_density = MT_DENSITY2; 2578 } else { 2579 dp->default_density = MT_DENSITY1; 2580 } 2581 break; 2582 } 2583 2584 bzero(dp->mediatype, NDENSITIES); 2585 2586 kmem_free(den_header, buflen); 2587 return (1); 2588 } 2589 2590 static int 2591 st_get_timeout_values_from_tape_drive(struct scsi_tape *un, 2592 struct st_drivetype *dp) 2593 { 2594 ushort_t timeout; 2595 int rval; 2596 2597 ST_FUNC(ST_DEVINFO, st_get_timeout_values_from_type_drive); 2598 2599 rval = st_get_timeouts_value(un, SCMD_ERASE, &timeout, 0); 2600 if (rval) { 2601 if (rval == EACCES) { 2602 un->un_dp->type = ST_TYPE_INVALID; 2603 dp->type = ST_TYPE_INVALID; 2604 return (1); 2605 } 2606 return (0); 2607 } 2608 dp->erase_timeout = timeout; 2609 2610 rval = st_get_timeouts_value(un, SCMD_READ, &timeout, 0); 2611 if (rval) { 2612 if (rval == EACCES) { 2613 un->un_dp->type = ST_TYPE_INVALID; 2614 dp->type = ST_TYPE_INVALID; 2615 return (1); 2616 } 2617 return (0); 2618 } 2619 dp->io_timeout = timeout; 2620 2621 rval = st_get_timeouts_value(un, SCMD_WRITE, &timeout, 0); 2622 if (rval) { 2623 if (rval == EACCES) { 2624 un->un_dp->type = ST_TYPE_INVALID; 2625 dp->type = ST_TYPE_INVALID; 2626 return (1); 2627 } 2628 return (0); 2629 } 2630 dp->io_timeout = max(dp->io_timeout, timeout); 2631 2632 rval = st_get_timeouts_value(un, SCMD_SPACE, &timeout, 0); 2633 if (rval) { 2634 if (rval == EACCES) { 2635 un->un_dp->type = ST_TYPE_INVALID; 2636 dp->type = ST_TYPE_INVALID; 2637 return (1); 2638 } 2639 return (0); 2640 } 2641 dp->space_timeout = timeout; 2642 2643 rval = st_get_timeouts_value(un, SCMD_LOAD, &timeout, 0); 2644 if (rval) { 2645 if (rval == EACCES) { 2646 un->un_dp->type = ST_TYPE_INVALID; 2647 dp->type = ST_TYPE_INVALID; 2648 return (1); 2649 } 2650 return (0); 2651 } 2652 dp->load_timeout = timeout; 2653 dp->unload_timeout = timeout; 2654 2655 rval = st_get_timeouts_value(un, SCMD_REWIND, &timeout, 0); 2656 if (rval) { 2657 if (rval == EACCES) { 2658 un->un_dp->type = ST_TYPE_INVALID; 2659 dp->type = ST_TYPE_INVALID; 2660 return (1); 2661 } 2662 return (0); 2663 } 2664 dp->rewind_timeout = timeout; 2665 2666 rval = st_get_timeouts_value(un, SCMD_INQUIRY, &timeout, 0); 2667 if (rval) { 2668 if (rval == EACCES) { 2669 un->un_dp->type = ST_TYPE_INVALID; 2670 dp->type = ST_TYPE_INVALID; 2671 return (1); 2672 } 2673 return (0); 2674 } 2675 dp->non_motion_timeout = timeout; 2676 2677 return (1); 2678 } 2679 2680 static int 2681 st_get_timeouts_value(struct scsi_tape *un, uchar_t option_code, 2682 ushort_t *timeout_value, ushort_t service_action) 2683 { 2684 uchar_t *timeouts; 2685 uchar_t *oper; 2686 uchar_t support; 2687 uchar_t cdbsize; 2688 uchar_t ctdp; 2689 size_t buflen; 2690 int rval; 2691 2692 ST_FUNC(ST_DEVINFO, st_get_timeouts_value); 2693 2694 buflen = sizeof (struct one_com_des) + 2695 sizeof (struct com_timeout_des); 2696 oper = kmem_zalloc(buflen, KM_SLEEP); 2697 rval = st_report_supported_operation(un, oper, option_code, 2698 service_action); 2699 2700 if (rval) { 2701 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2702 "st_get_timeouts_value(): " 2703 "fail to timeouts value for command %d.\n", option_code); 2704 kmem_free(oper, buflen); 2705 return (rval); 2706 } 2707 2708 support = ((struct one_com_des *)oper)->support; 2709 if ((support != SUPPORT_VALUES_SUPPORT_SCSI) && 2710 (support != SUPPORT_VALUES_SUPPORT_VENDOR)) { 2711 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2712 "st_get_timeouts_value(): " 2713 "command %d is not supported.\n", option_code); 2714 kmem_free(oper, buflen); 2715 return (ENOTSUP); 2716 } 2717 2718 ctdp = ((struct one_com_des *)oper)->ctdp; 2719 if (!ctdp) { 2720 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2721 "st_get_timeouts_value(): " 2722 "command timeout is not included.\n"); 2723 kmem_free(oper, buflen); 2724 return (ENOTSUP); 2725 } 2726 2727 cdbsize = BE_16(((struct one_com_des *)oper)->cdb_size); 2728 timeouts = (uchar_t *)(oper + cdbsize + 4); 2729 2730 /* 2731 * Timeout value in seconds is 4 bytes, but we only support the lower 2 2732 * bytes. If the higher 2 bytes are not zero, the timeout value is set 2733 * to 0xFFFF. 2734 */ 2735 if (*(timeouts + 8) != 0 || *(timeouts + 9) != 0) { 2736 *timeout_value = USHRT_MAX; 2737 } else { 2738 *timeout_value = ((*(timeouts + 10)) << 8) | 2739 (*(timeouts + 11)); 2740 } 2741 2742 kmem_free(oper, buflen); 2743 return (0); 2744 } 2745 2746 static int 2747 st_get_default_conf(struct scsi_tape *un, char *vidpid, struct st_drivetype *dp) 2748 { 2749 int i; 2750 2751 ST_FUNC(ST_DEVINFO, st_get_default_conf); 2752 2753 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 2754 "st_get_default_conf(): making drivetype from INQ cmd\n"); 2755 2756 /* 2757 * Make up a name 2758 */ 2759 bcopy("Vendor '", dp->name, 8); 2760 bcopy(vidpid, &dp->name[8], VIDLEN); 2761 bcopy("' Product '", &dp->name[16], 11); 2762 bcopy(&vidpid[8], &dp->name[27], PIDLEN); 2763 dp->name[ST_NAMESIZE - 2] = '\''; 2764 dp->name[ST_NAMESIZE - 1] = '\0'; 2765 dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1)); 2766 (void) strncpy(dp->vid, ST_INQUIRY->inq_vid, dp->length); 2767 /* 2768 * 'clean' vendor and product strings of non-printing chars 2769 */ 2770 for (i = 0; i < ST_NAMESIZE - 2; i++) { 2771 if (dp->name[i] < ' ' || dp->name[i] > '~') { 2772 dp->name[i] = '.'; 2773 } 2774 } 2775 dp->type = ST_TYPE_INVALID; 2776 dp->options |= (ST_DYNAMIC | ST_UNLOADABLE | ST_MODE_SEL_COMP); 2777 2778 return (1); /* Can Not Fail */ 2779 } 2780 2781 /* 2782 * Regular Unix Entry points 2783 */ 2784 2785 2786 2787 /* ARGSUSED */ 2788 static int 2789 st_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p) 2790 { 2791 dev_t dev = *dev_p; 2792 int rval = 0; 2793 2794 GET_SOFT_STATE(dev); 2795 2796 ST_ENTR(ST_DEVINFO, st_open); 2797 2798 /* 2799 * validate that we are addressing a sensible unit 2800 */ 2801 mutex_enter(ST_MUTEX); 2802 2803 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2804 "st_open(node = %s dev = 0x%lx, flag = %d, otyp = %d)\n", 2805 st_dev_name(dev), *dev_p, flag, otyp); 2806 2807 /* 2808 * All device accesss go thru st_strategy() where we check 2809 * suspend status 2810 */ 2811 2812 if (!un->un_attached) { 2813 st_known_tape_type(un); 2814 if (!un->un_attached) { 2815 rval = ENXIO; 2816 goto exit; 2817 } 2818 2819 } 2820 2821 /* 2822 * Check for the case of the tape in the middle of closing. 2823 * This isn't simply a check of the current state, because 2824 * we could be in state of sensing with the previous state 2825 * that of closing. 2826 * 2827 * And don't allow multiple opens. 2828 */ 2829 if (!(flag & (FNDELAY | FNONBLOCK)) && IS_CLOSING(un)) { 2830 un->un_laststate = un->un_state; 2831 un->un_state = ST_STATE_CLOSE_PENDING_OPEN; 2832 while (IS_CLOSING(un) || 2833 un->un_state == ST_STATE_CLOSE_PENDING_OPEN) { 2834 if (cv_wait_sig(&un->un_clscv, ST_MUTEX) == 0) { 2835 rval = EINTR; 2836 un->un_state = un->un_laststate; 2837 goto exit; 2838 } 2839 } 2840 } else if (un->un_state != ST_STATE_CLOSED) { 2841 rval = EBUSY; 2842 goto busy; 2843 } 2844 2845 /* 2846 * record current dev 2847 */ 2848 un->un_dev = dev; 2849 un->un_oflags = flag; /* save for use in st_tape_init() */ 2850 un->un_errno = 0; /* no errors yet */ 2851 un->un_restore_pos = 0; 2852 un->un_rqs_state = 0; 2853 2854 /* 2855 * If we are opening O_NDELAY, or O_NONBLOCK, we don't check for 2856 * anything, leave internal states alone, if fileno >= 0 2857 */ 2858 if (flag & (FNDELAY | FNONBLOCK)) { 2859 switch (un->un_pos.pmode) { 2860 2861 case invalid: 2862 un->un_state = ST_STATE_OFFLINE; 2863 break; 2864 2865 case legacy: 2866 /* 2867 * If position is anything other than rewound. 2868 */ 2869 if (un->un_pos.fileno != 0 || un->un_pos.blkno != 0) { 2870 /* 2871 * set un_read_only/write-protect status. 2872 * 2873 * If the tape is not bot we can assume 2874 * that mspl->wp_status is set properly. 2875 * else 2876 * we need to do a mode sense/Tur once 2877 * again to get the actual tape status.(since 2878 * user might have replaced the tape) 2879 * Hence make the st state OFFLINE so that 2880 * we re-intialize the tape once again. 2881 */ 2882 un->un_read_only = 2883 (un->un_oflags & FWRITE) ? RDWR : RDONLY; 2884 un->un_state = ST_STATE_OPEN_PENDING_IO; 2885 } else { 2886 un->un_state = ST_STATE_OFFLINE; 2887 } 2888 break; 2889 case logical: 2890 if (un->un_pos.lgclblkno == 0) { 2891 un->un_state = ST_STATE_OFFLINE; 2892 } else { 2893 un->un_read_only = 2894 (un->un_oflags & FWRITE) ? RDWR : RDONLY; 2895 un->un_state = ST_STATE_OPEN_PENDING_IO; 2896 } 2897 break; 2898 } 2899 rval = 0; 2900 } else { 2901 /* 2902 * Not opening O_NDELAY. 2903 */ 2904 un->un_state = ST_STATE_OPENING; 2905 2906 /* 2907 * Clear error entry stack 2908 */ 2909 st_empty_error_stack(un); 2910 2911 rval = st_tape_init(un); 2912 if ((rval == EACCES) && (un->un_read_only & WORM)) { 2913 un->un_state = ST_STATE_OPEN_PENDING_IO; 2914 rval = 0; /* so open doesn't fail */ 2915 } else if (rval) { 2916 /* 2917 * Release the tape unit, if reserved and not 2918 * preserve reserve. 2919 */ 2920 if ((un->un_rsvd_status & 2921 (ST_RESERVE | ST_PRESERVE_RESERVE)) == ST_RESERVE) { 2922 (void) st_reserve_release(un, ST_RELEASE, 2923 st_uscsi_cmd); 2924 } 2925 } else { 2926 un->un_state = ST_STATE_OPEN_PENDING_IO; 2927 } 2928 } 2929 2930 exit: 2931 /* 2932 * we don't want any uninvited guests scrogging our data when we're 2933 * busy with something, so for successful opens or failed opens 2934 * (except for EBUSY), reset these counters and state appropriately. 2935 */ 2936 if (rval != EBUSY) { 2937 if (rval) { 2938 un->un_state = ST_STATE_CLOSED; 2939 } 2940 un->un_err_resid = 0; 2941 un->un_retry_ct = 0; 2942 } 2943 busy: 2944 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2945 "st_open: return val = %x, state = %d\n", rval, un->un_state); 2946 mutex_exit(ST_MUTEX); 2947 return (rval); 2948 2949 } 2950 2951 static int 2952 st_tape_init(struct scsi_tape *un) 2953 { 2954 int err; 2955 int rval = 0; 2956 2957 ST_FUNC(ST_DEVINFO, st_tape_init); 2958 2959 ASSERT(mutex_owned(ST_MUTEX)); 2960 2961 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2962 "st_tape_init(un = 0x%p, oflags = %d)\n", (void*)un, un->un_oflags); 2963 2964 /* 2965 * Clean up after any errors left by 'last' close. 2966 * This also handles the case of the initial open. 2967 */ 2968 if (un->un_state != ST_STATE_INITIALIZING) { 2969 un->un_laststate = un->un_state; 2970 un->un_state = ST_STATE_OPENING; 2971 } 2972 2973 un->un_kbytes_xferred = 0; 2974 2975 /* 2976 * do a throw away TUR to clear check condition 2977 */ 2978 err = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 2979 2980 /* 2981 * If test unit ready fails because the drive is reserved 2982 * by another host fail the open for no access. 2983 */ 2984 if (err) { 2985 if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) { 2986 un->un_state = ST_STATE_CLOSED; 2987 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2988 "st_tape_init: RESERVATION CONFLICT\n"); 2989 rval = EACCES; 2990 goto exit; 2991 } else if ((un->un_rsvd_status & 2992 ST_APPLICATION_RESERVATIONS) != 0) { 2993 if ((ST_RQSENSE != NULL) && 2994 (ST_RQSENSE->es_add_code == 0x2a && 2995 ST_RQSENSE->es_qual_code == 0x03)) { 2996 un->un_state = ST_STATE_CLOSED; 2997 rval = EACCES; 2998 goto exit; 2999 } 3000 } 3001 } 3002 3003 /* 3004 * Tape self identification could fail if the tape drive is used by 3005 * another host during attach time. We try to get the tape type 3006 * again. This is also applied to any posponed configuration methods. 3007 */ 3008 if (un->un_dp->type == ST_TYPE_INVALID) { 3009 un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE; 3010 st_known_tape_type(un); 3011 } 3012 3013 /* 3014 * If the tape type is still invalid, try to determine the generic 3015 * configuration. 3016 */ 3017 if (un->un_dp->type == ST_TYPE_INVALID) { 3018 rval = st_determine_generic(un); 3019 if (rval) { 3020 if (rval != EACCES) { 3021 rval = EIO; 3022 } 3023 un->un_state = ST_STATE_CLOSED; 3024 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3025 "st_tape_init: %s invalid type\n", 3026 rval == EACCES ? "EACCES" : "EIO"); 3027 goto exit; 3028 } 3029 /* 3030 * If this is a Unknown Type drive, 3031 * Use the READ BLOCK LIMITS to determine if 3032 * allow large xfer is approprate if not globally 3033 * disabled with st_allow_large_xfer. 3034 */ 3035 un->un_allow_large_xfer = (uchar_t)st_allow_large_xfer; 3036 } else { 3037 3038 /* 3039 * If we allow_large_xfer (ie >64k) and have not yet found out 3040 * the max block size supported by the drive, 3041 * find it by issueing a READ_BLKLIM command. 3042 * if READ_BLKLIM cmd fails, assume drive doesn't 3043 * allow_large_xfer and min/max block sizes as 1 byte and 63k. 3044 */ 3045 un->un_allow_large_xfer = st_allow_large_xfer && 3046 (un->un_dp->options & ST_NO_RECSIZE_LIMIT); 3047 } 3048 /* 3049 * if maxbsize is unknown, set the maximum block size. 3050 */ 3051 if (un->un_maxbsize == MAXBSIZE_UNKNOWN) { 3052 3053 /* 3054 * Get the Block limits of the tape drive. 3055 * if un->un_allow_large_xfer = 0 , then make sure 3056 * that maxbsize is <= ST_MAXRECSIZE_FIXED. 3057 */ 3058 un->un_rbl = kmem_zalloc(RBLSIZE, KM_SLEEP); 3059 3060 err = st_cmd(un, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD); 3061 if (err) { 3062 /* Retry */ 3063 err = st_cmd(un, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD); 3064 } 3065 if (!err) { 3066 3067 /* 3068 * if cmd successful, use limit returned 3069 */ 3070 un->un_maxbsize = (un->un_rbl->max_hi << 16) + 3071 (un->un_rbl->max_mid << 8) + 3072 un->un_rbl->max_lo; 3073 un->un_minbsize = (un->un_rbl->min_hi << 8) + 3074 un->un_rbl->min_lo; 3075 un->un_data_mod = 1 << un->un_rbl->granularity; 3076 if ((un->un_maxbsize == 0) || 3077 (un->un_allow_large_xfer == 0 && 3078 un->un_maxbsize > ST_MAXRECSIZE_FIXED)) { 3079 un->un_maxbsize = ST_MAXRECSIZE_FIXED; 3080 3081 } else if (un->un_dp->type == ST_TYPE_DEFAULT) { 3082 /* 3083 * Drive is not one that is configured, But the 3084 * READ BLOCK LIMITS tells us it can do large 3085 * xfers. 3086 */ 3087 if (un->un_maxbsize > ST_MAXRECSIZE_FIXED) { 3088 un->un_dp->options |= 3089 ST_NO_RECSIZE_LIMIT; 3090 } 3091 /* 3092 * If max and mimimum block limits are the 3093 * same this is a fixed block size device. 3094 */ 3095 if (un->un_maxbsize == un->un_minbsize) { 3096 un->un_dp->options &= ~ST_VARIABLE; 3097 } 3098 } 3099 3100 if (un->un_minbsize == 0) { 3101 un->un_minbsize = 1; 3102 } 3103 3104 } else { /* error on read block limits */ 3105 3106 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 3107 "!st_tape_init: Error on READ BLOCK LIMITS," 3108 " errno = %d un_rsvd_status = 0x%X\n", 3109 err, un->un_rsvd_status); 3110 3111 /* 3112 * since read block limits cmd failed, 3113 * do not allow large xfers. 3114 * use old values in st_minphys 3115 */ 3116 if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) { 3117 rval = EACCES; 3118 } else { 3119 un->un_allow_large_xfer = 0; 3120 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 3121 "!Disabling large transfers\n"); 3122 3123 /* 3124 * we guess maxbsize and minbsize 3125 */ 3126 if (un->un_bsize) { 3127 un->un_maxbsize = un->un_minbsize = 3128 un->un_bsize; 3129 } else { 3130 un->un_maxbsize = ST_MAXRECSIZE_FIXED; 3131 un->un_minbsize = 1; 3132 } 3133 /* 3134 * Data Mod must be set, 3135 * Even if read block limits fails. 3136 * Prevents Divide By Zero in st_rw(). 3137 */ 3138 un->un_data_mod = 1; 3139 } 3140 } 3141 if (un->un_rbl) { 3142 kmem_free(un->un_rbl, RBLSIZE); 3143 un->un_rbl = NULL; 3144 } 3145 3146 if (rval) { 3147 goto exit; 3148 } 3149 } 3150 3151 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 3152 "maxdma = %d, maxbsize = %d, minbsize = %d, %s large xfer\n", 3153 un->un_maxdma, un->un_maxbsize, un->un_minbsize, 3154 (un->un_allow_large_xfer ? "ALLOW": "DON'T ALLOW")); 3155 3156 err = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 3157 3158 if (err != 0) { 3159 if (err == EINTR) { 3160 un->un_laststate = un->un_state; 3161 un->un_state = ST_STATE_CLOSED; 3162 rval = EINTR; 3163 goto exit; 3164 } 3165 /* 3166 * Make sure the tape is ready 3167 */ 3168 un->un_pos.pmode = invalid; 3169 if (un->un_status != KEY_UNIT_ATTENTION) { 3170 /* 3171 * allow open no media. Subsequent MTIOCSTATE 3172 * with media present will complete the open 3173 * logic. 3174 */ 3175 un->un_laststate = un->un_state; 3176 if (un->un_oflags & (FNONBLOCK|FNDELAY)) { 3177 un->un_mediastate = MTIO_EJECTED; 3178 un->un_state = ST_STATE_OFFLINE; 3179 rval = 0; 3180 goto exit; 3181 } else { 3182 un->un_state = ST_STATE_CLOSED; 3183 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3184 "st_tape_init EIO no media, not opened " 3185 "O_NONBLOCK|O_EXCL\n"); 3186 rval = EIO; 3187 goto exit; 3188 } 3189 } 3190 } 3191 3192 /* 3193 * On each open, initialize block size from drivetype struct, 3194 * as it could have been changed by MTSRSZ ioctl. 3195 * Now, ST_VARIABLE simply means drive is capable of variable 3196 * mode. All drives are assumed to support fixed records. 3197 * Hence, un_bsize tells what mode the drive is in. 3198 * un_bsize = 0 - variable record length 3199 * = x - fixed record length is x 3200 */ 3201 un->un_bsize = un->un_dp->bsize; 3202 3203 /* 3204 * If saved position is valid go there 3205 */ 3206 if (un->un_restore_pos) { 3207 un->un_restore_pos = 0; 3208 un->un_pos.fileno = un->un_save_fileno; 3209 un->un_pos.blkno = un->un_save_blkno; 3210 rval = st_validate_tapemarks(un, st_uscsi_cmd, &un->un_pos); 3211 if (rval != 0) { 3212 if (rval != EACCES) { 3213 rval = EIO; 3214 } 3215 un->un_laststate = un->un_state; 3216 un->un_state = ST_STATE_CLOSED; 3217 goto exit; 3218 } 3219 } 3220 3221 if (un->un_pos.pmode == invalid) { 3222 rval = st_loadtape(un); 3223 if (rval) { 3224 if (rval != EACCES) { 3225 rval = EIO; 3226 } 3227 un->un_laststate = un->un_state; 3228 un->un_state = ST_STATE_CLOSED; 3229 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3230 "st_tape_init: %s can't open tape\n", 3231 rval == EACCES ? "EACCES" : "EIO"); 3232 goto exit; 3233 } 3234 } 3235 3236 /* 3237 * do a mode sense to pick up state of current write-protect, 3238 * Could cause reserve and fail due to conflict. 3239 */ 3240 if (un->un_unit_attention_flags) { 3241 rval = st_modesense(un); 3242 if (rval == EACCES) { 3243 goto exit; 3244 } 3245 } 3246 3247 /* 3248 * If we are opening the tape for writing, check 3249 * to make sure that the tape can be written. 3250 */ 3251 if (un->un_oflags & FWRITE) { 3252 err = 0; 3253 if (un->un_mspl->wp) { 3254 un->un_status = KEY_WRITE_PROTECT; 3255 un->un_laststate = un->un_state; 3256 un->un_state = ST_STATE_CLOSED; 3257 rval = EACCES; 3258 /* 3259 * STK sets the wp bit if volsafe tape is loaded. 3260 */ 3261 if ((un->un_dp->type == MT_ISSTK9840) && 3262 (un->un_dp->options & ST_WORMABLE)) { 3263 un->un_read_only = RDONLY; 3264 } else { 3265 goto exit; 3266 } 3267 } else { 3268 un->un_read_only = RDWR; 3269 } 3270 } else { 3271 un->un_read_only = RDONLY; 3272 } 3273 3274 if (un->un_dp->options & ST_WORMABLE && 3275 un->un_unit_attention_flags) { 3276 un->un_read_only |= un->un_wormable(un); 3277 3278 if (((un->un_read_only == WORM) || 3279 (un->un_read_only == RDWORM)) && 3280 ((un->un_oflags & FWRITE) == FWRITE)) { 3281 un->un_status = KEY_DATA_PROTECT; 3282 rval = EACCES; 3283 ST_DEBUG4(ST_DEVINFO, st_label, CE_NOTE, 3284 "read_only = %d eof = %d oflag = %d\n", 3285 un->un_read_only, un->un_pos.eof, un->un_oflags); 3286 } 3287 } 3288 3289 /* 3290 * If we're opening the tape write-only, we need to 3291 * write 2 filemarks on the HP 1/2 inch drive, to 3292 * create a null file. 3293 */ 3294 if ((un->un_read_only == RDWR) || 3295 (un->un_read_only == WORM) && (un->un_oflags & FWRITE)) { 3296 if (un->un_dp->options & ST_REEL) { 3297 un->un_fmneeded = 2; 3298 } else { 3299 un->un_fmneeded = 1; 3300 } 3301 } else { 3302 un->un_fmneeded = 0; 3303 } 3304 3305 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 3306 "fmneeded = %x\n", un->un_fmneeded); 3307 3308 /* 3309 * Make sure the density can be selected correctly. 3310 * If WORM can only write at the append point which in most cases 3311 * isn't BOP. st_determine_density() with a B_WRITE only attempts 3312 * to set and try densities if a BOP. 3313 */ 3314 if (st_determine_density(un, 3315 un->un_read_only == RDWR ? B_WRITE : B_READ)) { 3316 un->un_status = KEY_ILLEGAL_REQUEST; 3317 un->un_laststate = un->un_state; 3318 un->un_state = ST_STATE_CLOSED; 3319 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 3320 "st_tape_init: EIO can't determine density\n"); 3321 rval = EIO; 3322 goto exit; 3323 } 3324 3325 /* 3326 * Destroy the knowledge that we have 'determined' 3327 * density so that a later read at BOT comes along 3328 * does the right density determination. 3329 */ 3330 3331 un->un_density_known = 0; 3332 3333 3334 /* 3335 * Okay, the tape is loaded and either at BOT or somewhere past. 3336 * Mark the state such that any I/O or tape space operations 3337 * will get/set the right density, etc.. 3338 */ 3339 un->un_laststate = un->un_state; 3340 un->un_lastop = ST_OP_NIL; 3341 un->un_mediastate = MTIO_INSERTED; 3342 cv_broadcast(&un->un_state_cv); 3343 3344 /* 3345 * Set test append flag if writing. 3346 * First write must check that tape is positioned correctly. 3347 */ 3348 un->un_test_append = (un->un_oflags & FWRITE); 3349 3350 /* 3351 * if there are pending unit attention flags. 3352 * Check that the media has not changed. 3353 */ 3354 if (un->un_unit_attention_flags) { 3355 rval = st_get_media_identification(un, st_uscsi_cmd); 3356 if (rval != 0 && rval != EACCES) { 3357 rval = EIO; 3358 } 3359 un->un_unit_attention_flags = 0; 3360 } 3361 3362 exit: 3363 un->un_err_resid = 0; 3364 un->un_last_resid = 0; 3365 un->un_last_count = 0; 3366 3367 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3368 "st_tape_init: return val = %x\n", rval); 3369 return (rval); 3370 3371 } 3372 3373 3374 3375 /* ARGSUSED */ 3376 static int 3377 st_close(dev_t dev, int flag, int otyp, cred_t *cred_p) 3378 { 3379 int err = 0; 3380 int count, last_state; 3381 minor_t minor = getminor(dev); 3382 #ifdef __x86 3383 struct contig_mem *cp, *cp_temp; 3384 #endif 3385 3386 GET_SOFT_STATE(dev); 3387 3388 ST_ENTR(ST_DEVINFO, st_close); 3389 3390 /* 3391 * wait till all cmds in the pipeline have been completed 3392 */ 3393 mutex_enter(ST_MUTEX); 3394 3395 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3396 "st_close(dev = 0x%lx, flag = %d, otyp = %d)\n", dev, flag, otyp); 3397 3398 st_wait_for_io(un); 3399 3400 /* turn off persistent errors on close, as we want close to succeed */ 3401 st_turn_pe_off(un); 3402 3403 /* 3404 * set state to indicate that we are in process of closing 3405 */ 3406 last_state = un->un_laststate = un->un_state; 3407 un->un_state = ST_STATE_CLOSING; 3408 3409 ST_POS(ST_DEVINFO, "st_close1:", &un->un_pos); 3410 3411 /* 3412 * BSD behavior: 3413 * a close always causes a silent span to the next file if we've hit 3414 * an EOF (but not yet read across it). 3415 */ 3416 if ((minor & MT_BSD) && (un->un_pos.eof == ST_EOF)) { 3417 if (un->un_pos.pmode != invalid) { 3418 un->un_pos.fileno++; 3419 un->un_pos.blkno = 0; 3420 } 3421 un->un_pos.eof = ST_NO_EOF; 3422 } 3423 3424 /* 3425 * SVR4 behavior for skipping to next file: 3426 * 3427 * If we have not seen a filemark, space to the next file 3428 * 3429 * If we have already seen the filemark we are physically in the next 3430 * file and we only increment the filenumber 3431 */ 3432 if (((minor & (MT_BSD | MT_NOREWIND)) == MT_NOREWIND) && 3433 (flag & FREAD) && /* reading or at least asked to */ 3434 (un->un_mediastate == MTIO_INSERTED) && /* tape loaded */ 3435 (un->un_pos.pmode != invalid) && /* XXX position known */ 3436 ((un->un_pos.blkno != 0) && /* inside a file */ 3437 (un->un_lastop != ST_OP_WRITE) && /* Didn't just write */ 3438 (un->un_lastop != ST_OP_WEOF))) { /* or write filemarks */ 3439 switch (un->un_pos.eof) { 3440 case ST_NO_EOF: 3441 /* 3442 * if we were reading and did not read the complete file 3443 * skip to the next file, leaving the tape correctly 3444 * positioned to read the first record of the next file 3445 * Check first for REEL if we are at EOT by trying to 3446 * read a block 3447 */ 3448 if ((un->un_dp->options & ST_REEL) && 3449 (!(un->un_dp->options & ST_READ_IGNORE_EOFS)) && 3450 (un->un_pos.blkno == 0)) { 3451 if (st_cmd(un, SCMD_SPACE, Blk(1), SYNC_CMD)) { 3452 ST_DEBUG2(ST_DEVINFO, st_label, 3453 SCSI_DEBUG, 3454 "st_close : EIO can't space\n"); 3455 err = EIO; 3456 goto error_out; 3457 } 3458 if (un->un_pos.eof >= ST_EOF_PENDING) { 3459 un->un_pos.eof = ST_EOT_PENDING; 3460 un->un_pos.fileno += 1; 3461 un->un_pos.blkno = 0; 3462 break; 3463 } 3464 } 3465 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 3466 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3467 "st_close: EIO can't space #2\n"); 3468 err = EIO; 3469 goto error_out; 3470 } else { 3471 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3472 "st_close2: fileno=%x,blkno=%x,eof=%x\n", 3473 un->un_pos.fileno, un->un_pos.blkno, 3474 un->un_pos.eof); 3475 un->un_pos.eof = ST_NO_EOF; 3476 } 3477 break; 3478 3479 case ST_EOF_PENDING: 3480 case ST_EOF: 3481 un->un_pos.fileno += 1; 3482 un->un_pos.lgclblkno += 1; 3483 un->un_pos.blkno = 0; 3484 un->un_pos.eof = ST_NO_EOF; 3485 break; 3486 3487 case ST_EOT: 3488 case ST_EOT_PENDING: 3489 case ST_EOM: 3490 /* nothing to do */ 3491 break; 3492 default: 3493 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 3494 "Undefined state 0x%x", un->un_pos.eof); 3495 3496 } 3497 } 3498 3499 3500 /* 3501 * For performance reasons (HP 88780), the driver should 3502 * postpone writing the second tape mark until just before a file 3503 * positioning ioctl is issued (e.g., rewind). This means that 3504 * the user must not manually rewind the tape because the tape will 3505 * be missing the second tape mark which marks EOM. 3506 * However, this small performance improvement is not worth the risk. 3507 */ 3508 3509 /* 3510 * We need to back up over the filemark we inadvertently popped 3511 * over doing a read in between the two filemarks that constitute 3512 * logical eot for 1/2" tapes. Note that ST_EOT_PENDING is only 3513 * set while reading. 3514 * 3515 * If we happen to be at physical eot (ST_EOM) (writing case), 3516 * the writing of filemark(s) will clear the ST_EOM state, which 3517 * we don't want, so we save this state and restore it later. 3518 */ 3519 3520 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3521 "flag=%x, fmneeded=%x, lastop=%x, eof=%x\n", 3522 flag, un->un_fmneeded, un->un_lastop, un->un_pos.eof); 3523 3524 if (un->un_pos.eof == ST_EOT_PENDING) { 3525 if (minor & MT_NOREWIND) { 3526 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 3527 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3528 "st_close: EIO can't space #3\n"); 3529 err = EIO; 3530 goto error_out; 3531 } else { 3532 un->un_pos.blkno = 0; 3533 un->un_pos.eof = ST_EOT; 3534 } 3535 } else { 3536 un->un_pos.eof = ST_NO_EOF; 3537 } 3538 3539 /* 3540 * Do we need to write a file mark? 3541 * 3542 * only write filemarks if there are fmks to be written and 3543 * - open for write (possibly read/write) 3544 * - the last operation was a write 3545 * or: 3546 * - opened for wronly 3547 * - no data was written 3548 */ 3549 } else if ((un->un_pos.pmode != invalid) && 3550 (un->un_fmneeded > 0) && 3551 (((flag & FWRITE) && 3552 ((un->un_lastop == ST_OP_WRITE)||(un->un_lastop == ST_OP_WEOF))) || 3553 ((flag == FWRITE) && (un->un_lastop == ST_OP_NIL)))) { 3554 3555 /* save ST_EOM state */ 3556 int was_at_eom = (un->un_pos.eof == ST_EOM) ? 1 : 0; 3557 3558 /* 3559 * Note that we will write a filemark if we had opened 3560 * the tape write only and no data was written, thus 3561 * creating a null file. 3562 * 3563 * If the user already wrote one, we only have to write 1 more. 3564 * If they wrote two, we don't have to write any. 3565 */ 3566 3567 count = un->un_fmneeded; 3568 if (count > 0) { 3569 if (st_cmd(un, SCMD_WRITE_FILE_MARK, count, SYNC_CMD)) { 3570 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3571 "st_close : EIO can't wfm\n"); 3572 err = EIO; 3573 goto error_out; 3574 } 3575 if ((un->un_dp->options & ST_REEL) && 3576 (minor & MT_NOREWIND)) { 3577 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 3578 ST_DEBUG2(ST_DEVINFO, st_label, 3579 SCSI_DEBUG, 3580 "st_close : EIO space fmk(-1)\n"); 3581 err = EIO; 3582 goto error_out; 3583 } 3584 un->un_pos.eof = ST_NO_EOF; 3585 /* fix up block number */ 3586 un->un_pos.blkno = 0; 3587 } 3588 } 3589 3590 /* 3591 * If we aren't going to be rewinding, and we were at 3592 * physical eot, restore the state that indicates we 3593 * are at physical eot. Once you have reached physical 3594 * eot, and you close the tape, the only thing you can 3595 * do on the next open is to rewind. Access to trailer 3596 * records is only allowed without closing the device. 3597 */ 3598 if ((minor & MT_NOREWIND) == 0 && was_at_eom) { 3599 un->un_pos.eof = ST_EOM; 3600 } 3601 } 3602 3603 /* 3604 * report soft errors if enabled and available, if we never accessed 3605 * the drive, don't get errors. This will prevent some DAT error 3606 * messages upon LOG SENSE. 3607 */ 3608 if (st_report_soft_errors_on_close && 3609 (un->un_dp->options & ST_SOFT_ERROR_REPORTING) && 3610 (last_state != ST_STATE_OFFLINE)) { 3611 if (st_report_soft_errors(dev, flag)) { 3612 err = EIO; 3613 goto error_out; 3614 } 3615 } 3616 3617 3618 /* 3619 * Do we need to rewind? Can we rewind? 3620 */ 3621 if ((minor & MT_NOREWIND) == 0 && 3622 un->un_pos.pmode != invalid && err == 0) { 3623 /* 3624 * We'd like to rewind with the 3625 * 'immediate' bit set, but this 3626 * causes problems on some drives 3627 * where subsequent opens get a 3628 * 'NOT READY' error condition 3629 * back while the tape is rewinding, 3630 * which is impossible to distinguish 3631 * from the condition of 'no tape loaded'. 3632 * 3633 * Also, for some targets, if you disconnect 3634 * with the 'immediate' bit set, you don't 3635 * actually return right away, i.e., the 3636 * target ignores your request for immediate 3637 * return. 3638 * 3639 * Instead, we'll fire off an async rewind 3640 * command. We'll mark the device as closed, 3641 * and any subsequent open will stall on 3642 * the first TEST_UNIT_READY until the rewind 3643 * completes. 3644 */ 3645 3646 /* 3647 * Used to be if reserve was not supported we'd send an 3648 * asynchronious rewind. Comments above may be slightly invalid 3649 * as the immediate bit was never set. Doing an immedate rewind 3650 * makes sense, I think fixes to not ready status might handle 3651 * the problems described above. 3652 */ 3653 if (un->un_sd->sd_inq->inq_ansi < 2) { 3654 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 3655 err = EIO; 3656 } 3657 } else { 3658 /* flush data for older drives per scsi spec. */ 3659 if (st_cmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD)) { 3660 err = EIO; 3661 } else { 3662 /* release the drive before rewind immediate */ 3663 if ((un->un_rsvd_status & 3664 (ST_RESERVE | ST_PRESERVE_RESERVE)) == 3665 ST_RESERVE) { 3666 if (st_reserve_release(un, ST_RELEASE, 3667 st_uscsi_cmd)) { 3668 err = EIO; 3669 } 3670 } 3671 3672 /* send rewind with immediate bit set */ 3673 if (st_cmd(un, SCMD_REWIND, 1, ASYNC_CMD)) { 3674 err = EIO; 3675 } 3676 } 3677 } 3678 /* 3679 * Setting positions invalid in case the rewind doesn't 3680 * happen. Drives don't like to rewind if resets happen 3681 * they will tend to move back to where the rewind was 3682 * issued if a reset or something happens so that if a 3683 * write happens the data doesn't get clobbered. 3684 * 3685 * Not a big deal if the position is invalid when the 3686 * open occures it will do a read position. 3687 */ 3688 un->un_pos.pmode = invalid; 3689 un->un_running.pmode = invalid; 3690 3691 if (err == EIO) { 3692 goto error_out; 3693 } 3694 } 3695 3696 /* 3697 * eject tape if necessary 3698 */ 3699 if (un->un_eject_tape_on_failure) { 3700 un->un_eject_tape_on_failure = 0; 3701 if (st_cmd(un, SCMD_LOAD, LD_UNLOAD, SYNC_CMD)) { 3702 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3703 "st_close : can't unload tape\n"); 3704 err = EIO; 3705 goto error_out; 3706 } else { 3707 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3708 "st_close : tape unloaded \n"); 3709 un->un_pos.eof = ST_NO_EOF; 3710 un->un_mediastate = MTIO_EJECTED; 3711 } 3712 } 3713 /* 3714 * Release the tape unit, if default reserve/release 3715 * behaviour. 3716 */ 3717 if ((un->un_rsvd_status & 3718 (ST_RESERVE | ST_PRESERVE_RESERVE | 3719 ST_APPLICATION_RESERVATIONS)) == ST_RESERVE) { 3720 (void) st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 3721 } 3722 error_out: 3723 /* 3724 * clear up state 3725 */ 3726 un->un_laststate = un->un_state; 3727 un->un_state = ST_STATE_CLOSED; 3728 un->un_lastop = ST_OP_NIL; 3729 un->un_throttle = 1; /* assume one request at time, for now */ 3730 un->un_retry_ct = 0; 3731 un->un_errno = 0; 3732 un->un_swr_token = (opaque_t)NULL; 3733 un->un_rsvd_status &= ~(ST_INIT_RESERVE); 3734 3735 /* Restore the options to the init time settings */ 3736 if (un->un_init_options & ST_READ_IGNORE_ILI) { 3737 un->un_dp->options |= ST_READ_IGNORE_ILI; 3738 } else { 3739 un->un_dp->options &= ~ST_READ_IGNORE_ILI; 3740 } 3741 3742 if (un->un_init_options & ST_READ_IGNORE_EOFS) { 3743 un->un_dp->options |= ST_READ_IGNORE_EOFS; 3744 } else { 3745 un->un_dp->options &= ~ST_READ_IGNORE_EOFS; 3746 } 3747 3748 if (un->un_init_options & ST_SHORT_FILEMARKS) { 3749 un->un_dp->options |= ST_SHORT_FILEMARKS; 3750 } else { 3751 un->un_dp->options &= ~ST_SHORT_FILEMARKS; 3752 } 3753 3754 ASSERT(mutex_owned(ST_MUTEX)); 3755 3756 /* 3757 * Signal anyone awaiting a close operation to complete. 3758 */ 3759 cv_signal(&un->un_clscv); 3760 3761 /* 3762 * any kind of error on closing causes all state to be tossed 3763 */ 3764 if (err && un->un_status != KEY_ILLEGAL_REQUEST) { 3765 /* 3766 * note that st_intr has already set 3767 * un_pos.pmode to invalid. 3768 */ 3769 un->un_density_known = 0; 3770 } 3771 3772 #ifdef __x86 3773 /* 3774 * free any contiguous mem alloc'ed for big block I/O 3775 */ 3776 cp = un->un_contig_mem; 3777 while (cp) { 3778 if (cp->cm_addr) { 3779 ddi_dma_mem_free(&cp->cm_acc_hdl); 3780 } 3781 cp_temp = cp; 3782 cp = cp->cm_next; 3783 kmem_free(cp_temp, 3784 sizeof (struct contig_mem) + biosize()); 3785 } 3786 un->un_contig_mem_total_num = 0; 3787 un->un_contig_mem_available_num = 0; 3788 un->un_contig_mem = NULL; 3789 un->un_max_contig_mem_len = 0; 3790 #endif 3791 3792 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 3793 "st_close3: return val = %x, fileno=%x, blkno=%x, eof=%x\n", 3794 err, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 3795 3796 mutex_exit(ST_MUTEX); 3797 return (err); 3798 } 3799 3800 /* 3801 * These routines perform raw i/o operations. 3802 */ 3803 3804 /* ARGSUSED2 */ 3805 static int 3806 st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p) 3807 { 3808 #ifdef STDEBUG 3809 GET_SOFT_STATE(dev); 3810 ST_ENTR(ST_DEVINFO, st_aread); 3811 #endif 3812 return (st_arw(dev, aio, B_READ)); 3813 } 3814 3815 3816 /* ARGSUSED2 */ 3817 static int 3818 st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p) 3819 { 3820 #ifdef STDEBUG 3821 GET_SOFT_STATE(dev); 3822 ST_ENTR(ST_DEVINFO, st_awrite); 3823 #endif 3824 return (st_arw(dev, aio, B_WRITE)); 3825 } 3826 3827 3828 3829 /* ARGSUSED */ 3830 static int 3831 st_read(dev_t dev, struct uio *uiop, cred_t *cred_p) 3832 { 3833 #ifdef STDEBUG 3834 GET_SOFT_STATE(dev); 3835 ST_ENTR(ST_DEVINFO, st_read); 3836 #endif 3837 return (st_rw(dev, uiop, B_READ)); 3838 } 3839 3840 /* ARGSUSED */ 3841 static int 3842 st_write(dev_t dev, struct uio *uiop, cred_t *cred_p) 3843 { 3844 #ifdef STDEBUG 3845 GET_SOFT_STATE(dev); 3846 ST_ENTR(ST_DEVINFO, st_write); 3847 #endif 3848 return (st_rw(dev, uiop, B_WRITE)); 3849 } 3850 3851 /* 3852 * Due to historical reasons, old limits are: For variable-length devices: 3853 * if greater than 64KB - 1 (ST_MAXRECSIZE_VARIABLE), block into 64 KB - 2 3854 * ST_MAXRECSIZE_VARIABLE_LIMIT) requests; otherwise, 3855 * (let it through unmodified. For fixed-length record devices: 3856 * 63K (ST_MAXRECSIZE_FIXED) is max (default minphys). 3857 * 3858 * The new limits used are un_maxdma (retrieved using scsi_ifgetcap() 3859 * from the HBA) and un_maxbsize (retrieved by sending SCMD_READ_BLKLIM 3860 * command to the drive). 3861 * 3862 */ 3863 static void 3864 st_minphys(struct buf *bp) 3865 { 3866 struct scsi_tape *un; 3867 3868 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 3869 3870 ST_FUNC(ST_DEVINFO, st_minphys); 3871 3872 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3873 "st_minphys(bp = 0x%p): b_bcount = 0x%lx\n", (void *)bp, 3874 bp->b_bcount); 3875 3876 if (un->un_allow_large_xfer) { 3877 3878 /* 3879 * check un_maxbsize for variable length devices only 3880 */ 3881 if (un->un_bsize == 0 && bp->b_bcount > un->un_maxbsize) { 3882 bp->b_bcount = un->un_maxbsize; 3883 } 3884 /* 3885 * can't go more that HBA maxdma limit in either fixed-length 3886 * or variable-length tape drives. 3887 */ 3888 if (bp->b_bcount > un->un_maxdma) { 3889 bp->b_bcount = un->un_maxdma; 3890 } 3891 } else { 3892 3893 /* 3894 * use old fixed limits 3895 */ 3896 if (un->un_bsize == 0) { 3897 if (bp->b_bcount > ST_MAXRECSIZE_VARIABLE) { 3898 bp->b_bcount = ST_MAXRECSIZE_VARIABLE_LIMIT; 3899 } 3900 } else { 3901 if (bp->b_bcount > ST_MAXRECSIZE_FIXED) { 3902 bp->b_bcount = ST_MAXRECSIZE_FIXED; 3903 } 3904 } 3905 } 3906 3907 /* 3908 * For regular raw I/O and Fixed Block length devices, make sure 3909 * the adjusted block count is a whole multiple of the device 3910 * block size. 3911 */ 3912 if (bp != un->un_sbufp && un->un_bsize) { 3913 bp->b_bcount -= (bp->b_bcount % un->un_bsize); 3914 } 3915 } 3916 3917 static int 3918 st_rw(dev_t dev, struct uio *uio, int flag) 3919 { 3920 int rval = 0; 3921 long len; 3922 3923 GET_SOFT_STATE(dev); 3924 3925 ST_FUNC(ST_DEVINFO, st_rw); 3926 3927 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3928 "st_rw(dev = 0x%lx, flag = %s)\n", dev, 3929 (flag == B_READ ? rd_str: wr_str)); 3930 3931 /* get local copy of transfer length */ 3932 len = uio->uio_iov->iov_len; 3933 3934 mutex_enter(ST_MUTEX); 3935 3936 /* 3937 * Clear error entry stack 3938 */ 3939 st_empty_error_stack(un); 3940 3941 /* 3942 * If in fixed block size mode and requested read or write 3943 * is not an even multiple of that block size. 3944 */ 3945 if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) { 3946 scsi_log(ST_DEVINFO, st_label, CE_WARN, 3947 "%s: not modulo %d block size\n", 3948 (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize); 3949 rval = EINVAL; 3950 } 3951 3952 /* If device has set granularity in the READ_BLKLIM we honor it. */ 3953 if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) { 3954 scsi_log(ST_DEVINFO, st_label, CE_WARN, 3955 "%s: not modulo %d device granularity\n", 3956 (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod); 3957 rval = EINVAL; 3958 } 3959 3960 if (st_recov_sz != sizeof (recov_info) && un->un_multipath) { 3961 scsi_log(ST_DEVINFO, st_label, CE_WARN, mp_misconf); 3962 rval = EFAULT; 3963 } 3964 3965 if (rval != 0) { 3966 un->un_errno = rval; 3967 mutex_exit(ST_MUTEX); 3968 return (rval); 3969 } 3970 3971 /* 3972 * Reset this so it can be set if Berkeley and read over a filemark. 3973 */ 3974 un->un_silent_skip = 0; 3975 mutex_exit(ST_MUTEX); 3976 3977 len = uio->uio_resid; 3978 3979 rval = physio(st_queued_strategy, (struct buf *)NULL, 3980 dev, flag, st_minphys, uio); 3981 /* 3982 * if we have hit logical EOT during this xfer and there is not a 3983 * full residue, then set eof back to ST_EOM to make sure that 3984 * the user will see at least one zero write 3985 * after this short write 3986 */ 3987 mutex_enter(ST_MUTEX); 3988 if (un->un_pos.eof > ST_NO_EOF) { 3989 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3990 "eof=%d resid=%lx\n", un->un_pos.eof, uio->uio_resid); 3991 } 3992 if (un->un_pos.eof >= ST_EOM && (flag == B_WRITE)) { 3993 if ((uio->uio_resid != len) && (uio->uio_resid != 0)) { 3994 un->un_pos.eof = ST_EOM; 3995 } else if (uio->uio_resid == len) { 3996 un->un_pos.eof = ST_NO_EOF; 3997 } 3998 } 3999 4000 if (un->un_silent_skip && uio->uio_resid != len) { 4001 un->un_pos.eof = ST_EOF; 4002 un->un_pos.blkno = un->un_save_blkno; 4003 un->un_pos.fileno--; 4004 } 4005 4006 un->un_errno = rval; 4007 4008 mutex_exit(ST_MUTEX); 4009 4010 return (rval); 4011 } 4012 4013 static int 4014 st_arw(dev_t dev, struct aio_req *aio, int flag) 4015 { 4016 struct uio *uio = aio->aio_uio; 4017 int rval = 0; 4018 long len; 4019 4020 GET_SOFT_STATE(dev); 4021 4022 ST_FUNC(ST_DEVINFO, st_arw); 4023 4024 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4025 "st_arw(dev = 0x%lx, flag = %s)\n", dev, 4026 (flag == B_READ ? rd_str: wr_str)); 4027 4028 /* get local copy of transfer length */ 4029 len = uio->uio_iov->iov_len; 4030 4031 mutex_enter(ST_MUTEX); 4032 4033 /* 4034 * If in fixed block size mode and requested read or write 4035 * is not an even multiple of that block size. 4036 */ 4037 if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) { 4038 scsi_log(ST_DEVINFO, st_label, CE_WARN, 4039 "%s: not modulo %d block size\n", 4040 (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize); 4041 rval = EINVAL; 4042 } 4043 4044 /* If device has set granularity in the READ_BLKLIM we honor it. */ 4045 if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) { 4046 scsi_log(ST_DEVINFO, st_label, CE_WARN, 4047 "%s: not modulo %d device granularity\n", 4048 (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod); 4049 rval = EINVAL; 4050 } 4051 4052 if (st_recov_sz != sizeof (recov_info) && un->un_multipath) { 4053 scsi_log(ST_DEVINFO, st_label, CE_WARN, mp_misconf); 4054 rval = EFAULT; 4055 } 4056 4057 if (rval != 0) { 4058 un->un_errno = rval; 4059 mutex_exit(ST_MUTEX); 4060 return (rval); 4061 } 4062 4063 mutex_exit(ST_MUTEX); 4064 4065 len = uio->uio_resid; 4066 4067 rval = 4068 aphysio(st_queued_strategy, anocancel, dev, flag, st_minphys, aio); 4069 4070 /* 4071 * if we have hit logical EOT during this xfer and there is not a 4072 * full residue, then set eof back to ST_EOM to make sure that 4073 * the user will see at least one zero write 4074 * after this short write 4075 * 4076 * we keep this here just in case the application is not using 4077 * persistent errors 4078 */ 4079 mutex_enter(ST_MUTEX); 4080 if (un->un_pos.eof > ST_NO_EOF) { 4081 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4082 "eof=%d resid=%lx\n", un->un_pos.eof, uio->uio_resid); 4083 } 4084 if (un->un_pos.eof >= ST_EOM && (flag == B_WRITE)) { 4085 if ((uio->uio_resid != len) && (uio->uio_resid != 0)) { 4086 un->un_pos.eof = ST_EOM; 4087 } else if (uio->uio_resid == len && 4088 !(un->un_persistence && un->un_persist_errors)) { 4089 un->un_pos.eof = ST_NO_EOF; 4090 } 4091 } 4092 un->un_errno = rval; 4093 mutex_exit(ST_MUTEX); 4094 4095 return (rval); 4096 } 4097 4098 4099 4100 static int 4101 st_queued_strategy(buf_t *bp) 4102 { 4103 struct scsi_tape *un; 4104 char reading = bp->b_flags & B_READ; 4105 int wasopening = 0; 4106 4107 /* 4108 * validate arguments 4109 */ 4110 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 4111 if (un == NULL) { 4112 bp->b_resid = bp->b_bcount; 4113 bioerror(bp, ENXIO); 4114 ST_DEBUG6(NULL, st_label, SCSI_DEBUG, 4115 "st_queued_strategy: ENXIO error exit\n"); 4116 biodone(bp); 4117 return (0); 4118 } 4119 4120 ST_ENTR(ST_DEVINFO, st_queued_strategy); 4121 4122 mutex_enter(ST_MUTEX); 4123 4124 while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 4125 cv_wait(&un->un_suspend_cv, ST_MUTEX); 4126 } 4127 4128 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4129 "st_queued_strategy(): bcount=0x%lx, fileno=%d, blkno=%x, eof=%d\n", 4130 bp->b_bcount, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 4131 4132 /* 4133 * If persistent errors have been flagged, just nix this one. We wait 4134 * for any outstanding I/O's below, so we will be in order. 4135 */ 4136 if (un->un_persistence && un->un_persist_errors) { 4137 goto exit; 4138 } 4139 4140 /* 4141 * If last command was non queued, wait till it finishes. 4142 */ 4143 while (un->un_sbuf_busy) { 4144 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 4145 /* woke up because of an error */ 4146 if (un->un_persistence && un->un_persist_errors) { 4147 goto exit; 4148 } 4149 } 4150 4151 /* 4152 * s_buf and recovery commands shouldn't come here. 4153 */ 4154 ASSERT(bp != un->un_recov_buf); 4155 ASSERT(bp != un->un_sbufp); 4156 4157 /* 4158 * If we haven't done/checked reservation on the tape unit 4159 * do it now. 4160 */ 4161 if ((un->un_rsvd_status & 4162 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 4163 if ((un->un_dp->options & ST_NO_RESERVE_RELEASE) == 0) { 4164 if (st_reserve_release(un, ST_RESERVE, st_uscsi_cmd)) { 4165 st_bioerror(bp, un->un_errno); 4166 goto exit; 4167 } 4168 } else if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4169 /* 4170 * Enter here to restore position for possible 4171 * resets when the device was closed and opened 4172 * in O_NDELAY mode subsequently 4173 */ 4174 un->un_state = ST_STATE_INITIALIZING; 4175 (void) st_cmd(un, SCMD_TEST_UNIT_READY, 4176 0, SYNC_CMD); 4177 un->un_state = ST_STATE_OPEN_PENDING_IO; 4178 } 4179 un->un_rsvd_status |= ST_INIT_RESERVE; 4180 } 4181 4182 /* 4183 * If we are offline, we have to initialize everything first. 4184 * This is to handle either when opened with O_NDELAY, or 4185 * we just got a new tape in the drive, after an offline. 4186 * We don't observe O_NDELAY past the open, 4187 * as it will not make sense for tapes. 4188 */ 4189 if (un->un_state == ST_STATE_OFFLINE || un->un_restore_pos) { 4190 /* 4191 * reset state to avoid recursion 4192 */ 4193 un->un_laststate = un->un_state; 4194 un->un_state = ST_STATE_INITIALIZING; 4195 if (st_tape_init(un)) { 4196 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4197 "stioctl : OFFLINE init failure "); 4198 un->un_state = ST_STATE_OFFLINE; 4199 un->un_pos.pmode = invalid; 4200 goto b_done_err; 4201 } 4202 /* un_restore_pos make invalid */ 4203 un->un_state = ST_STATE_OPEN_PENDING_IO; 4204 un->un_restore_pos = 0; 4205 } 4206 /* 4207 * Check for legal operations 4208 */ 4209 if (un->un_pos.pmode == invalid) { 4210 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4211 "strategy with un->un_pos.pmode invalid\n"); 4212 goto b_done_err; 4213 } 4214 4215 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4216 "st_queued_strategy(): regular io\n"); 4217 4218 /* 4219 * Process this first. If we were reading, and we're pending 4220 * logical eot, that means we've bumped one file mark too far. 4221 */ 4222 4223 /* 4224 * Recursion warning: st_cmd will route back through here. 4225 * Not anymore st_cmd will go through st_strategy()! 4226 */ 4227 if (un->un_pos.eof == ST_EOT_PENDING) { 4228 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 4229 un->un_pos.pmode = invalid; 4230 un->un_density_known = 0; 4231 goto b_done_err; 4232 } 4233 un->un_pos.blkno = 0; /* fix up block number.. */ 4234 un->un_pos.eof = ST_EOT; 4235 } 4236 4237 /* 4238 * If we are in the process of opening, we may have to 4239 * determine/set the correct density. We also may have 4240 * to do a test_append (if QIC) to see whether we are 4241 * in a position to append to the end of the tape. 4242 * 4243 * If we're already at logical eot, we transition 4244 * to ST_NO_EOF. If we're at physical eot, we punt 4245 * to the switch statement below to handle. 4246 */ 4247 if ((un->un_state == ST_STATE_OPEN_PENDING_IO) || 4248 (un->un_test_append && (un->un_dp->options & ST_QIC))) { 4249 4250 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4251 if (st_determine_density(un, (int)reading)) { 4252 goto b_done_err; 4253 } 4254 } 4255 4256 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4257 "pending_io@fileno %d rw %d qic %d eof %d\n", 4258 un->un_pos.fileno, (int)reading, 4259 (un->un_dp->options & ST_QIC) ? 1 : 0, 4260 un->un_pos.eof); 4261 4262 if (!reading && un->un_pos.eof != ST_EOM) { 4263 if (un->un_pos.eof == ST_EOT) { 4264 un->un_pos.eof = ST_NO_EOF; 4265 } else if (un->un_pos.pmode != invalid && 4266 (un->un_dp->options & ST_QIC)) { 4267 /* 4268 * st_test_append() will do it all 4269 */ 4270 st_test_append(bp); 4271 mutex_exit(ST_MUTEX); 4272 return (0); 4273 } 4274 } 4275 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4276 wasopening = 1; 4277 } 4278 un->un_laststate = un->un_state; 4279 un->un_state = ST_STATE_OPEN; 4280 } 4281 4282 4283 /* 4284 * Process rest of END OF FILE and END OF TAPE conditions 4285 */ 4286 4287 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4288 "eof=%x, wasopening=%x\n", 4289 un->un_pos.eof, wasopening); 4290 4291 switch (un->un_pos.eof) { 4292 case ST_EOM: 4293 /* 4294 * This allows writes to proceed past physical 4295 * eot. We'll *really* be in trouble if the 4296 * user continues blindly writing data too 4297 * much past this point (unwind the tape). 4298 * Physical eot really means 'early warning 4299 * eot' in this context. 4300 * 4301 * Every other write from now on will succeed 4302 * (if sufficient tape left). 4303 * This write will return with resid == count 4304 * but the next one should be successful 4305 * 4306 * Note that we only transition to logical EOT 4307 * if the last state wasn't the OPENING state. 4308 * We explicitly prohibit running up to physical 4309 * eot, closing the device, and then re-opening 4310 * to proceed. Trailer records may only be gotten 4311 * at by keeping the tape open after hitting eot. 4312 * 4313 * Also note that ST_EOM cannot be set by reading- 4314 * this can only be set during writing. Reading 4315 * up to the end of the tape gets a blank check 4316 * or a double-filemark indication (ST_EOT_PENDING), 4317 * and we prohibit reading after that point. 4318 * 4319 */ 4320 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOM\n"); 4321 if (wasopening == 0) { 4322 /* 4323 * this allows st_rw() to reset it back to 4324 * will see a zero write 4325 */ 4326 un->un_pos.eof = ST_WRITE_AFTER_EOM; 4327 } 4328 un->un_status = SUN_KEY_EOT; 4329 goto b_done; 4330 4331 case ST_WRITE_AFTER_EOM: 4332 case ST_EOT: 4333 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOT\n"); 4334 un->un_status = SUN_KEY_EOT; 4335 if (SVR4_BEHAVIOR && reading) { 4336 goto b_done_err; 4337 } 4338 4339 if (reading) { 4340 goto b_done; 4341 } 4342 un->un_pos.eof = ST_NO_EOF; 4343 break; 4344 4345 case ST_EOF_PENDING: 4346 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4347 "EOF PENDING\n"); 4348 un->un_status = SUN_KEY_EOF; 4349 if (SVR4_BEHAVIOR) { 4350 un->un_pos.eof = ST_EOF; 4351 goto b_done; 4352 } 4353 /* FALLTHROUGH */ 4354 case ST_EOF: 4355 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOF\n"); 4356 un->un_status = SUN_KEY_EOF; 4357 if (SVR4_BEHAVIOR) { 4358 goto b_done_err; 4359 } 4360 4361 if (BSD_BEHAVIOR) { 4362 un->un_pos.eof = ST_NO_EOF; 4363 un->un_pos.fileno += 1; 4364 un->un_pos.blkno = 0; 4365 } 4366 4367 if (reading) { 4368 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4369 "now file %d (read)\n", 4370 un->un_pos.fileno); 4371 goto b_done; 4372 } 4373 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4374 "now file %d (write)\n", un->un_pos.fileno); 4375 break; 4376 default: 4377 un->un_status = 0; 4378 break; 4379 } 4380 4381 bp->b_flags &= ~(B_DONE); 4382 st_bioerror(bp, 0); 4383 bp->av_forw = NULL; 4384 bp->b_resid = 0; 4385 SET_BP_PKT(bp, 0); 4386 4387 4388 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4389 "st_queued_strategy: cmd=0x%p count=%ld resid=%ld flags=0x%x" 4390 " pkt=0x%p\n", 4391 (void *)bp->b_forw, bp->b_bcount, 4392 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 4393 4394 #ifdef __x86 4395 /* 4396 * We will replace bp with a new bp that can do big blk xfer 4397 * if the requested xfer size is bigger than un->un_maxdma_arch 4398 * 4399 * Also, we need to make sure that we're handling real I/O 4400 * by checking group 0/1 SCSI I/O commands, if needed 4401 */ 4402 if (bp->b_bcount > un->un_maxdma_arch && 4403 ((uchar_t)(uintptr_t)bp->b_forw == SCMD_READ || 4404 (uchar_t)(uintptr_t)bp->b_forw == SCMD_READ_G4 || 4405 (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE || 4406 (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE_G4)) { 4407 mutex_exit(ST_MUTEX); 4408 bp = st_get_bigblk_bp(bp); 4409 mutex_enter(ST_MUTEX); 4410 } 4411 #endif 4412 4413 /* put on wait queue */ 4414 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4415 "st_queued_strategy: un->un_quef = 0x%p, bp = 0x%p\n", 4416 (void *)un->un_quef, (void *)bp); 4417 4418 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quel, bp); 4419 4420 ST_DO_KSTATS(bp, kstat_waitq_enter); 4421 4422 st_start(un); 4423 4424 mutex_exit(ST_MUTEX); 4425 return (0); 4426 4427 b_done_err: 4428 st_bioerror(bp, EIO); 4429 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4430 "st_queued_strategy : EIO b_done_err\n"); 4431 4432 b_done: 4433 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4434 "st_queued_strategy: b_done\n"); 4435 4436 exit: 4437 /* 4438 * make sure no commands are outstanding or waiting before closing, 4439 * so we can guarantee order 4440 */ 4441 st_wait_for_io(un); 4442 un->un_err_resid = bp->b_resid = bp->b_bcount; 4443 4444 /* override errno here, if persistent errors were flagged */ 4445 if (un->un_persistence && un->un_persist_errors) 4446 bioerror(bp, un->un_errno); 4447 4448 mutex_exit(ST_MUTEX); 4449 4450 biodone(bp); 4451 ASSERT(mutex_owned(ST_MUTEX) == 0); 4452 return (0); 4453 } 4454 4455 4456 static int 4457 st_strategy(struct buf *bp) 4458 { 4459 struct scsi_tape *un; 4460 4461 /* 4462 * validate arguments 4463 */ 4464 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 4465 if (un == NULL) { 4466 bp->b_resid = bp->b_bcount; 4467 bioerror(bp, ENXIO); 4468 ST_DEBUG6(NULL, st_label, SCSI_DEBUG, 4469 "st_strategy: ENXIO error exit\n"); 4470 4471 biodone(bp); 4472 return (0); 4473 4474 } 4475 4476 ST_ENTR(ST_DEVINFO, st_strategy); 4477 4478 mutex_enter(ST_MUTEX); 4479 4480 while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 4481 cv_wait(&un->un_suspend_cv, ST_MUTEX); 4482 } 4483 4484 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4485 "st_strategy(): bcount=0x%lx, fileno=%d, blkno=%x, eof=%d\n", 4486 bp->b_bcount, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 4487 4488 ASSERT((bp == un->un_recov_buf) || (bp == un->un_sbufp)); 4489 4490 bp->b_flags &= ~(B_DONE); 4491 st_bioerror(bp, 0); 4492 bp->av_forw = NULL; 4493 bp->b_resid = 0; 4494 SET_BP_PKT(bp, 0); 4495 4496 4497 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4498 "st_strategy: cmd=0x%x count=%ld resid=%ld flags=0x%x" 4499 " pkt=0x%p\n", 4500 (unsigned char)(uintptr_t)bp->b_forw, bp->b_bcount, 4501 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 4502 ST_DO_KSTATS(bp, kstat_waitq_enter); 4503 4504 st_start(un); 4505 4506 mutex_exit(ST_MUTEX); 4507 return (0); 4508 } 4509 4510 /* 4511 * this routine spaces forward over filemarks 4512 */ 4513 static int 4514 st_space_fmks(struct scsi_tape *un, int64_t count) 4515 { 4516 int rval = 0; 4517 4518 ST_FUNC(ST_DEVINFO, st_space_fmks); 4519 4520 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4521 "st_space_fmks(dev = 0x%lx, count = %"PRIx64")\n", 4522 un->un_dev, count); 4523 4524 ASSERT(mutex_owned(ST_MUTEX)); 4525 4526 /* 4527 * the risk with doing only one space operation is that we 4528 * may accidentily jump in old data 4529 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD 4530 * because the 8200 does not append a marker; in order not to 4531 * sacrifice the fast file skip, we do a slow skip if the low 4532 * density device has been opened 4533 */ 4534 4535 if ((un->un_dp->options & ST_KNOWS_EOD) && 4536 !((un->un_dp->type == ST_TYPE_EXB8500 && 4537 MT_DENSITY(un->un_dev) == 0))) { 4538 if (st_cmd(un, SCMD_SPACE, Fmk(count), SYNC_CMD)) { 4539 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4540 "space_fmks : EIO can't do space cmd #1\n"); 4541 rval = EIO; 4542 } 4543 } else { 4544 while (count > 0) { 4545 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 4546 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4547 "space_fmks : EIO can't do space cmd #2\n"); 4548 rval = EIO; 4549 break; 4550 } 4551 count -= 1; 4552 /* 4553 * read a block to see if we have reached 4554 * end of medium (double filemark for reel or 4555 * medium error for others) 4556 */ 4557 if (count > 0) { 4558 if (st_cmd(un, SCMD_SPACE, Blk(1), SYNC_CMD)) { 4559 ST_DEBUG2(ST_DEVINFO, st_label, 4560 SCSI_DEBUG, 4561 "space_fmks : EIO can't do " 4562 "space cmd #3\n"); 4563 rval = EIO; 4564 break; 4565 } 4566 if ((un->un_pos.eof >= ST_EOF_PENDING) && 4567 (un->un_dp->options & ST_REEL)) { 4568 un->un_status = SUN_KEY_EOT; 4569 ST_DEBUG2(ST_DEVINFO, st_label, 4570 SCSI_DEBUG, 4571 "space_fmks : EIO ST_REEL\n"); 4572 rval = EIO; 4573 break; 4574 } else if (IN_EOF(un->un_pos)) { 4575 un->un_pos.eof = ST_NO_EOF; 4576 un->un_pos.fileno++; 4577 un->un_pos.blkno = 0; 4578 count--; 4579 } else if (un->un_pos.eof > ST_EOF) { 4580 ST_DEBUG2(ST_DEVINFO, st_label, 4581 SCSI_DEBUG, 4582 "space_fmks, EIO > ST_EOF\n"); 4583 rval = EIO; 4584 break; 4585 } 4586 4587 } 4588 } 4589 un->un_err_resid = count; 4590 COPY_POS(&un->un_pos, &un->un_err_pos); 4591 } 4592 ASSERT(mutex_owned(ST_MUTEX)); 4593 return (rval); 4594 } 4595 4596 /* 4597 * this routine spaces to EOD 4598 * 4599 * it keeps track of the current filenumber and returns the filenumber after 4600 * the last successful space operation, we keep the number high because as 4601 * tapes are getting larger, the possibility of more and more files exist, 4602 * 0x100000 (1 Meg of files) probably will never have to be changed any time 4603 * soon 4604 */ 4605 #define MAX_SKIP 0x100000 /* somewhat arbitrary */ 4606 4607 static int 4608 st_find_eod(struct scsi_tape *un) 4609 { 4610 tapepos_t savepos; 4611 int64_t sp_type; 4612 int result; 4613 4614 if (un == NULL) { 4615 return (-1); 4616 } 4617 4618 ST_FUNC(ST_DEVINFO, st_find_eod); 4619 4620 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4621 "st_find_eod(dev = 0x%lx): fileno = %d\n", un->un_dev, 4622 un->un_pos.fileno); 4623 4624 ASSERT(mutex_owned(ST_MUTEX)); 4625 4626 COPY_POS(&savepos, &un->un_pos); 4627 4628 /* 4629 * see if the drive is smart enough to do the skips in 4630 * one operation; 1/2" use two filemarks 4631 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD 4632 * because the 8200 does not append a marker; in order not to 4633 * sacrifice the fast file skip, we do a slow skip if the low 4634 * density device has been opened 4635 */ 4636 if ((un->un_dp->options & ST_KNOWS_EOD) != 0) { 4637 if ((un->un_dp->type == ST_TYPE_EXB8500) && 4638 (MT_DENSITY(un->un_dev) == 0)) { 4639 sp_type = Fmk(1); 4640 } else if (un->un_pos.pmode == logical) { 4641 sp_type = SPACE(SP_EOD, 0); 4642 } else { 4643 sp_type = Fmk(MAX_SKIP); 4644 } 4645 } else { 4646 sp_type = Fmk(1); 4647 } 4648 4649 for (;;) { 4650 result = st_cmd(un, SCMD_SPACE, sp_type, SYNC_CMD); 4651 4652 if (result == 0) { 4653 COPY_POS(&savepos, &un->un_pos); 4654 } 4655 4656 if (sp_type == SPACE(SP_EOD, 0)) { 4657 if (result != 0) { 4658 sp_type = Fmk(MAX_SKIP); 4659 continue; 4660 } 4661 4662 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4663 "st_find_eod: 0x%"PRIx64"\n", 4664 savepos.lgclblkno); 4665 /* 4666 * What we return will become the current file position. 4667 * After completing the space command with the position 4668 * mode that is not invalid a read position command will 4669 * be automaticly issued. If the drive support the long 4670 * read position format a valid file position can be 4671 * returned. 4672 */ 4673 return (un->un_pos.fileno); 4674 } 4675 4676 if (result != 0) { 4677 break; 4678 } 4679 4680 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4681 "count=%"PRIx64", eof=%x, status=%x\n", 4682 SPACE_CNT(sp_type), un->un_pos.eof, un->un_status); 4683 4684 /* 4685 * If we're not EOM smart, space a record 4686 * to see whether we're now in the slot between 4687 * the two sequential filemarks that logical 4688 * EOM consists of (REEL) or hit nowhere land 4689 * (8mm). 4690 */ 4691 if (sp_type == Fmk(1)) { 4692 /* 4693 * no fast skipping, check a record 4694 */ 4695 if (st_cmd(un, SCMD_SPACE, Blk((1)), SYNC_CMD)) { 4696 break; 4697 } 4698 if ((un->un_pos.eof >= ST_EOF_PENDING) && 4699 (un->un_dp->options & ST_REEL)) { 4700 un->un_status = KEY_BLANK_CHECK; 4701 un->un_pos.fileno++; 4702 un->un_pos.blkno = 0; 4703 break; 4704 } 4705 if (IN_EOF(un->un_pos)) { 4706 un->un_pos.eof = ST_NO_EOF; 4707 un->un_pos.fileno++; 4708 un->un_pos.blkno = 0; 4709 } 4710 if (un->un_pos.eof > ST_EOF) { 4711 break; 4712 } 4713 } else { 4714 if (un->un_pos.eof > ST_EOF) { 4715 break; 4716 } 4717 } 4718 } 4719 4720 if (un->un_dp->options & ST_KNOWS_EOD) { 4721 COPY_POS(&savepos, &un->un_pos); 4722 } 4723 4724 ASSERT(mutex_owned(ST_MUTEX)); 4725 4726 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4727 "st_find_eod: %x\n", savepos.fileno); 4728 return (savepos.fileno); 4729 } 4730 4731 4732 /* 4733 * this routine is frequently used in ioctls below; 4734 * it determines whether we know the density and if not will 4735 * determine it 4736 * if we have written the tape before, one or more filemarks are written 4737 * 4738 * depending on the stepflag, the head is repositioned to where it was before 4739 * the filemarks were written in order not to confuse step counts 4740 */ 4741 #define STEPBACK 0 4742 #define NO_STEPBACK 1 4743 4744 static int 4745 st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag) 4746 { 4747 4748 GET_SOFT_STATE(dev); 4749 4750 ST_FUNC(ST_DEVINFO, st_check_density_or_wfm); 4751 4752 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4753 "st_check_density_or_wfm(dev= 0x%lx, wfm= %d, mode= %d, stpflg= %d)" 4754 "\n", dev, wfm, mode, stepflag); 4755 4756 ASSERT(mutex_owned(ST_MUTEX)); 4757 4758 /* 4759 * If we don't yet know the density of the tape we have inserted, 4760 * we have to either unconditionally set it (if we're 'writing'), 4761 * or we have to determine it. As side effects, check for any 4762 * write-protect errors, and for the need to put out any file-marks 4763 * before positioning a tape. 4764 * 4765 * If we are going to be spacing forward, and we haven't determined 4766 * the tape density yet, we have to do so now... 4767 */ 4768 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4769 if (st_determine_density(un, mode)) { 4770 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4771 "check_density_or_wfm : EIO can't determine " 4772 "density\n"); 4773 un->un_errno = EIO; 4774 return (EIO); 4775 } 4776 /* 4777 * Presumably we are at BOT. If we attempt to write, it will 4778 * either work okay, or bomb. We don't do a st_test_append 4779 * unless we're past BOT. 4780 */ 4781 un->un_laststate = un->un_state; 4782 un->un_state = ST_STATE_OPEN; 4783 4784 } else if (un->un_pos.pmode != invalid && un->un_fmneeded > 0 && 4785 ((un->un_lastop == ST_OP_WEOF && wfm) || 4786 (un->un_lastop == ST_OP_WRITE && wfm))) { 4787 4788 tapepos_t spos; 4789 4790 COPY_POS(&spos, &un->un_pos); 4791 4792 /* 4793 * We need to write one or two filemarks. 4794 * In the case of the HP, we need to 4795 * position the head between the two 4796 * marks. 4797 */ 4798 if ((un->un_fmneeded > 0) || (un->un_lastop == ST_OP_WEOF)) { 4799 wfm = un->un_fmneeded; 4800 un->un_fmneeded = 0; 4801 } 4802 4803 if (st_write_fm(dev, wfm)) { 4804 un->un_pos.pmode = invalid; 4805 un->un_density_known = 0; 4806 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4807 "check_density_or_wfm : EIO can't write fm\n"); 4808 un->un_errno = EIO; 4809 return (EIO); 4810 } 4811 4812 if (stepflag == STEPBACK) { 4813 if (st_cmd(un, SCMD_SPACE, Fmk(-wfm), SYNC_CMD)) { 4814 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4815 "check_density_or_wfm : EIO can't space " 4816 "(-wfm)\n"); 4817 un->un_errno = EIO; 4818 return (EIO); 4819 } 4820 COPY_POS(&un->un_pos, &spos); 4821 } 4822 } 4823 4824 /* 4825 * Whatever we do at this point clears the state of the eof flag. 4826 */ 4827 4828 un->un_pos.eof = ST_NO_EOF; 4829 4830 /* 4831 * If writing, let's check that we're positioned correctly 4832 * at the end of tape before issuing the next write. 4833 */ 4834 if (un->un_read_only == RDWR) { 4835 un->un_test_append = 1; 4836 } 4837 4838 ASSERT(mutex_owned(ST_MUTEX)); 4839 return (0); 4840 } 4841 4842 4843 /* 4844 * Wait for all outstaning I/O's to complete 4845 * 4846 * we wait on both ncmds and the wait queue for times when we are flushing 4847 * after persistent errors are flagged, which is when ncmds can be 0, and the 4848 * queue can still have I/O's. This way we preserve order of biodone's. 4849 */ 4850 static void 4851 st_wait_for_io(struct scsi_tape *un) 4852 { 4853 ST_FUNC(ST_DEVINFO, st_wait_for_io); 4854 ASSERT(mutex_owned(ST_MUTEX)); 4855 while ((un->un_ncmds) || (un->un_quef) || (un->un_runqf)) { 4856 cv_wait(&un->un_queue_cv, ST_MUTEX); 4857 } 4858 } 4859 4860 /* 4861 * This routine implements the ioctl calls. It is called 4862 * from the device switch at normal priority. 4863 */ 4864 /*ARGSUSED*/ 4865 static int 4866 st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p, 4867 int *rval_p) 4868 { 4869 int tmp, rval = 0; 4870 4871 GET_SOFT_STATE(dev); 4872 4873 ST_ENTR(ST_DEVINFO, st_ioctl); 4874 4875 mutex_enter(ST_MUTEX); 4876 4877 ASSERT(un->un_recov_buf_busy == 0); 4878 4879 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4880 "st_ioctl(): fileno=%x, blkno=%x, eof=%x, state = %d, " 4881 "pe_flag = %d\n", 4882 un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof, un->un_state, 4883 un->un_persistence && un->un_persist_errors); 4884 4885 /* 4886 * We don't want to block on these, so let them through 4887 * and we don't care about setting driver states here. 4888 */ 4889 if ((cmd == MTIOCGETDRIVETYPE) || 4890 (cmd == MTIOCGUARANTEEDORDER) || 4891 (cmd == MTIOCPERSISTENTSTATUS)) { 4892 goto check_commands; 4893 } 4894 4895 /* 4896 * We clear error entry stack except command 4897 * MTIOCGETERROR and MTIOCGET 4898 */ 4899 if ((cmd != MTIOCGETERROR) && 4900 (cmd != MTIOCGET)) { 4901 st_empty_error_stack(un); 4902 } 4903 4904 /* 4905 * wait for all outstanding commands to complete, or be dequeued. 4906 * And because ioctl's are synchronous commands, any return value 4907 * after this, will be in order 4908 */ 4909 st_wait_for_io(un); 4910 4911 /* 4912 * allow only a through clear errors and persistent status, and 4913 * status 4914 */ 4915 if (un->un_persistence && un->un_persist_errors) { 4916 if ((cmd == MTIOCLRERR) || 4917 (cmd == MTIOCPERSISTENT) || 4918 (cmd == MTIOCGET)) { 4919 goto check_commands; 4920 } else { 4921 rval = un->un_errno; 4922 goto exit; 4923 } 4924 } 4925 4926 ASSERT(un->un_throttle != 0); 4927 un->un_throttle = 1; /* > 1 will never happen here */ 4928 un->un_errno = 0; /* start clean from here */ 4929 4930 /* 4931 * first and foremost, handle any ST_EOT_PENDING cases. 4932 * That is, if a logical eot is pending notice, notice it. 4933 */ 4934 if (un->un_pos.eof == ST_EOT_PENDING) { 4935 int resid = un->un_err_resid; 4936 uchar_t status = un->un_status; 4937 uchar_t lastop = un->un_lastop; 4938 4939 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 4940 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4941 "stioctl : EIO can't space fmk(-1)\n"); 4942 rval = EIO; 4943 goto exit; 4944 } 4945 un->un_lastop = lastop; /* restore last operation */ 4946 if (status == SUN_KEY_EOF) { 4947 un->un_status = SUN_KEY_EOT; 4948 } else { 4949 un->un_status = status; 4950 } 4951 un->un_err_resid = resid; 4952 /* fix up block number */ 4953 un->un_err_pos.blkno = un->un_pos.blkno = 0; 4954 /* now we're at logical eot */ 4955 un->un_pos.eof = ST_EOT; 4956 } 4957 4958 /* 4959 * now, handle the rest of the situations 4960 */ 4961 check_commands: 4962 switch (cmd) { 4963 case MTIOCGET: 4964 { 4965 #ifdef _MULTI_DATAMODEL 4966 /* 4967 * For use when a 32 bit app makes a call into a 4968 * 64 bit ioctl 4969 */ 4970 struct mtget32 mtg_local32; 4971 struct mtget32 *mtget_32 = &mtg_local32; 4972 #endif /* _MULTI_DATAMODEL */ 4973 4974 /* Get tape status */ 4975 struct mtget mtg_local; 4976 struct mtget *mtget = &mtg_local; 4977 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 4978 "st_ioctl: MTIOCGET\n"); 4979 4980 bzero((caddr_t)mtget, sizeof (struct mtget)); 4981 mtget->mt_erreg = un->un_status; 4982 mtget->mt_resid = un->un_err_resid; 4983 mtget->mt_dsreg = un->un_retry_ct; 4984 if (un->un_err_pos.pmode == legacy) { 4985 mtget->mt_fileno = un->un_err_pos.fileno; 4986 } else { 4987 mtget->mt_fileno = -1; 4988 } 4989 /* 4990 * If the value is positive fine. 4991 * If its negative we need to return a value based on the 4992 * old way if counting backwards from INF (1,000,000,000). 4993 */ 4994 if (un->un_err_pos.blkno >= 0) { 4995 mtget->mt_blkno = un->un_err_pos.blkno; 4996 } else { 4997 mtget->mt_blkno = INF + 1 - (-un->un_err_pos.blkno); 4998 } 4999 mtget->mt_type = un->un_dp->type; 5000 mtget->mt_flags = MTF_SCSI | MTF_ASF; 5001 if (un->un_read_pos_type != NO_POS) { 5002 mtget->mt_flags |= MTF_LOGICAL_BLOCK; 5003 } 5004 if (un->un_dp->options & ST_REEL) { 5005 mtget->mt_flags |= MTF_REEL; 5006 mtget->mt_bf = 20; 5007 } else { /* 1/4" cartridges */ 5008 switch (mtget->mt_type) { 5009 /* Emulex cartridge tape */ 5010 case MT_ISMT02: 5011 mtget->mt_bf = 40; 5012 break; 5013 default: 5014 mtget->mt_bf = 126; 5015 break; 5016 } 5017 } 5018 5019 /* 5020 * If large transfers are allowed and drive options 5021 * has no record size limit set. Calculate blocking 5022 * factor from the lesser of maxbsize and maxdma. 5023 */ 5024 if ((un->un_allow_large_xfer) && 5025 (un->un_dp->options & ST_NO_RECSIZE_LIMIT)) { 5026 mtget->mt_bf = min(un->un_maxbsize, 5027 un->un_maxdma) / SECSIZE; 5028 } 5029 5030 if (un->un_read_only == WORM || 5031 un->un_read_only == RDWORM) { 5032 mtget->mt_flags |= MTF_WORM_MEDIA; 5033 } 5034 5035 /* 5036 * In persistent error mode sending a non-queued can hang 5037 * because this ioctl gets to be run without turning off 5038 * persistense. Fake the answer based on previous info. 5039 */ 5040 if (un->un_persistence) { 5041 rval = 0; 5042 } else { 5043 rval = st_check_clean_bit(un); 5044 } 5045 if (rval == 0) { 5046 /* 5047 * If zero is returned or in persistent mode, 5048 * use the old data. 5049 */ 5050 if ((un->un_HeadClean & (TAPE_ALERT_SUPPORTED | 5051 TAPE_SEQUENTIAL_SUPPORTED|TAPE_ALERT_NOT_SUPPORTED)) 5052 != TAPE_ALERT_NOT_SUPPORTED) { 5053 mtget->mt_flags |= MTF_TAPE_CLN_SUPPORTED; 5054 } 5055 if (un->un_HeadClean & (TAPE_PREVIOUSLY_DIRTY | 5056 TAPE_ALERT_STILL_DIRTY)) { 5057 mtget->mt_flags |= MTF_TAPE_HEAD_DIRTY; 5058 } 5059 } else { 5060 mtget->mt_flags |= (ushort_t)rval; 5061 rval = 0; 5062 } 5063 5064 un->un_status = 0; /* Reset status */ 5065 un->un_err_resid = 0; 5066 tmp = sizeof (struct mtget); 5067 5068 #ifdef _MULTI_DATAMODEL 5069 5070 switch (ddi_model_convert_from(flag & FMODELS)) { 5071 case DDI_MODEL_ILP32: 5072 /* 5073 * Convert 64 bit back to 32 bit before doing 5074 * copyout. This is what the ILP32 app expects. 5075 */ 5076 mtget_32->mt_erreg = mtget->mt_erreg; 5077 mtget_32->mt_resid = mtget->mt_resid; 5078 mtget_32->mt_dsreg = mtget->mt_dsreg; 5079 mtget_32->mt_fileno = (daddr32_t)mtget->mt_fileno; 5080 mtget_32->mt_blkno = (daddr32_t)mtget->mt_blkno; 5081 mtget_32->mt_type = mtget->mt_type; 5082 mtget_32->mt_flags = mtget->mt_flags; 5083 mtget_32->mt_bf = mtget->mt_bf; 5084 5085 if (ddi_copyout(mtget_32, (void *)arg, 5086 sizeof (struct mtget32), flag)) { 5087 rval = EFAULT; 5088 } 5089 break; 5090 5091 case DDI_MODEL_NONE: 5092 if (ddi_copyout(mtget, (void *)arg, tmp, flag)) { 5093 rval = EFAULT; 5094 } 5095 break; 5096 } 5097 #else /* ! _MULTI_DATAMODE */ 5098 if (ddi_copyout(mtget, (void *)arg, tmp, flag)) { 5099 rval = EFAULT; 5100 } 5101 #endif /* _MULTI_DATAMODE */ 5102 5103 break; 5104 } 5105 case MTIOCGETERROR: 5106 /* 5107 * get error entry from error stack 5108 */ 5109 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5110 "st_ioctl: MTIOCGETERROR\n"); 5111 5112 rval = st_get_error_entry(un, arg, flag); 5113 5114 break; 5115 5116 case MTIOCSTATE: 5117 { 5118 /* 5119 * return when media presence matches state 5120 */ 5121 enum mtio_state state; 5122 5123 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5124 "st_ioctl: MTIOCSTATE\n"); 5125 5126 if (ddi_copyin((void *)arg, &state, sizeof (int), flag)) 5127 rval = EFAULT; 5128 5129 mutex_exit(ST_MUTEX); 5130 5131 rval = st_check_media(dev, state); 5132 5133 mutex_enter(ST_MUTEX); 5134 5135 if (rval != 0) { 5136 break; 5137 } 5138 5139 if (ddi_copyout(&un->un_mediastate, (void *)arg, 5140 sizeof (int), flag)) 5141 rval = EFAULT; 5142 break; 5143 5144 } 5145 5146 case MTIOCGETDRIVETYPE: 5147 { 5148 #ifdef _MULTI_DATAMODEL 5149 /* 5150 * For use when a 32 bit app makes a call into a 5151 * 64 bit ioctl 5152 */ 5153 struct mtdrivetype_request32 mtdtrq32; 5154 #endif /* _MULTI_DATAMODEL */ 5155 5156 /* 5157 * return mtdrivetype 5158 */ 5159 struct mtdrivetype_request mtdtrq; 5160 struct mtdrivetype mtdrtyp; 5161 struct mtdrivetype *mtdt = &mtdrtyp; 5162 struct st_drivetype *stdt = un->un_dp; 5163 5164 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5165 "st_ioctl: MTIOCGETDRIVETYPE\n"); 5166 5167 #ifdef _MULTI_DATAMODEL 5168 switch (ddi_model_convert_from(flag & FMODELS)) { 5169 case DDI_MODEL_ILP32: 5170 { 5171 if (ddi_copyin((void *)arg, &mtdtrq32, 5172 sizeof (struct mtdrivetype_request32), flag)) { 5173 rval = EFAULT; 5174 break; 5175 } 5176 mtdtrq.size = mtdtrq32.size; 5177 mtdtrq.mtdtp = 5178 (struct mtdrivetype *)(uintptr_t)mtdtrq32.mtdtp; 5179 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5180 "st_ioctl: size 0x%x\n", mtdtrq.size); 5181 break; 5182 } 5183 case DDI_MODEL_NONE: 5184 if (ddi_copyin((void *)arg, &mtdtrq, 5185 sizeof (struct mtdrivetype_request), flag)) { 5186 rval = EFAULT; 5187 break; 5188 } 5189 break; 5190 } 5191 5192 #else /* ! _MULTI_DATAMODEL */ 5193 if (ddi_copyin((void *)arg, &mtdtrq, 5194 sizeof (struct mtdrivetype_request), flag)) { 5195 rval = EFAULT; 5196 break; 5197 } 5198 #endif /* _MULTI_DATAMODEL */ 5199 5200 /* 5201 * if requested size is < 0 then return 5202 * error. 5203 */ 5204 if (mtdtrq.size < 0) { 5205 rval = EINVAL; 5206 break; 5207 } 5208 bzero(mtdt, sizeof (struct mtdrivetype)); 5209 (void) strncpy(mtdt->name, stdt->name, ST_NAMESIZE); 5210 (void) strncpy(mtdt->vid, stdt->vid, VIDPIDLEN - 1); 5211 mtdt->type = stdt->type; 5212 mtdt->bsize = stdt->bsize; 5213 mtdt->options = stdt->options; 5214 mtdt->max_rretries = stdt->max_rretries; 5215 mtdt->max_wretries = stdt->max_wretries; 5216 for (tmp = 0; tmp < NDENSITIES; tmp++) { 5217 mtdt->densities[tmp] = stdt->densities[tmp]; 5218 } 5219 mtdt->default_density = stdt->default_density; 5220 /* 5221 * Speed hasn't been used since the hayday of reel tape. 5222 * For all drives not setting the option ST_KNOWS_MEDIA 5223 * the speed member renamed to mediatype are zeros. 5224 * Those drives that have ST_KNOWS_MEDIA set use the 5225 * new mediatype member which is used to figure the 5226 * type of media loaded. 5227 * 5228 * So as to not break applications speed in the 5229 * mtdrivetype structure is not renamed. 5230 */ 5231 for (tmp = 0; tmp < NDENSITIES; tmp++) { 5232 mtdt->speeds[tmp] = stdt->mediatype[tmp]; 5233 } 5234 mtdt->non_motion_timeout = stdt->non_motion_timeout; 5235 mtdt->io_timeout = stdt->io_timeout; 5236 mtdt->rewind_timeout = stdt->rewind_timeout; 5237 mtdt->space_timeout = stdt->space_timeout; 5238 mtdt->load_timeout = stdt->load_timeout; 5239 mtdt->unload_timeout = stdt->unload_timeout; 5240 mtdt->erase_timeout = stdt->erase_timeout; 5241 5242 /* 5243 * Limit the maximum length of the result to 5244 * sizeof (struct mtdrivetype). 5245 */ 5246 tmp = sizeof (struct mtdrivetype); 5247 if (mtdtrq.size < tmp) 5248 tmp = mtdtrq.size; 5249 if (ddi_copyout(mtdt, mtdtrq.mtdtp, tmp, flag)) { 5250 rval = EFAULT; 5251 } 5252 break; 5253 } 5254 case MTIOCPERSISTENT: 5255 5256 if (ddi_copyin((void *)arg, &tmp, sizeof (tmp), flag)) { 5257 rval = EFAULT; 5258 break; 5259 } 5260 5261 if (tmp) { 5262 st_turn_pe_on(un); 5263 } else { 5264 st_turn_pe_off(un); 5265 } 5266 5267 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5268 "st_ioctl: MTIOCPERSISTENT : persistence = %d\n", 5269 un->un_persistence); 5270 5271 break; 5272 5273 case MTIOCPERSISTENTSTATUS: 5274 tmp = (int)un->un_persistence; 5275 5276 if (ddi_copyout(&tmp, (void *)arg, sizeof (tmp), flag)) { 5277 rval = EFAULT; 5278 } 5279 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5280 "st_ioctl: MTIOCPERSISTENTSTATUS:persistence = %d\n", 5281 un->un_persistence); 5282 5283 break; 5284 5285 case MTIOCLRERR: 5286 { 5287 /* clear persistent errors */ 5288 5289 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5290 "st_ioctl: MTIOCLRERR\n"); 5291 5292 st_clear_pe(un); 5293 5294 break; 5295 } 5296 5297 case MTIOCGUARANTEEDORDER: 5298 { 5299 /* 5300 * this is just a holder to make a valid ioctl and 5301 * it won't be in any earlier release 5302 */ 5303 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5304 "st_ioctl: MTIOCGUARANTEEDORDER\n"); 5305 5306 break; 5307 } 5308 5309 case MTIOCRESERVE: 5310 { 5311 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5312 "st_ioctl: MTIOCRESERVE\n"); 5313 5314 /* 5315 * Check if Reserve/Release is supported. 5316 */ 5317 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5318 rval = ENOTTY; 5319 break; 5320 } 5321 5322 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 5323 5324 if (rval == 0) { 5325 un->un_rsvd_status |= ST_PRESERVE_RESERVE; 5326 } 5327 break; 5328 } 5329 5330 case MTIOCRELEASE: 5331 { 5332 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5333 "st_ioctl: MTIOCRELEASE\n"); 5334 5335 /* 5336 * Check if Reserve/Release is supported. 5337 */ 5338 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5339 rval = ENOTTY; 5340 break; 5341 } 5342 5343 /* 5344 * Used to just clear ST_PRESERVE_RESERVE which 5345 * made the reservation release at next close. 5346 * As the user may have opened and then done a 5347 * persistant reservation we now need to drop 5348 * the reservation without closing if the user 5349 * attempts to do this. 5350 */ 5351 rval = st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 5352 5353 un->un_rsvd_status &= ~ST_PRESERVE_RESERVE; 5354 5355 break; 5356 } 5357 5358 case MTIOCFORCERESERVE: 5359 { 5360 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5361 "st_ioctl: MTIOCFORCERESERVE\n"); 5362 5363 /* 5364 * Check if Reserve/Release is supported. 5365 */ 5366 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5367 rval = ENOTTY; 5368 break; 5369 } 5370 /* 5371 * allow only super user to run this. 5372 */ 5373 if (drv_priv(cred_p) != 0) { 5374 rval = EPERM; 5375 break; 5376 } 5377 /* 5378 * Throw away reserve, 5379 * not using test-unit-ready 5380 * since reserve can succeed without tape being 5381 * present in the drive. 5382 */ 5383 (void) st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 5384 5385 rval = st_take_ownership(un, st_uscsi_cmd); 5386 5387 break; 5388 } 5389 5390 case USCSICMD: 5391 { 5392 cred_t *cr; 5393 5394 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5395 "st_ioctl: USCSICMD\n"); 5396 5397 cr = ddi_get_cred(); 5398 if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) { 5399 rval = EPERM; 5400 } else { 5401 rval = st_uscsi_cmd(un, (struct uscsi_cmd *)arg, flag); 5402 } 5403 break; 5404 } 5405 case MTIOCTOP: 5406 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5407 "st_ioctl: MTIOCTOP\n"); 5408 rval = st_mtioctop(un, arg, flag); 5409 break; 5410 5411 case MTIOCLTOP: 5412 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5413 "st_ioctl: MTIOLCTOP\n"); 5414 rval = st_mtiocltop(un, arg, flag); 5415 break; 5416 5417 case MTIOCREADIGNOREILI: 5418 { 5419 int set_ili; 5420 5421 if (ddi_copyin((void *)arg, &set_ili, 5422 sizeof (set_ili), flag)) { 5423 rval = EFAULT; 5424 break; 5425 } 5426 5427 if (un->un_bsize) { 5428 rval = ENOTTY; 5429 break; 5430 } 5431 5432 switch (set_ili) { 5433 case 0: 5434 un->un_dp->options &= ~ST_READ_IGNORE_ILI; 5435 break; 5436 5437 case 1: 5438 un->un_dp->options |= ST_READ_IGNORE_ILI; 5439 break; 5440 5441 default: 5442 rval = EINVAL; 5443 break; 5444 } 5445 break; 5446 } 5447 5448 case MTIOCREADIGNOREEOFS: 5449 { 5450 int ignore_eof; 5451 5452 if (ddi_copyin((void *)arg, &ignore_eof, 5453 sizeof (ignore_eof), flag)) { 5454 rval = EFAULT; 5455 break; 5456 } 5457 5458 if (!(un->un_dp->options & ST_REEL)) { 5459 rval = ENOTTY; 5460 break; 5461 } 5462 5463 switch (ignore_eof) { 5464 case 0: 5465 un->un_dp->options &= ~ST_READ_IGNORE_EOFS; 5466 break; 5467 5468 case 1: 5469 un->un_dp->options |= ST_READ_IGNORE_EOFS; 5470 break; 5471 5472 default: 5473 rval = EINVAL; 5474 break; 5475 } 5476 break; 5477 } 5478 5479 case MTIOCSHORTFMK: 5480 { 5481 int short_fmk; 5482 5483 if (ddi_copyin((void *)arg, &short_fmk, 5484 sizeof (short_fmk), flag)) { 5485 rval = EFAULT; 5486 break; 5487 } 5488 5489 switch (un->un_dp->type) { 5490 case ST_TYPE_EXB8500: 5491 case ST_TYPE_EXABYTE: 5492 if (!short_fmk) { 5493 un->un_dp->options &= ~ST_SHORT_FILEMARKS; 5494 } else if (short_fmk == 1) { 5495 un->un_dp->options |= ST_SHORT_FILEMARKS; 5496 } else { 5497 rval = EINVAL; 5498 } 5499 break; 5500 5501 default: 5502 rval = ENOTTY; 5503 break; 5504 } 5505 break; 5506 } 5507 5508 case MTIOCGETPOS: 5509 rval = st_update_block_pos(un, st_cmd, 0); 5510 if (rval == 0) { 5511 if (ddi_copyout((void *)&un->un_pos, (void *)arg, 5512 sizeof (tapepos_t), flag)) { 5513 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 5514 "MTIOCGETPOS copy out failed\n"); 5515 rval = EFAULT; 5516 } 5517 } 5518 break; 5519 5520 case MTIOCRESTPOS: 5521 { 5522 tapepos_t dest; 5523 5524 if (ddi_copyin((void *)arg, &dest, sizeof (tapepos_t), 5525 flag) != 0) { 5526 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 5527 "MTIOCRESTPOS copy in failed\n"); 5528 rval = EFAULT; 5529 break; 5530 } 5531 rval = st_validate_tapemarks(un, st_uscsi_cmd, &dest); 5532 if (rval != 0) { 5533 rval = EIO; 5534 } 5535 break; 5536 } 5537 default: 5538 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5539 "st_ioctl: unknown ioctl\n"); 5540 rval = ENOTTY; 5541 } 5542 5543 exit: 5544 if (!(un->un_persistence && un->un_persist_errors)) { 5545 un->un_errno = rval; 5546 } 5547 5548 mutex_exit(ST_MUTEX); 5549 5550 return (rval); 5551 } 5552 5553 5554 /* 5555 * do some MTIOCTOP tape operations 5556 */ 5557 static int 5558 st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag) 5559 { 5560 #ifdef _MULTI_DATAMODEL 5561 /* 5562 * For use when a 32 bit app makes a call into a 5563 * 64 bit ioctl 5564 */ 5565 struct mtop32 mtop_32_for_64; 5566 #endif /* _MULTI_DATAMODEL */ 5567 struct mtop passed; 5568 struct mtlop local; 5569 int rval = 0; 5570 5571 ST_FUNC(ST_DEVINFO, st_mtioctop); 5572 5573 ASSERT(mutex_owned(ST_MUTEX)); 5574 5575 #ifdef _MULTI_DATAMODEL 5576 switch (ddi_model_convert_from(flag & FMODELS)) { 5577 case DDI_MODEL_ILP32: 5578 if (ddi_copyin((void *)arg, &mtop_32_for_64, 5579 sizeof (struct mtop32), flag)) { 5580 return (EFAULT); 5581 } 5582 local.mt_op = mtop_32_for_64.mt_op; 5583 local.mt_count = (int64_t)mtop_32_for_64.mt_count; 5584 break; 5585 5586 case DDI_MODEL_NONE: 5587 if (ddi_copyin((void *)arg, &passed, sizeof (passed), flag)) { 5588 return (EFAULT); 5589 } 5590 local.mt_op = passed.mt_op; 5591 /* prevent sign extention */ 5592 local.mt_count = (UINT32_MAX & passed.mt_count); 5593 break; 5594 } 5595 5596 #else /* ! _MULTI_DATAMODEL */ 5597 if (ddi_copyin((void *)arg, &passed, sizeof (passed), flag)) { 5598 return (EFAULT); 5599 } 5600 local.mt_op = passed.mt_op; 5601 /* prevent sign extention */ 5602 local.mt_count = (UINT32_MAX & passed.mt_count); 5603 #endif /* _MULTI_DATAMODEL */ 5604 5605 rval = st_do_mtioctop(un, &local); 5606 5607 #ifdef _MULTI_DATAMODEL 5608 switch (ddi_model_convert_from(flag & FMODELS)) { 5609 case DDI_MODEL_ILP32: 5610 if (((uint64_t)local.mt_count) > UINT32_MAX) { 5611 rval = ERANGE; 5612 break; 5613 } 5614 /* 5615 * Convert 64 bit back to 32 bit before doing 5616 * copyout. This is what the ILP32 app expects. 5617 */ 5618 mtop_32_for_64.mt_op = local.mt_op; 5619 mtop_32_for_64.mt_count = local.mt_count; 5620 5621 if (ddi_copyout(&mtop_32_for_64, (void *)arg, 5622 sizeof (struct mtop32), flag)) { 5623 rval = EFAULT; 5624 } 5625 break; 5626 5627 case DDI_MODEL_NONE: 5628 passed.mt_count = local.mt_count; 5629 passed.mt_op = local.mt_op; 5630 if (ddi_copyout(&passed, (void *)arg, sizeof (passed), flag)) { 5631 rval = EFAULT; 5632 } 5633 break; 5634 } 5635 #else /* ! _MULTI_DATAMODE */ 5636 if (((uint64_t)local.mt_count) > UINT32_MAX) { 5637 rval = ERANGE; 5638 } else { 5639 passed.mt_op = local.mt_op; 5640 passed.mt_count = local.mt_count; 5641 if (ddi_copyout(&passed, (void *)arg, sizeof (passed), flag)) { 5642 rval = EFAULT; 5643 } 5644 } 5645 #endif /* _MULTI_DATAMODE */ 5646 5647 5648 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 5649 "st_ioctl: fileno=%x, blkno=%x, eof=%x\n", un->un_pos.fileno, 5650 un->un_pos.blkno, un->un_pos.eof); 5651 5652 if (un->un_pos.pmode == invalid) { 5653 un->un_density_known = 0; 5654 } 5655 5656 ASSERT(mutex_owned(ST_MUTEX)); 5657 return (rval); 5658 } 5659 5660 static int 5661 st_mtiocltop(struct scsi_tape *un, intptr_t arg, int flag) 5662 { 5663 struct mtlop local; 5664 int rval; 5665 5666 ST_FUNC(ST_DEVINFO, st_mtiocltop); 5667 if (ddi_copyin((void *)arg, &local, sizeof (local), flag)) { 5668 return (EFAULT); 5669 } 5670 5671 rval = st_do_mtioctop(un, &local); 5672 5673 if (ddi_copyout(&local, (void *)arg, sizeof (local), flag)) { 5674 rval = EFAULT; 5675 } 5676 return (rval); 5677 } 5678 5679 5680 static int 5681 st_do_mtioctop(struct scsi_tape *un, struct mtlop *mtop) 5682 { 5683 dev_t dev = un->un_dev; 5684 int savefile; 5685 int rval = 0; 5686 5687 ST_FUNC(ST_DEVINFO, st_do_mtioctop); 5688 5689 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5690 "st_do_mtioctop(): mt_op=%x\n", mtop->mt_op); 5691 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5692 "fileno=%x, blkno=%x, eof=%x\n", 5693 un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 5694 5695 un->un_status = 0; 5696 5697 /* 5698 * if we are going to mess with a tape, we have to make sure we have 5699 * one and are not offline (i.e. no tape is initialized). We let 5700 * commands pass here that don't actually touch the tape, except for 5701 * loading and initialization (rewinding). 5702 */ 5703 if (un->un_state == ST_STATE_OFFLINE) { 5704 switch (mtop->mt_op) { 5705 case MTLOAD: 5706 case MTNOP: 5707 /* 5708 * We don't want strategy calling st_tape_init here, 5709 * so, change state 5710 */ 5711 un->un_state = ST_STATE_INITIALIZING; 5712 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5713 "st_do_mtioctop : OFFLINE state = %d\n", 5714 un->un_state); 5715 break; 5716 default: 5717 /* 5718 * reinitialize by normal means 5719 */ 5720 rval = st_tape_init(un); 5721 if (rval) { 5722 un->un_state = ST_STATE_INITIALIZING; 5723 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5724 "st_do_mtioctop : OFFLINE init failure "); 5725 un->un_state = ST_STATE_OFFLINE; 5726 un->un_pos.pmode = invalid; 5727 if (rval != EACCES) { 5728 rval = EIO; 5729 } 5730 return (rval); 5731 } 5732 un->un_state = ST_STATE_OPEN_PENDING_IO; 5733 break; 5734 } 5735 } 5736 5737 /* 5738 * If the file position is invalid, allow only those 5739 * commands that properly position the tape and fail 5740 * the rest with EIO 5741 */ 5742 if (un->un_pos.pmode == invalid) { 5743 switch (mtop->mt_op) { 5744 case MTWEOF: 5745 case MTRETEN: 5746 case MTERASE: 5747 case MTEOM: 5748 case MTFSF: 5749 case MTFSR: 5750 case MTBSF: 5751 case MTNBSF: 5752 case MTBSR: 5753 case MTSRSZ: 5754 case MTGRSZ: 5755 case MTSEEK: 5756 case MTBSSF: 5757 case MTFSSF: 5758 return (EIO); 5759 /* NOTREACHED */ 5760 case MTREW: 5761 case MTLOAD: 5762 case MTOFFL: 5763 case MTNOP: 5764 case MTTELL: 5765 case MTLOCK: 5766 case MTUNLOCK: 5767 break; 5768 5769 default: 5770 return (ENOTTY); 5771 /* NOTREACHED */ 5772 } 5773 } 5774 5775 switch (mtop->mt_op) { 5776 case MTERASE: 5777 /* 5778 * MTERASE rewinds the tape, erase it completely, and returns 5779 * to the beginning of the tape 5780 */ 5781 if (un->un_mspl->wp || un->un_read_only & WORM) { 5782 un->un_status = KEY_WRITE_PROTECT; 5783 un->un_err_resid = mtop->mt_count; 5784 COPY_POS(&un->un_err_pos, &un->un_pos); 5785 return (EACCES); 5786 } 5787 if (un->un_dp->options & ST_REEL) { 5788 un->un_fmneeded = 2; 5789 } else { 5790 un->un_fmneeded = 1; 5791 } 5792 mtop->mt_count = mtop->mt_count ? 1 : 0; 5793 if (st_check_density_or_wfm(dev, 1, B_WRITE, NO_STEPBACK) || 5794 st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 5795 st_cmd(un, SCMD_ERASE, mtop->mt_count, SYNC_CMD)) { 5796 un->un_pos.pmode = invalid; 5797 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5798 "st_do_mtioctop : EIO space or erase or " 5799 "check den)\n"); 5800 rval = EIO; 5801 } else { 5802 /* QIC and helical scan rewind after erase */ 5803 if (un->un_dp->options & ST_REEL) { 5804 (void) st_cmd(un, SCMD_REWIND, 0, ASYNC_CMD); 5805 } 5806 } 5807 break; 5808 5809 case MTWEOF: 5810 /* 5811 * write an end-of-file record 5812 */ 5813 if (un->un_mspl->wp || un->un_read_only & RDONLY) { 5814 un->un_status = KEY_WRITE_PROTECT; 5815 un->un_err_resid = mtop->mt_count; 5816 COPY_POS(&un->un_err_pos, &un->un_pos); 5817 return (EACCES); 5818 } 5819 5820 /* 5821 * zero count means just flush buffers 5822 * negative count is not permitted 5823 */ 5824 if (mtop->mt_count < 0) { 5825 return (EINVAL); 5826 } 5827 5828 /* Not on worm */ 5829 if (un->un_read_only == RDWR) { 5830 un->un_test_append = 1; 5831 } 5832 5833 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 5834 if (st_determine_density(un, B_WRITE)) { 5835 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5836 "st_do_mtioctop : EIO : MTWEOF can't " 5837 "determine density"); 5838 return (EIO); 5839 } 5840 } 5841 5842 rval = st_write_fm(dev, (int)mtop->mt_count); 5843 if ((rval != 0) && (rval != EACCES)) { 5844 /* 5845 * Failure due to something other than illegal 5846 * request results in loss of state (st_intr). 5847 */ 5848 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5849 "st_do_mtioctop : EIO : MTWEOF can't write " 5850 "file mark"); 5851 rval = EIO; 5852 } 5853 break; 5854 5855 case MTRETEN: 5856 /* 5857 * retension the tape 5858 */ 5859 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK) || 5860 st_cmd(un, SCMD_LOAD, LD_LOAD | LD_RETEN, SYNC_CMD)) { 5861 un->un_pos.pmode = invalid; 5862 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5863 "st_do_mtioctop : EIO : MTRETEN "); 5864 rval = EIO; 5865 } 5866 break; 5867 5868 case MTREW: 5869 /* 5870 * rewind the tape 5871 */ 5872 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) { 5873 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5874 "st_do_mtioctop : EIO:MTREW check " 5875 "density/wfm failed"); 5876 return (EIO); 5877 } 5878 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 5879 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5880 "st_do_mtioctop : EIO : MTREW "); 5881 rval = EIO; 5882 } 5883 break; 5884 5885 case MTOFFL: 5886 /* 5887 * rewinds, and, if appropriate, takes the device offline by 5888 * unloading the tape 5889 */ 5890 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) { 5891 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5892 "st_do_mtioctop :EIO:MTOFFL check " 5893 "density/wfm failed"); 5894 return (EIO); 5895 } 5896 (void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 5897 if (st_cmd(un, SCMD_LOAD, LD_UNLOAD, SYNC_CMD)) { 5898 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5899 "st_do_mtioctop : EIO : MTOFFL"); 5900 return (EIO); 5901 } 5902 un->un_pos.eof = ST_NO_EOF; 5903 un->un_laststate = un->un_state; 5904 un->un_state = ST_STATE_OFFLINE; 5905 un->un_mediastate = MTIO_EJECTED; 5906 break; 5907 5908 case MTLOAD: 5909 /* 5910 * This is to load a tape into the drive 5911 * Note that if the tape is not loaded, the device will have 5912 * to be opened via O_NDELAY or O_NONBLOCK. 5913 */ 5914 /* 5915 * Let's try and clean things up, if we are not 5916 * initializing, and then send in the load command, no 5917 * matter what. 5918 * 5919 * load after a media change by the user. 5920 */ 5921 5922 if (un->un_state > ST_STATE_INITIALIZING) { 5923 (void) st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK); 5924 } 5925 rval = st_cmd(un, SCMD_LOAD, LD_LOAD, SYNC_CMD); 5926 /* Load command to a drive that doesn't support load */ 5927 if ((rval == EIO) && 5928 ((un->un_status == KEY_NOT_READY) && 5929 /* Medium not present */ 5930 (un->un_uscsi_rqs_buf->es_add_code == 0x3a) || 5931 ((un->un_status == KEY_ILLEGAL_REQUEST) && 5932 (un->un_dp->type == MT_ISSTK9840) && 5933 /* CSL not present */ 5934 (un->un_uscsi_rqs_buf->es_add_code == 0x80)))) { 5935 rval = ENOTTY; 5936 break; 5937 } else if (rval != EACCES && rval != 0) { 5938 rval = EIO; 5939 } 5940 if (rval) { 5941 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5942 "st_do_mtioctop : %s : MTLOAD\n", 5943 rval == EACCES ? "EACCES" : "EIO"); 5944 /* 5945 * If load tape fails, who knows what happened... 5946 */ 5947 un->un_pos.pmode = invalid; 5948 break; 5949 } 5950 5951 /* 5952 * reset all counters appropriately using rewind, as if LOAD 5953 * succeeds, we are at BOT 5954 */ 5955 un->un_state = ST_STATE_INITIALIZING; 5956 5957 rval = st_tape_init(un); 5958 if ((rval == EACCES) && (un->un_read_only & WORM)) { 5959 rval = 0; 5960 break; 5961 } 5962 5963 if (rval != 0) { 5964 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5965 "st_do_mtioctop : EIO : MTLOAD calls " 5966 "st_tape_init\n"); 5967 rval = EIO; 5968 un->un_state = ST_STATE_OFFLINE; 5969 } 5970 5971 break; 5972 5973 case MTNOP: 5974 un->un_status = 0; /* Reset status */ 5975 un->un_err_resid = 0; 5976 mtop->mt_count = MTUNIT(dev); 5977 break; 5978 5979 case MTEOM: 5980 /* 5981 * positions the tape at a location just after the last file 5982 * written on the tape. For cartridge and 8 mm, this after 5983 * the last file mark; for reel, this is inbetween the two 5984 * last 2 file marks 5985 */ 5986 if ((un->un_pos.pmode == legacy && un->un_pos.eof >= ST_EOT) || 5987 (un->un_lastop == ST_OP_WRITE) || 5988 (un->un_lastop == ST_OP_WEOF)) { 5989 /* 5990 * If the command wants to move to logical end 5991 * of media, and we're already there, we're done. 5992 * If we were at logical eot, we reset the state 5993 * to be *not* at logical eot. 5994 * 5995 * If we're at physical or logical eot, we prohibit 5996 * forward space operations (unconditionally). 5997 * 5998 * Also if the last operation was a write of any 5999 * kind the tape is at EOD. 6000 */ 6001 return (0); 6002 } 6003 /* 6004 * physical tape position may not be what we've been 6005 * telling the user; adjust the request accordingly 6006 */ 6007 if (IN_EOF(un->un_pos)) { 6008 un->un_pos.fileno++; 6009 un->un_pos.blkno = 0; 6010 } 6011 6012 if (st_check_density_or_wfm(dev, 1, B_READ, NO_STEPBACK)) { 6013 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6014 "st_do_mtioctop : EIO:MTEOM check density/wfm " 6015 " failed"); 6016 return (EIO); 6017 } 6018 6019 /* 6020 * st_find_eod() returns the last fileno we knew about; 6021 */ 6022 savefile = st_find_eod(un); 6023 6024 if ((un->un_status != KEY_BLANK_CHECK) && 6025 (un->un_status != SUN_KEY_EOT)) { 6026 un->un_pos.pmode = invalid; 6027 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6028 "st_do_mtioctop : EIO : MTEOM status check failed"); 6029 rval = EIO; 6030 } else { 6031 /* 6032 * For 1/2" reel tapes assume logical EOT marked 6033 * by two file marks or we don't care that we may 6034 * be extending the last file on the tape. 6035 */ 6036 if (un->un_dp->options & ST_REEL) { 6037 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 6038 un->un_pos.pmode = invalid; 6039 ST_DEBUG2(ST_DEVINFO, st_label, 6040 SCSI_DEBUG, 6041 "st_do_mtioctop : EIO : MTEOM space" 6042 " cmd failed"); 6043 rval = EIO; 6044 break; 6045 } 6046 /* 6047 * Fix up the block number. 6048 */ 6049 un->un_pos.blkno = 0; 6050 un->un_err_pos.blkno = 0; 6051 } 6052 un->un_err_resid = 0; 6053 un->un_pos.fileno = savefile; 6054 un->un_pos.eof = ST_EOT; 6055 } 6056 un->un_status = 0; 6057 break; 6058 6059 case MTFSF: 6060 MAX_SPACE_CNT(mtop->mt_count); 6061 rval = st_mtfsf_ioctl(un, mtop->mt_count); 6062 break; 6063 6064 case MTFSR: 6065 MAX_SPACE_CNT(mtop->mt_count); 6066 rval = st_mtfsr_ioctl(un, mtop->mt_count); 6067 break; 6068 6069 case MTBSF: 6070 MAX_SPACE_CNT(mtop->mt_count); 6071 rval = st_mtbsf_ioctl(un, mtop->mt_count); 6072 break; 6073 6074 case MTNBSF: 6075 MAX_SPACE_CNT(mtop->mt_count); 6076 rval = st_mtnbsf_ioctl(un, mtop->mt_count); 6077 break; 6078 6079 case MTBSR: 6080 MAX_SPACE_CNT(mtop->mt_count); 6081 rval = st_mtbsr_ioctl(un, mtop->mt_count); 6082 break; 6083 6084 case MTBSSF: 6085 MAX_SPACE_CNT(mtop->mt_count); 6086 rval = st_mtbsfm_ioctl(un, mtop->mt_count); 6087 break; 6088 6089 case MTFSSF: 6090 MAX_SPACE_CNT(mtop->mt_count); 6091 rval = st_mtfsfm_ioctl(un, mtop->mt_count); 6092 break; 6093 6094 case MTSRSZ: 6095 6096 /* 6097 * Set record-size to that sent by user 6098 * Check to see if there is reason that the requested 6099 * block size should not be set. 6100 */ 6101 6102 /* If requesting variable block size is it ok? */ 6103 if ((mtop->mt_count == 0) && 6104 ((un->un_dp->options & ST_VARIABLE) == 0)) { 6105 return (ENOTTY); 6106 } 6107 6108 /* 6109 * If requested block size is not variable "0", 6110 * is it less then minimum. 6111 */ 6112 if ((mtop->mt_count != 0) && 6113 (mtop->mt_count < un->un_minbsize)) { 6114 return (EINVAL); 6115 } 6116 6117 /* Is the requested block size more then maximum */ 6118 if ((mtop->mt_count > min(un->un_maxbsize, un->un_maxdma)) && 6119 (un->un_maxbsize != 0)) { 6120 return (EINVAL); 6121 } 6122 6123 /* Is requested block size a modulus the device likes */ 6124 if ((mtop->mt_count % un->un_data_mod) != 0) { 6125 return (EINVAL); 6126 } 6127 6128 if (st_change_block_size(un, (uint32_t)mtop->mt_count) != 0) { 6129 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6130 "st_ioctl : MTSRSZ : EIO : cant set block size"); 6131 return (EIO); 6132 } 6133 6134 return (0); 6135 6136 case MTGRSZ: 6137 /* 6138 * Get record-size to the user 6139 */ 6140 mtop->mt_count = un->un_bsize; 6141 rval = 0; 6142 break; 6143 6144 case MTTELL: 6145 rval = st_update_block_pos(un, st_cmd, 0); 6146 mtop->mt_count = un->un_pos.lgclblkno; 6147 break; 6148 6149 case MTSEEK: 6150 rval = st_logical_block_locate(un, st_uscsi_cmd, &un->un_pos, 6151 (uint64_t)mtop->mt_count, un->un_pos.partition); 6152 /* 6153 * This bit of magic make mt print the actual position if 6154 * the resulting position was not what was asked for. 6155 */ 6156 if (rval == ESPIPE) { 6157 rval = EIO; 6158 if ((uint64_t)mtop->mt_count != un->un_pos.lgclblkno) { 6159 mtop->mt_op = MTTELL; 6160 mtop->mt_count = un->un_pos.lgclblkno; 6161 } 6162 } 6163 break; 6164 6165 case MTLOCK: 6166 if (st_cmd(un, SCMD_DOORLOCK, MR_LOCK, SYNC_CMD)) { 6167 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6168 "st_do_mtioctop : EIO : MTLOCK"); 6169 rval = EIO; 6170 } 6171 break; 6172 6173 case MTUNLOCK: 6174 if (st_cmd(un, SCMD_DOORLOCK, MR_UNLOCK, SYNC_CMD)) { 6175 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6176 "st_do_mtioctop : EIO : MTUNLOCK"); 6177 rval = EIO; 6178 } 6179 break; 6180 6181 default: 6182 rval = ENOTTY; 6183 } 6184 6185 return (rval); 6186 } 6187 6188 6189 /* 6190 * Run a command for uscsi ioctl. 6191 */ 6192 static int 6193 st_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, int flag) 6194 { 6195 struct uscsi_cmd *uscmd; 6196 struct buf *bp; 6197 enum uio_seg uioseg; 6198 int offline_state = 0; 6199 int err = 0; 6200 dev_t dev = un->un_dev; 6201 6202 ST_FUNC(ST_DEVINFO, st_uscsi_cmd); 6203 6204 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6205 "st_uscsi_cmd(dev = 0x%lx)\n", un->un_dev); 6206 6207 ASSERT(mutex_owned(ST_MUTEX)); 6208 6209 /* 6210 * We really don't know what commands are coming in here and 6211 * we don't want to limit the commands coming in. 6212 * 6213 * If st_tape_init() gets called from st_strategy(), then we 6214 * will hang the process waiting for un->un_sbuf_busy to be cleared, 6215 * which it never will, as we set it below. To prevent 6216 * st_tape_init() from getting called, we have to set state to other 6217 * than ST_STATE_OFFLINE, so we choose ST_STATE_INITIALIZING, which 6218 * achieves this purpose already. 6219 * 6220 * We use offline_state to preserve the OFFLINE state, if it exists, 6221 * so other entry points to the driver might have the chance to call 6222 * st_tape_init(). 6223 */ 6224 if (un->un_state == ST_STATE_OFFLINE) { 6225 un->un_laststate = ST_STATE_OFFLINE; 6226 un->un_state = ST_STATE_INITIALIZING; 6227 offline_state = 1; 6228 } 6229 6230 mutex_exit(ST_MUTEX); 6231 err = scsi_uscsi_alloc_and_copyin((intptr_t)ucmd, flag, ROUTE, &uscmd); 6232 mutex_enter(ST_MUTEX); 6233 if (err != 0) { 6234 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6235 "st_uscsi_cmd: scsi_uscsi_alloc_and_copyin failed\n"); 6236 goto exit; 6237 } 6238 6239 uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE : UIO_USERSPACE; 6240 6241 /* check to see if this command requires the drive to be reserved */ 6242 if (uscmd->uscsi_cdb != NULL) { 6243 err = st_check_cdb_for_need_to_reserve(un, 6244 (uchar_t *)uscmd->uscsi_cdb); 6245 if (err) { 6246 goto exit_free; 6247 } 6248 /* 6249 * If this is a space command we need to save the starting 6250 * point so we can retry from there if the command fails. 6251 */ 6252 if ((uscmd->uscsi_cdb[0] == SCMD_SPACE) || 6253 (uscmd->uscsi_cdb[0] == (char)SCMD_SPACE_G4)) { 6254 (void) st_update_block_pos(un, st_cmd, 0); 6255 } 6256 } 6257 6258 /* 6259 * Forground should not be doing anything while recovery is active. 6260 */ 6261 ASSERT(un->un_recov_buf_busy == 0); 6262 6263 /* 6264 * Get buffer resources... 6265 */ 6266 while (un->un_sbuf_busy) 6267 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 6268 un->un_sbuf_busy = 1; 6269 6270 #ifdef STDEBUG 6271 if ((uscmd->uscsi_cdb != NULL) && (st_debug & 0x7) > 6) { 6272 int rw = (uscmd->uscsi_flags & USCSI_READ) ? B_READ : B_WRITE; 6273 st_print_cdb(ST_DEVINFO, st_label, SCSI_DEBUG, 6274 "uscsi cdb", uscmd->uscsi_cdb); 6275 if (uscmd->uscsi_buflen) { 6276 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6277 "uscsi %s of %ld bytes %s %s space\n", 6278 (rw == B_READ) ? rd_str : wr_str, 6279 uscmd->uscsi_buflen, 6280 (rw == B_READ) ? "to" : "from", 6281 (uioseg == UIO_SYSSPACE) ? "system" : "user"); 6282 } 6283 } 6284 #endif /* STDEBUG */ 6285 6286 /* 6287 * Although st_uscsi_cmd() never makes use of these 6288 * now, we are just being safe and consistent. 6289 */ 6290 uscmd->uscsi_flags &= ~(USCSI_NOINTR | USCSI_NOPARITY | 6291 USCSI_OTAG | USCSI_HTAG | USCSI_HEAD); 6292 6293 un->un_srqbufp = uscmd->uscsi_rqbuf; 6294 bp = un->un_sbufp; 6295 bzero(bp, sizeof (buf_t)); 6296 if (uscmd->uscsi_cdb != NULL) { 6297 bp->b_forw = (struct buf *)(uintptr_t)uscmd->uscsi_cdb[0]; 6298 } 6299 bp->b_back = (struct buf *)uscmd; 6300 6301 mutex_exit(ST_MUTEX); 6302 err = scsi_uscsi_handle_cmd(dev, uioseg, uscmd, st_strategy, bp, NULL); 6303 mutex_enter(ST_MUTEX); 6304 6305 /* 6306 * If scsi reset successful, don't write any filemarks. 6307 */ 6308 if ((err == 0) && (uscmd->uscsi_flags & 6309 (USCSI_RESET_LUN | USCSI_RESET_TARGET | USCSI_RESET_ALL))) { 6310 un->un_fmneeded = 0; 6311 } 6312 6313 exit_free: 6314 /* 6315 * Free resources 6316 */ 6317 un->un_sbuf_busy = 0; 6318 un->un_srqbufp = NULL; 6319 6320 /* 6321 * If was a space command need to update logical block position. 6322 * If the command failed such that positioning is invalid, Don't 6323 * update the position as the user must do this to validate the 6324 * position for data protection. 6325 */ 6326 if ((uscmd->uscsi_cdb != NULL) && 6327 ((uscmd->uscsi_cdb[0] == SCMD_SPACE) || 6328 (uscmd->uscsi_cdb[0] == (char)SCMD_SPACE_G4)) && 6329 (un->un_pos.pmode != invalid)) { 6330 un->un_running.pmode = invalid; 6331 (void) st_update_block_pos(un, st_cmd, 1); 6332 /* 6333 * Set running position to invalid so it updates on the 6334 * next command. 6335 */ 6336 un->un_running.pmode = invalid; 6337 } 6338 cv_signal(&un->un_sbuf_cv); 6339 mutex_exit(ST_MUTEX); 6340 (void) scsi_uscsi_copyout_and_free((intptr_t)ucmd, uscmd); 6341 mutex_enter(ST_MUTEX); 6342 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6343 "st_uscsi_cmd returns 0x%x\n", err); 6344 6345 exit: 6346 /* don't lose offline state */ 6347 if (offline_state) { 6348 un->un_state = ST_STATE_OFFLINE; 6349 } 6350 6351 ASSERT(mutex_owned(ST_MUTEX)); 6352 return (err); 6353 } 6354 6355 static int 6356 st_write_fm(dev_t dev, int wfm) 6357 { 6358 int i; 6359 int rval; 6360 6361 GET_SOFT_STATE(dev); 6362 6363 ST_FUNC(ST_DEVINFO, st_write_fm); 6364 6365 ASSERT(mutex_owned(ST_MUTEX)); 6366 6367 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6368 "st_write_fm(dev = 0x%lx, wfm = %d)\n", dev, wfm); 6369 6370 /* 6371 * write one filemark at the time after EOT 6372 */ 6373 if (un->un_pos.eof >= ST_EOT) { 6374 for (i = 0; i < wfm; i++) { 6375 rval = st_cmd(un, SCMD_WRITE_FILE_MARK, 1, SYNC_CMD); 6376 if (rval == EACCES) { 6377 return (rval); 6378 } 6379 if (rval != 0) { 6380 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6381 "st_write_fm : EIO : write EOT file mark"); 6382 return (EIO); 6383 } 6384 } 6385 } else { 6386 rval = st_cmd(un, SCMD_WRITE_FILE_MARK, wfm, SYNC_CMD); 6387 if (rval == EACCES) { 6388 return (rval); 6389 } 6390 if (rval) { 6391 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6392 "st_write_fm : EIO : write file mark"); 6393 return (EIO); 6394 } 6395 } 6396 6397 ASSERT(mutex_owned(ST_MUTEX)); 6398 return (0); 6399 } 6400 6401 #ifdef STDEBUG 6402 static void 6403 st_start_dump(struct scsi_tape *un, struct buf *bp) 6404 { 6405 struct scsi_pkt *pkt = BP_PKT(bp); 6406 uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp; 6407 6408 ST_FUNC(ST_DEVINFO, st_start_dump); 6409 6410 if ((st_debug & 0x7) < 6) 6411 return; 6412 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6413 "st_start: cmd=0x%p count=%ld resid=%ld flags=0x%x pkt=0x%p\n", 6414 (void *)bp->b_forw, bp->b_bcount, 6415 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 6416 st_print_cdb(ST_DEVINFO, st_label, SCSI_DEBUG, 6417 "st_start: cdb", (caddr_t)cdbp); 6418 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6419 "st_start: fileno=%d, blk=%d\n", 6420 un->un_pos.fileno, un->un_pos.blkno); 6421 } 6422 #endif 6423 6424 6425 /* 6426 * Command start && done functions 6427 */ 6428 6429 /* 6430 * st_start() 6431 * 6432 * Called from: 6433 * st_strategy() to start a command. 6434 * st_runout() to retry when scsi_pkt allocation fails on previous attempt(s). 6435 * st_attach() when resuming from power down state. 6436 * st_start_restart() to retry transport when device was previously busy. 6437 * st_done_and_mutex_exit() to start the next command when previous is done. 6438 * 6439 * On entry: 6440 * scsi_pkt may or may not be allocated. 6441 * 6442 */ 6443 static void 6444 st_start(struct scsi_tape *un) 6445 { 6446 struct buf *bp; 6447 int status; 6448 int queued; 6449 6450 ST_FUNC(ST_DEVINFO, st_start); 6451 ASSERT(mutex_owned(ST_MUTEX)); 6452 6453 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6454 "st_start(): dev = 0x%lx\n", un->un_dev); 6455 6456 if (un->un_recov_buf_busy) { 6457 /* recovery commands can happen anytime */ 6458 bp = un->un_recov_buf; 6459 queued = 0; 6460 } else if (un->un_sbuf_busy) { 6461 /* sbuf commands should only happen with an empty queue. */ 6462 ASSERT(un->un_quef == NULL); 6463 ASSERT(un->un_runqf == NULL); 6464 bp = un->un_sbufp; 6465 queued = 0; 6466 } else if (un->un_quef != NULL) { 6467 if (un->un_persistence && un->un_persist_errors) { 6468 return; 6469 } 6470 bp = un->un_quef; 6471 queued = 1; 6472 } else { 6473 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6474 "st_start() returning no buf found\n"); 6475 return; 6476 } 6477 6478 ASSERT((bp->b_flags & B_DONE) == 0); 6479 6480 /* 6481 * Don't send more than un_throttle commands to the HBA 6482 */ 6483 if ((un->un_throttle <= 0) || (un->un_ncmds >= un->un_throttle)) { 6484 /* 6485 * if doing recovery we know there is outstanding commands. 6486 */ 6487 if (bp != un->un_recov_buf) { 6488 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6489 "st_start returning throttle = %d or ncmds = %d\n", 6490 un->un_throttle, un->un_ncmds); 6491 if (un->un_ncmds == 0) { 6492 typedef void (*func)(); 6493 func fnc = (func)st_runout; 6494 6495 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6496 "Sending delayed start to st_runout()\n"); 6497 mutex_exit(ST_MUTEX); 6498 (void) timeout(fnc, un, drv_usectohz(1000000)); 6499 mutex_enter(ST_MUTEX); 6500 } 6501 return; 6502 } 6503 } 6504 6505 /* 6506 * If the buf has no scsi_pkt call st_make_cmd() to get one and 6507 * build the command. 6508 */ 6509 if (BP_PKT(bp) == NULL) { 6510 ASSERT((bp->b_flags & B_DONE) == 0); 6511 st_make_cmd(un, bp, st_runout); 6512 ASSERT((bp->b_flags & B_DONE) == 0); 6513 status = geterror(bp); 6514 6515 /* 6516 * Some HBA's don't call bioerror() to set an error. 6517 * And geterror() returns zero if B_ERROR is not set. 6518 * So if we get zero we must check b_error. 6519 */ 6520 if (status == 0 && bp->b_error != 0) { 6521 status = bp->b_error; 6522 bioerror(bp, status); 6523 } 6524 6525 /* 6526 * Some HBA's convert DDI_DMA_NORESOURCES into ENOMEM. 6527 * In tape ENOMEM has special meaning so we'll change it. 6528 */ 6529 if (status == ENOMEM) { 6530 status = 0; 6531 bioerror(bp, status); 6532 } 6533 6534 /* 6535 * Did it fail and is it retryable? 6536 * If so return and wait for the callback through st_runout. 6537 * Also looks like scsi_init_pkt() will setup a callback even 6538 * if it isn't retryable. 6539 */ 6540 if (BP_PKT(bp) == NULL) { 6541 if (status == 0) { 6542 /* 6543 * If first attempt save state. 6544 */ 6545 if (un->un_state != ST_STATE_RESOURCE_WAIT) { 6546 un->un_laststate = un->un_state; 6547 un->un_state = ST_STATE_RESOURCE_WAIT; 6548 } 6549 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6550 "temp no resources for pkt\n"); 6551 } else if (status == EINVAL) { 6552 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6553 "scsi_init_pkt rejected pkt as too big\n"); 6554 if (un->un_persistence) { 6555 st_set_pe_flag(un); 6556 } 6557 } else { 6558 /* 6559 * Unlikely that it would be retryable then not. 6560 */ 6561 if (un->un_state == ST_STATE_RESOURCE_WAIT) { 6562 un->un_state = un->un_laststate; 6563 } 6564 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6565 "perm no resources for pkt errno = 0x%x\n", 6566 status); 6567 } 6568 return; 6569 } 6570 /* 6571 * Worked this time set the state back. 6572 */ 6573 if (un->un_state == ST_STATE_RESOURCE_WAIT) { 6574 un->un_state = un->un_laststate; 6575 } 6576 } 6577 6578 if (queued) { 6579 /* 6580 * move from waitq to runq 6581 */ 6582 (void) st_remove_from_queue(&un->un_quef, &un->un_quel, bp); 6583 st_add_to_queue(&un->un_runqf, &un->un_runql, un->un_runql, bp); 6584 } 6585 6586 6587 #ifdef STDEBUG 6588 st_start_dump(un, bp); 6589 #endif 6590 6591 /* could not get here if throttle was zero */ 6592 un->un_last_throttle = un->un_throttle; 6593 un->un_throttle = 0; /* so nothing else will come in here */ 6594 un->un_ncmds++; 6595 6596 ST_DO_KSTATS(bp, kstat_waitq_to_runq); 6597 6598 status = st_transport(un, BP_PKT(bp)); 6599 6600 if (un->un_last_throttle) { 6601 un->un_throttle = un->un_last_throttle; 6602 } 6603 6604 if (status != TRAN_ACCEPT) { 6605 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 6606 ST_DEBUG(ST_DEVINFO, st_label, CE_WARN, 6607 "Unhappy transport packet status 0x%x\n", status); 6608 6609 if (status == TRAN_BUSY) { 6610 pkt_info *pkti = BP_PKT(bp)->pkt_private; 6611 6612 /* 6613 * If command recovery is enabled and this isn't 6614 * a recovery command try command recovery. 6615 */ 6616 if (pkti->privatelen == sizeof (recov_info) && 6617 bp != un->un_recov_buf) { 6618 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 6619 "Command Recovery called on busy send\n"); 6620 if (st_command_recovery(un, BP_PKT(bp), 6621 ATTEMPT_RETRY) == JUST_RETURN) { 6622 return; 6623 } 6624 } else { 6625 mutex_exit(ST_MUTEX); 6626 if (st_handle_start_busy(un, bp, 6627 ST_TRAN_BUSY_TIMEOUT, queued) == 0) { 6628 mutex_enter(ST_MUTEX); 6629 return; 6630 } 6631 /* 6632 * if too many retries, fail the transport 6633 */ 6634 mutex_enter(ST_MUTEX); 6635 } 6636 } 6637 scsi_log(ST_DEVINFO, st_label, CE_WARN, 6638 "transport rejected %d\n", status); 6639 bp->b_resid = bp->b_bcount; 6640 6641 ST_DO_KSTATS(bp, kstat_waitq_exit); 6642 ST_DO_ERRSTATS(un, st_transerrs); 6643 if ((bp == un->un_recov_buf) && (status == TRAN_BUSY)) { 6644 st_bioerror(bp, EBUSY); 6645 } else { 6646 st_bioerror(bp, EIO); 6647 st_set_pe_flag(un); 6648 } 6649 st_done_and_mutex_exit(un, bp); 6650 mutex_enter(ST_MUTEX); 6651 } 6652 6653 ASSERT(mutex_owned(ST_MUTEX)); 6654 } 6655 6656 /* 6657 * if the transport is busy, then put this bp back on the waitq 6658 */ 6659 static int 6660 st_handle_start_busy(struct scsi_tape *un, struct buf *bp, 6661 clock_t timeout_interval, int queued) 6662 { 6663 6664 pkt_info *pktinfo = BP_PKT(bp)->pkt_private; 6665 6666 ST_FUNC(ST_DEVINFO, st_handle_start_busy); 6667 6668 mutex_enter(ST_MUTEX); 6669 6670 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6671 "st_handle_start_busy()\n"); 6672 6673 /* 6674 * Check to see if we hit the retry timeout and one last check for 6675 * making sure this is the last on the runq, if it is not, we have 6676 * to fail 6677 */ 6678 if ((pktinfo->str_retry_cnt++ > st_retry_count) || 6679 ((queued) && (un->un_runql != bp))) { 6680 mutex_exit(ST_MUTEX); 6681 return (-1); 6682 } 6683 6684 if (queued) { 6685 /* put the bp back on the waitq */ 6686 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quef, bp); 6687 } 6688 6689 /* 6690 * Decrement un_ncmds so that this 6691 * gets thru' st_start() again. 6692 */ 6693 un->un_ncmds--; 6694 6695 if (queued) { 6696 /* 6697 * since this is an error case, we won't have to do this list 6698 * walking much. We've already made sure this bp was the 6699 * last on the runq 6700 */ 6701 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 6702 6703 /* 6704 * send a marker pkt, if appropriate 6705 */ 6706 st_hba_unflush(un); 6707 6708 } 6709 /* 6710 * all queues are aligned, we are just waiting to 6711 * transport, don't alloc any more buf p's, when 6712 * st_start is reentered. 6713 */ 6714 (void) timeout(st_start_restart, un, timeout_interval); 6715 6716 mutex_exit(ST_MUTEX); 6717 return (0); 6718 } 6719 6720 6721 /* 6722 * st_runout a callback that is called what a resource allocatation failed 6723 */ 6724 static int 6725 st_runout(caddr_t arg) 6726 { 6727 struct scsi_tape *un = (struct scsi_tape *)arg; 6728 struct buf *bp; 6729 int queued; 6730 6731 ASSERT(un != NULL); 6732 6733 ST_FUNC(ST_DEVINFO, st_runout); 6734 6735 mutex_enter(ST_MUTEX); 6736 6737 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_runout()\n"); 6738 6739 if (un->un_recov_buf_busy != 0) { 6740 bp = un->un_recov_buf; 6741 queued = 0; 6742 } else if (un->un_sbuf_busy != 0) { 6743 /* sbuf commands should only happen with an empty queue. */ 6744 ASSERT(un->un_quef == NULL); 6745 ASSERT(un->un_runqf == NULL); 6746 bp = un->un_sbufp; 6747 queued = 0; 6748 } else if (un->un_quef != NULL) { 6749 bp = un->un_quef; 6750 if (un->un_persistence && un->un_persist_errors) { 6751 mutex_exit(ST_MUTEX); 6752 bp->b_resid = bp->b_bcount; 6753 biodone(bp); 6754 return (1); 6755 } 6756 queued = 1; 6757 } else { 6758 ASSERT(1 == 0); 6759 mutex_exit(ST_MUTEX); 6760 return (1); 6761 } 6762 6763 /* 6764 * failed scsi_init_pkt(). If errno is zero its retryable. 6765 */ 6766 if ((bp != NULL) && (geterror(bp) != 0)) { 6767 6768 scsi_log(ST_DEVINFO, st_label, CE_WARN, 6769 "errors after pkt alloc (b_flags=0x%x, b_error=0x%x)\n", 6770 bp->b_flags, geterror(bp)); 6771 ASSERT((bp->b_flags & B_DONE) == 0); 6772 6773 if (queued) { 6774 (void) st_remove_from_queue(&un->un_quef, &un->un_quel, 6775 bp); 6776 } 6777 mutex_exit(ST_MUTEX); 6778 6779 ASSERT((bp->b_flags & B_DONE) == 0); 6780 6781 /* 6782 * Set resid, Error already set, then unblock calling thread. 6783 */ 6784 bp->b_resid = bp->b_bcount; 6785 biodone(bp); 6786 } else { 6787 /* 6788 * Try Again 6789 */ 6790 st_start(un); 6791 mutex_exit(ST_MUTEX); 6792 } 6793 6794 /* 6795 * Comments courtesy of sd.c 6796 * The scsi_init_pkt routine allows for the callback function to 6797 * return a 0 indicating the callback should be rescheduled or a 1 6798 * indicating not to reschedule. This routine always returns 1 6799 * because the driver always provides a callback function to 6800 * scsi_init_pkt. This results in a callback always being scheduled 6801 * (via the scsi_init_pkt callback implementation) if a resource 6802 * failure occurs. 6803 */ 6804 6805 return (1); 6806 } 6807 6808 /* 6809 * st_done_and_mutex_exit() 6810 * - remove bp from runq 6811 * - start up the next request 6812 * - if this was an asynch bp, clean up 6813 * - exit with released mutex 6814 */ 6815 static void 6816 st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp) 6817 { 6818 int pe_flagged = 0; 6819 struct scsi_pkt *pkt = BP_PKT(bp); 6820 pkt_info *pktinfo = pkt->pkt_private; 6821 6822 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 6823 #if !defined(lint) 6824 _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex)) 6825 #endif 6826 6827 ST_FUNC(ST_DEVINFO, st_done_and_mutex_exit); 6828 6829 ASSERT(mutex_owned(ST_MUTEX)); 6830 6831 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 6832 6833 un->un_ncmds--; 6834 cv_signal(&un->un_queue_cv); 6835 6836 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6837 "st_done_and_mutex_exit(): cmd=0x%x count=%ld resid=%ld flags=" 6838 "0x%x\n", pkt->pkt_cdbp[0], bp->b_bcount, 6839 bp->b_resid, bp->b_flags); 6840 6841 6842 /* 6843 * update kstats with transfer count info 6844 */ 6845 if (un->un_stats && (bp != un->un_sbufp) && IS_RW(bp)) { 6846 uint32_t n_done = bp->b_bcount - bp->b_resid; 6847 if (bp->b_flags & B_READ) { 6848 IOSP->reads++; 6849 IOSP->nread += n_done; 6850 } else { 6851 IOSP->writes++; 6852 IOSP->nwritten += n_done; 6853 } 6854 } 6855 6856 /* 6857 * Start the next one before releasing resources on this one, if 6858 * there is something on the queue and persistent errors has not been 6859 * flagged 6860 */ 6861 6862 if ((pe_flagged = (un->un_persistence && un->un_persist_errors)) != 0) { 6863 un->un_last_resid = bp->b_resid; 6864 un->un_last_count = bp->b_bcount; 6865 } 6866 6867 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 6868 cv_broadcast(&un->un_tape_busy_cv); 6869 } else if (un->un_quef && un->un_throttle && !pe_flagged && 6870 (bp != un->un_recov_buf)) { 6871 st_start(un); 6872 } 6873 6874 un->un_retry_ct = max(pktinfo->pkt_retry_cnt, pktinfo->str_retry_cnt); 6875 6876 if (bp == un->un_sbufp && (bp->b_flags & B_ASYNC)) { 6877 /* 6878 * Since we marked this ourselves as ASYNC, 6879 * there isn't anybody around waiting for 6880 * completion any more. 6881 */ 6882 uchar_t *cmd = pkt->pkt_cdbp; 6883 if (*cmd == SCMD_READ || *cmd == SCMD_WRITE) { 6884 bp->b_un.b_addr = (caddr_t)0; 6885 } 6886 ST_DEBUG(ST_DEVINFO, st_label, CE_NOTE, 6887 "st_done_and_mutex_exit(async): freeing pkt\n"); 6888 st_print_cdb(ST_DEVINFO, st_label, CE_NOTE, 6889 "CDB sent with B_ASYNC", (caddr_t)cmd); 6890 if (pkt) { 6891 scsi_destroy_pkt(pkt); 6892 } 6893 un->un_sbuf_busy = 0; 6894 cv_signal(&un->un_sbuf_cv); 6895 mutex_exit(ST_MUTEX); 6896 return; 6897 } 6898 6899 if (bp == un->un_sbufp && BP_UCMD(bp)) { 6900 /* 6901 * Copy status from scsi_pkt to uscsi_cmd 6902 * since st_uscsi_cmd needs it 6903 */ 6904 BP_UCMD(bp)->uscsi_status = SCBP_C(BP_PKT(bp)); 6905 } 6906 6907 6908 #ifdef STDEBUG 6909 if (((st_debug & 0x7) >= 4) && 6910 (((un->un_pos.blkno % 100) == 0) || 6911 (un->un_persistence && un->un_persist_errors))) { 6912 6913 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6914 "st_d_a_m_exit(): ncmds = %d, thr = %d, " 6915 "un_errno = %d, un_pe = %d\n", 6916 un->un_ncmds, un->un_throttle, un->un_errno, 6917 un->un_persist_errors); 6918 } 6919 6920 #endif 6921 6922 mutex_exit(ST_MUTEX); 6923 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6924 "st_done_and_mutex_exit: freeing pkt\n"); 6925 6926 if (pkt) { 6927 scsi_destroy_pkt(pkt); 6928 } 6929 6930 biodone(bp); 6931 6932 /* 6933 * now that we biodoned that command, if persistent errors have been 6934 * flagged, flush the waitq 6935 */ 6936 if (pe_flagged) 6937 st_flush(un); 6938 } 6939 6940 6941 /* 6942 * Tape error, flush tape driver queue. 6943 */ 6944 static void 6945 st_flush(struct scsi_tape *un) 6946 { 6947 struct buf *bp; 6948 6949 ST_FUNC(ST_DEVINFO, st_flush); 6950 6951 mutex_enter(ST_MUTEX); 6952 6953 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6954 "st_flush(), ncmds = %d, quef = 0x%p\n", 6955 un->un_ncmds, (void *)un->un_quef); 6956 6957 /* 6958 * if we still have commands outstanding, wait for them to come in 6959 * before flushing the queue, and make sure there is a queue 6960 */ 6961 if (un->un_ncmds || !un->un_quef) 6962 goto exit; 6963 6964 /* 6965 * we have no more commands outstanding, so let's deal with special 6966 * cases in the queue for EOM and FM. If we are here, and un_errno 6967 * is 0, then we know there was no error and we return a 0 read or 6968 * write before showing errors 6969 */ 6970 6971 /* Flush the wait queue. */ 6972 while ((bp = un->un_quef) != NULL) { 6973 un->un_quef = bp->b_actf; 6974 6975 bp->b_resid = bp->b_bcount; 6976 6977 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6978 "st_flush() : blkno=%d, err=%d, b_bcount=%ld\n", 6979 un->un_pos.blkno, un->un_errno, bp->b_bcount); 6980 6981 st_set_pe_errno(un); 6982 6983 bioerror(bp, un->un_errno); 6984 6985 mutex_exit(ST_MUTEX); 6986 /* it should have one, but check anyway */ 6987 if (BP_PKT(bp)) { 6988 scsi_destroy_pkt(BP_PKT(bp)); 6989 } 6990 biodone(bp); 6991 mutex_enter(ST_MUTEX); 6992 } 6993 6994 /* 6995 * It's not a bad practice to reset the 6996 * waitq tail pointer to NULL. 6997 */ 6998 un->un_quel = NULL; 6999 7000 exit: 7001 /* we mucked with the queue, so let others know about it */ 7002 cv_signal(&un->un_queue_cv); 7003 mutex_exit(ST_MUTEX); 7004 } 7005 7006 7007 /* 7008 * Utility functions 7009 */ 7010 static int 7011 st_determine_generic(struct scsi_tape *un) 7012 { 7013 int bsize; 7014 static char *cart = "0.25 inch cartridge"; 7015 char *sizestr; 7016 7017 ST_FUNC(ST_DEVINFO, st_determine_generic); 7018 7019 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7020 "st_determine_generic(un = 0x%p)\n", (void*)un); 7021 7022 ASSERT(mutex_owned(ST_MUTEX)); 7023 7024 if (st_modesense(un)) { 7025 return (-1); 7026 } 7027 7028 bsize = (un->un_mspl->high_bl << 16) | 7029 (un->un_mspl->mid_bl << 8) | 7030 (un->un_mspl->low_bl); 7031 7032 if (bsize == 0) { 7033 un->un_dp->options |= ST_VARIABLE; 7034 un->un_dp->bsize = 0; 7035 un->un_bsize = 0; 7036 } else if (bsize > ST_MAXRECSIZE_FIXED) { 7037 /* 7038 * record size of this device too big. 7039 * try and convert it to variable record length. 7040 * 7041 */ 7042 un->un_dp->options |= ST_VARIABLE; 7043 if (st_change_block_size(un, 0) != 0) { 7044 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 7045 "Fixed Record Size %d is too large\n", bsize); 7046 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 7047 "Cannot switch to variable record size\n"); 7048 un->un_dp->options &= ~ST_VARIABLE; 7049 return (-1); 7050 } 7051 } else if (st_change_block_size(un, 0) == 0) { 7052 /* 7053 * If the drive was set to a non zero block size, 7054 * See if it can be set to a zero block size. 7055 * If it works, ST_VARIABLE so user can set it as they want. 7056 */ 7057 un->un_dp->options |= ST_VARIABLE; 7058 un->un_dp->bsize = 0; 7059 un->un_bsize = 0; 7060 } else { 7061 un->un_dp->bsize = bsize; 7062 un->un_bsize = bsize; 7063 } 7064 7065 7066 switch (un->un_mspl->density) { 7067 default: 7068 case 0x0: 7069 /* 7070 * default density, cannot determine any other 7071 * information. 7072 */ 7073 sizestr = "Unknown type- assuming 0.25 inch cartridge"; 7074 un->un_dp->type = ST_TYPE_DEFAULT; 7075 un->un_dp->options |= (ST_AUTODEN_OVERRIDE|ST_QIC); 7076 break; 7077 case 0x1: 7078 case 0x2: 7079 case 0x3: 7080 case 0x6: 7081 /* 7082 * 1/2" reel 7083 */ 7084 sizestr = "0.50 inch reel"; 7085 un->un_dp->type = ST_TYPE_REEL; 7086 un->un_dp->options |= ST_REEL; 7087 un->un_dp->densities[0] = 0x1; 7088 un->un_dp->densities[1] = 0x2; 7089 un->un_dp->densities[2] = 0x6; 7090 un->un_dp->densities[3] = 0x3; 7091 break; 7092 case 0x4: 7093 case 0x5: 7094 case 0x7: 7095 case 0x0b: 7096 7097 /* 7098 * Quarter inch. 7099 */ 7100 sizestr = cart; 7101 un->un_dp->type = ST_TYPE_DEFAULT; 7102 un->un_dp->options |= ST_QIC; 7103 7104 un->un_dp->densities[1] = 0x4; 7105 un->un_dp->densities[2] = 0x5; 7106 un->un_dp->densities[3] = 0x7; 7107 un->un_dp->densities[0] = 0x0b; 7108 break; 7109 7110 case 0x0f: 7111 case 0x10: 7112 case 0x11: 7113 case 0x12: 7114 /* 7115 * QIC-120, QIC-150, QIC-320, QIC-600 7116 */ 7117 sizestr = cart; 7118 un->un_dp->type = ST_TYPE_DEFAULT; 7119 un->un_dp->options |= ST_QIC; 7120 un->un_dp->densities[0] = 0x0f; 7121 un->un_dp->densities[1] = 0x10; 7122 un->un_dp->densities[2] = 0x11; 7123 un->un_dp->densities[3] = 0x12; 7124 break; 7125 7126 case 0x09: 7127 case 0x0a: 7128 case 0x0c: 7129 case 0x0d: 7130 /* 7131 * 1/2" cartridge tapes. Include HI-TC. 7132 */ 7133 sizestr = cart; 7134 sizestr[2] = '5'; 7135 sizestr[3] = '0'; 7136 un->un_dp->type = ST_TYPE_HIC; 7137 un->un_dp->densities[0] = 0x09; 7138 un->un_dp->densities[1] = 0x0a; 7139 un->un_dp->densities[2] = 0x0c; 7140 un->un_dp->densities[3] = 0x0d; 7141 break; 7142 7143 case 0x13: 7144 /* DDS-2/DDS-3 scsi spec densities */ 7145 case 0x24: 7146 case 0x25: 7147 case 0x26: 7148 sizestr = "DAT Data Storage (DDS)"; 7149 un->un_dp->type = ST_TYPE_DAT; 7150 un->un_dp->options |= ST_AUTODEN_OVERRIDE; 7151 break; 7152 7153 case 0x14: 7154 /* 7155 * Helical Scan (Exabyte) devices 7156 */ 7157 sizestr = "8mm helical scan cartridge"; 7158 un->un_dp->type = ST_TYPE_EXABYTE; 7159 un->un_dp->options |= ST_AUTODEN_OVERRIDE; 7160 break; 7161 } 7162 7163 /* 7164 * Assume LONG ERASE, BSF and BSR 7165 */ 7166 7167 un->un_dp->options |= 7168 (ST_LONG_ERASE | ST_UNLOADABLE | ST_BSF | ST_BSR | ST_KNOWS_EOD); 7169 7170 /* 7171 * Only if mode sense data says no buffered write, set NOBUF 7172 */ 7173 if (un->un_mspl->bufm == 0) 7174 un->un_dp->options |= ST_NOBUF; 7175 7176 /* 7177 * set up large read and write retry counts 7178 */ 7179 7180 un->un_dp->max_rretries = un->un_dp->max_wretries = 1000; 7181 7182 /* 7183 * If this is a 0.50 inch reel tape, and 7184 * it is *not* variable mode, try and 7185 * set it to variable record length 7186 * mode. 7187 */ 7188 if ((un->un_dp->options & ST_REEL) && un->un_bsize != 0 && 7189 (un->un_dp->options & ST_VARIABLE)) { 7190 if (st_change_block_size(un, 0) == 0) { 7191 un->un_dp->bsize = 0; 7192 un->un_mspl->high_bl = un->un_mspl->mid_bl = 7193 un->un_mspl->low_bl = 0; 7194 } 7195 } 7196 7197 /* 7198 * Write to console about type of device found 7199 */ 7200 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 7201 "Generic Drive, Vendor=%s\n\t%s", un->un_dp->name, 7202 sizestr); 7203 if (un->un_dp->options & ST_VARIABLE) { 7204 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7205 "!Variable record length I/O\n"); 7206 } else { 7207 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7208 "!Fixed record length (%d byte blocks) I/O\n", 7209 un->un_dp->bsize); 7210 } 7211 ASSERT(mutex_owned(ST_MUTEX)); 7212 return (0); 7213 } 7214 7215 static int 7216 st_determine_density(struct scsi_tape *un, int rw) 7217 { 7218 int rval = 0; 7219 7220 ST_FUNC(ST_DEVINFO, st_determine_density); 7221 7222 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7223 "st_determine_density(un = 0x%p, rw = %s)\n", 7224 (void*)un, (rw == B_WRITE ? wr_str: rd_str)); 7225 7226 ASSERT(mutex_owned(ST_MUTEX)); 7227 7228 /* 7229 * If we're past BOT, density is determined already. 7230 */ 7231 if (un->un_pos.pmode == logical) { 7232 if (un->un_pos.lgclblkno != 0) { 7233 goto exit; 7234 } 7235 } else if (un->un_pos.pmode == legacy) { 7236 if ((un->un_pos.fileno != 0) || (un->un_pos.blkno != 0)) { 7237 /* 7238 * XXX: put in a bitch message about attempting to 7239 * XXX: change density past BOT. 7240 */ 7241 goto exit; 7242 } 7243 } else { 7244 goto exit; 7245 } 7246 if ((un->un_pos.pmode == logical) && 7247 (un->un_pos.lgclblkno != 0)) { 7248 goto exit; 7249 } 7250 7251 7252 /* 7253 * If we're going to be writing, we set the density 7254 */ 7255 if (rw == 0 || rw == B_WRITE) { 7256 /* un_curdens is used as an index into densities table */ 7257 un->un_curdens = MT_DENSITY(un->un_dev); 7258 if (st_set_density(un)) { 7259 rval = -1; 7260 } 7261 goto exit; 7262 } 7263 7264 /* 7265 * If density is known already, 7266 * we don't have to get it again.(?) 7267 */ 7268 if (!un->un_density_known) { 7269 if (st_get_density(un)) { 7270 rval = -1; 7271 } 7272 } 7273 7274 exit: 7275 ASSERT(mutex_owned(ST_MUTEX)); 7276 return (rval); 7277 } 7278 7279 7280 /* 7281 * Try to determine density. We do this by attempting to read the 7282 * first record off the tape, cycling through the available density 7283 * codes as we go. 7284 */ 7285 7286 static int 7287 st_get_density(struct scsi_tape *un) 7288 { 7289 int succes = 0, rval = -1, i; 7290 uint_t size; 7291 uchar_t dens, olddens; 7292 7293 ST_FUNC(ST_DEVINFO, st_get_density); 7294 7295 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7296 "st_get_density(un = 0x%p)\n", (void*)un); 7297 7298 ASSERT(mutex_owned(ST_MUTEX)); 7299 7300 /* 7301 * If Auto Density override is enabled The drive has 7302 * only one density and there is no point in attempting 7303 * find the correct one. 7304 * 7305 * Since most modern drives auto detect the density 7306 * and format of the recorded media before they come 7307 * ready. What this function does is a legacy behavior 7308 * and modern drives not only don't need it, The backup 7309 * utilities that do positioning via uscsi find the un- 7310 * expected rewinds problematic. 7311 * 7312 * The drives that need this are old reel to reel devices. 7313 * I took a swag and said they must be scsi-1 or older. 7314 * I don't beleave there will any of the newer devices 7315 * that need this. There will be some scsi-1 devices that 7316 * don't need this but I don't think they will be using the 7317 * BIG aftermarket backup and restore utilitys. 7318 */ 7319 if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) || 7320 (un->un_sd->sd_inq->inq_ansi > 1)) { 7321 un->un_density_known = 1; 7322 rval = 0; 7323 goto exit; 7324 } 7325 7326 /* 7327 * This will only work on variable record length tapes 7328 * if and only if all variable record length tapes autodensity 7329 * select. 7330 */ 7331 size = (unsigned)(un->un_dp->bsize ? un->un_dp->bsize : SECSIZE); 7332 un->un_tmpbuf = kmem_alloc(size, KM_SLEEP); 7333 7334 /* 7335 * Start at the specified density 7336 */ 7337 7338 dens = olddens = un->un_curdens = MT_DENSITY(un->un_dev); 7339 7340 for (i = 0; i < NDENSITIES; i++, ((un->un_curdens == NDENSITIES - 1) ? 7341 (un->un_curdens = 0) : (un->un_curdens += 1))) { 7342 /* 7343 * If we've done this density before, 7344 * don't bother to do it again. 7345 */ 7346 dens = un->un_dp->densities[un->un_curdens]; 7347 if (i > 0 && dens == olddens) 7348 continue; 7349 olddens = dens; 7350 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7351 "trying density 0x%x\n", dens); 7352 if (st_set_density(un)) { 7353 continue; 7354 } 7355 7356 /* 7357 * XXX - the creates lots of headaches and slowdowns - must 7358 * fix. 7359 */ 7360 succes = (st_cmd(un, SCMD_READ, (int)size, SYNC_CMD) == 0); 7361 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 7362 break; 7363 } 7364 if (succes) { 7365 st_init(un); 7366 rval = 0; 7367 un->un_density_known = 1; 7368 break; 7369 } 7370 } 7371 kmem_free(un->un_tmpbuf, size); 7372 un->un_tmpbuf = 0; 7373 7374 exit: 7375 ASSERT(mutex_owned(ST_MUTEX)); 7376 return (rval); 7377 } 7378 7379 static int 7380 st_set_density(struct scsi_tape *un) 7381 { 7382 int rval = 0; 7383 7384 ST_FUNC(ST_DEVINFO, st_set_density); 7385 7386 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7387 "st_set_density(un = 0x%p): density = 0x%x\n", (void*)un, 7388 un->un_dp->densities[un->un_curdens]); 7389 7390 ASSERT(mutex_owned(ST_MUTEX)); 7391 7392 un->un_mspl->density = un->un_dp->densities[un->un_curdens]; 7393 7394 if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) == 0) { 7395 /* 7396 * If auto density override is not set, Use mode select 7397 * to set density and compression. 7398 */ 7399 if (st_modeselect(un)) { 7400 rval = -1; 7401 } 7402 } else if ((un->un_dp->options & ST_MODE_SEL_COMP) != 0) { 7403 /* 7404 * If auto density and mode select compression are set, 7405 * This is a drive with one density code but compression 7406 * can be enabled or disabled. 7407 * Set compression but no need to set density. 7408 */ 7409 rval = st_set_compression(un); 7410 if ((rval != 0) && (rval != EALREADY)) { 7411 rval = -1; 7412 } else { 7413 rval = 0; 7414 } 7415 } 7416 7417 /* If sucessful set density and/or compression, mark density known */ 7418 if (rval == 0) { 7419 un->un_density_known = 1; 7420 } 7421 7422 ASSERT(mutex_owned(ST_MUTEX)); 7423 return (rval); 7424 } 7425 7426 static int 7427 st_loadtape(struct scsi_tape *un) 7428 { 7429 int rval; 7430 7431 ST_FUNC(ST_DEVINFO, st_loadtape); 7432 7433 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7434 "st_loadtape(un = 0x%p)\n", (void*) un); 7435 7436 ASSERT(mutex_owned(ST_MUTEX)); 7437 7438 rval = st_update_block_pos(un, st_cmd, 0); 7439 if (rval == EACCES) { 7440 return (rval); 7441 } 7442 7443 /* 7444 * 'LOAD' the tape to BOT by rewinding 7445 */ 7446 rval = st_cmd(un, SCMD_REWIND, 1, SYNC_CMD); 7447 if (rval == 0) { 7448 st_init(un); 7449 un->un_density_known = 0; 7450 } 7451 7452 ASSERT(mutex_owned(ST_MUTEX)); 7453 return (rval); 7454 } 7455 7456 7457 /* 7458 * Note: QIC devices aren't so smart. If you try to append 7459 * after EOM, the write can fail because the device doesn't know 7460 * it's at EOM. In that case, issue a read. The read should fail 7461 * because there's no data, but the device knows it's at EOM, 7462 * so a subsequent write should succeed. To further confuse matters, 7463 * the target returns the same error if the tape is positioned 7464 * such that a write would overwrite existing data. That's why 7465 * we have to do the append test. A read in the middle of 7466 * recorded data would succeed, thus indicating we're attempting 7467 * something illegal. 7468 */ 7469 7470 7471 static void 7472 st_test_append(struct buf *bp) 7473 { 7474 dev_t dev = bp->b_edev; 7475 struct scsi_tape *un; 7476 uchar_t status; 7477 unsigned bcount; 7478 7479 un = ddi_get_soft_state(st_state, MTUNIT(dev)); 7480 7481 ST_FUNC(ST_DEVINFO, st_test_append); 7482 7483 ASSERT(mutex_owned(ST_MUTEX)); 7484 7485 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7486 "st_test_append(): fileno %d\n", un->un_pos.fileno); 7487 7488 un->un_laststate = un->un_state; 7489 un->un_state = ST_STATE_APPEND_TESTING; 7490 un->un_test_append = 0; 7491 7492 /* 7493 * first, map in the buffer, because we're doing a double write -- 7494 * first into the kernel, then onto the tape. 7495 */ 7496 bp_mapin(bp); 7497 7498 /* 7499 * get a copy of the data.... 7500 */ 7501 un->un_tmpbuf = kmem_alloc((unsigned)bp->b_bcount, KM_SLEEP); 7502 bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount); 7503 7504 /* 7505 * attempt the write.. 7506 */ 7507 7508 if (st_cmd(un, (int)SCMD_WRITE, (int)bp->b_bcount, SYNC_CMD) == 0) { 7509 success: 7510 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7511 "append write succeeded\n"); 7512 bp->b_resid = un->un_sbufp->b_resid; 7513 mutex_exit(ST_MUTEX); 7514 bcount = (unsigned)bp->b_bcount; 7515 biodone(bp); 7516 mutex_enter(ST_MUTEX); 7517 un->un_laststate = un->un_state; 7518 un->un_state = ST_STATE_OPEN; 7519 kmem_free(un->un_tmpbuf, bcount); 7520 un->un_tmpbuf = NULL; 7521 return; 7522 } 7523 7524 /* 7525 * The append failed. Do a short read. If that fails, we are at EOM 7526 * so we can retry the write command. If that succeeds, than we're 7527 * all screwed up (the controller reported a real error). 7528 * 7529 * XXX: should the dummy read be > SECSIZE? should it be the device's 7530 * XXX: block size? 7531 * 7532 */ 7533 status = un->un_status; 7534 un->un_status = 0; 7535 (void) st_cmd(un, SCMD_READ, SECSIZE, SYNC_CMD); 7536 if (un->un_status == KEY_BLANK_CHECK) { 7537 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7538 "append at EOM\n"); 7539 /* 7540 * Okay- the read failed. We should actually have confused 7541 * the controller enough to allow writing. In any case, the 7542 * i/o is on its own from here on out. 7543 */ 7544 un->un_laststate = un->un_state; 7545 un->un_state = ST_STATE_OPEN; 7546 bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount); 7547 if (st_cmd(un, (int)SCMD_WRITE, (int)bp->b_bcount, 7548 SYNC_CMD) == 0) { 7549 goto success; 7550 } 7551 } 7552 7553 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7554 "append write failed- not at EOM\n"); 7555 bp->b_resid = bp->b_bcount; 7556 st_bioerror(bp, EIO); 7557 7558 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 7559 "st_test_append : EIO : append write failed - not at EOM"); 7560 7561 /* 7562 * backspace one record to get back to where we were 7563 */ 7564 if (st_cmd(un, SCMD_SPACE, Blk(-1), SYNC_CMD)) { 7565 un->un_pos.pmode = invalid; 7566 } 7567 7568 un->un_err_resid = bp->b_resid; 7569 un->un_status = status; 7570 7571 /* 7572 * Note: biodone will do a bp_mapout() 7573 */ 7574 mutex_exit(ST_MUTEX); 7575 bcount = (unsigned)bp->b_bcount; 7576 biodone(bp); 7577 mutex_enter(ST_MUTEX); 7578 un->un_laststate = un->un_state; 7579 un->un_state = ST_STATE_OPEN_PENDING_IO; 7580 kmem_free(un->un_tmpbuf, bcount); 7581 un->un_tmpbuf = NULL; 7582 } 7583 7584 /* 7585 * Special command handler 7586 */ 7587 7588 /* 7589 * common st_cmd code. The fourth parameter states 7590 * whether the caller wishes to await the results 7591 * Note the release of the mutex during most of the function 7592 */ 7593 static int 7594 st_cmd(struct scsi_tape *un, int com, int64_t count, int wait) 7595 { 7596 struct buf *bp; 7597 int err; 7598 uint_t last_err_resid; 7599 7600 ST_FUNC(ST_DEVINFO, st_cmd); 7601 7602 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7603 "st_cmd(dev = 0x%lx, com = 0x%x, count = %"PRIx64", wait = %d)\n", 7604 un->un_dev, com, count, wait); 7605 7606 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 7607 ASSERT(mutex_owned(ST_MUTEX)); 7608 7609 #ifdef STDEBUG 7610 if ((st_debug & 0x7)) { 7611 st_debug_cmds(un, com, count, wait); 7612 } 7613 #endif 7614 7615 st_wait_for_io(un); 7616 7617 /* check to see if this command requires the drive to be reserved */ 7618 err = st_check_cmd_for_need_to_reserve(un, com, count); 7619 7620 if (err) { 7621 return (err); 7622 } 7623 7624 /* 7625 * A space command is not recoverable if we don't know were we 7626 * were when it was issued. 7627 */ 7628 if ((com == SCMD_SPACE) || (com == SCMD_SPACE_G4)) { 7629 (void) st_update_block_pos(un, st_cmd, 0); 7630 } 7631 7632 /* 7633 * Forground should not be doing anything while recovery is active. 7634 */ 7635 ASSERT(un->un_recov_buf_busy == 0); 7636 7637 while (un->un_sbuf_busy) 7638 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 7639 un->un_sbuf_busy = 1; 7640 7641 bp = un->un_sbufp; 7642 bzero(bp, sizeof (buf_t)); 7643 7644 bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC; 7645 7646 err = st_setup_cmd(un, bp, com, count); 7647 7648 un->un_sbuf_busy = 0; 7649 7650 /* 7651 * If was a space command need to update logical block position. 7652 * Only do this if the command was sucessful or it will mask the fact 7653 * that the space command failed by promoting the pmode to logical. 7654 */ 7655 if (((com == SCMD_SPACE) || (com == SCMD_SPACE_G4)) && 7656 (un->un_pos.pmode != invalid)) { 7657 un->un_running.pmode = invalid; 7658 last_err_resid = un->un_err_resid; 7659 (void) st_update_block_pos(un, st_cmd, 1); 7660 /* 7661 * Set running position to invalid so it updates on the 7662 * next command. 7663 */ 7664 un->un_running.pmode = invalid; 7665 un->un_err_resid = last_err_resid; 7666 } 7667 7668 cv_signal(&un->un_sbuf_cv); 7669 7670 return (err); 7671 } 7672 7673 static int 7674 st_setup_cmd(struct scsi_tape *un, buf_t *bp, int com, int64_t count) 7675 { 7676 int err; 7677 dev_t dev = un->un_dev; 7678 7679 ST_FUNC(ST_DEVINFO, st_setup_cmd); 7680 /* 7681 * Set count to the actual size of the data tranfer. 7682 * For commands with no data transfer, set bp->b_bcount 7683 * to the value to be used when constructing the 7684 * cdb in st_make_cmd(). 7685 */ 7686 switch (com) { 7687 case SCMD_READ: 7688 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7689 "special read %"PRId64"\n", count); 7690 bp->b_flags |= B_READ; 7691 bp->b_un.b_addr = un->un_tmpbuf; 7692 break; 7693 7694 case SCMD_WRITE: 7695 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7696 "special write %"PRId64"\n", count); 7697 bp->b_un.b_addr = un->un_tmpbuf; 7698 break; 7699 7700 case SCMD_WRITE_FILE_MARK: 7701 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7702 "write %"PRId64" file marks\n", count); 7703 bp->b_bcount = count; 7704 count = 0; 7705 break; 7706 7707 case SCMD_REWIND: 7708 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "rewind\n"); 7709 bp->b_bcount = count; 7710 count = 0; 7711 break; 7712 7713 case SCMD_SPACE: 7714 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "space\n"); 7715 /* 7716 * If the user could have entered a number that will 7717 * not fit in the 12 bit count field of space(8), 7718 * use space(16). 7719 */ 7720 if (((int64_t)SPACE_CNT(count) > 0x7fffff) || 7721 ((int64_t)SPACE_CNT(count) < -(0x7fffff))) { 7722 com = SCMD_SPACE_G4; 7723 } 7724 bp->b_bcount = count; 7725 count = 0; 7726 break; 7727 7728 case SCMD_RESERVE: 7729 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "reserve"); 7730 bp->b_bcount = 0; 7731 count = 0; 7732 break; 7733 7734 case SCMD_RELEASE: 7735 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "release"); 7736 bp->b_bcount = 0; 7737 count = 0; 7738 break; 7739 7740 case SCMD_LOAD: 7741 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7742 "%s tape\n", (count & LD_LOAD) ? "load" : "unload"); 7743 bp->b_bcount = count; 7744 count = 0; 7745 break; 7746 7747 case SCMD_ERASE: 7748 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7749 "erase tape\n"); 7750 bp->b_bcount = count; 7751 count = 0; 7752 break; 7753 7754 case SCMD_MODE_SENSE: 7755 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7756 "mode sense\n"); 7757 bp->b_flags |= B_READ; 7758 bp->b_un.b_addr = (caddr_t)(un->un_mspl); 7759 break; 7760 7761 case SCMD_MODE_SELECT: 7762 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7763 "mode select\n"); 7764 bp->b_un.b_addr = (caddr_t)(un->un_mspl); 7765 break; 7766 7767 case SCMD_READ_BLKLIM: 7768 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7769 "read block limits\n"); 7770 bp->b_bcount = count; 7771 bp->b_flags |= B_READ; 7772 bp->b_un.b_addr = (caddr_t)(un->un_rbl); 7773 break; 7774 7775 case SCMD_TEST_UNIT_READY: 7776 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7777 "test unit ready\n"); 7778 bp->b_bcount = 0; 7779 count = 0; 7780 break; 7781 7782 case SCMD_DOORLOCK: 7783 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7784 "%s tape\n", (count & MR_LOCK) ? "lock" : "unlock"); 7785 bp->b_bcount = count = 0; 7786 break; 7787 7788 case SCMD_READ_POSITION: 7789 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7790 "read position\n"); 7791 switch (un->un_read_pos_type) { 7792 case LONG_POS: 7793 count = sizeof (tape_position_long_t); 7794 break; 7795 case EXT_POS: 7796 count = min(count, sizeof (tape_position_ext_t)); 7797 break; 7798 case SHORT_POS: 7799 count = sizeof (tape_position_t); 7800 break; 7801 default: 7802 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 7803 "Unknown read position type 0x%x in " 7804 "st_make_cmd()\n", un->un_read_pos_type); 7805 } 7806 bp->b_bcount = count; 7807 bp->b_flags |= B_READ; 7808 bp->b_un.b_addr = (caddr_t)un->un_read_pos_data; 7809 break; 7810 7811 default: 7812 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 7813 "Unhandled scsi command 0x%x in st_setup_cmd()\n", com); 7814 } 7815 7816 mutex_exit(ST_MUTEX); 7817 7818 if (count > 0) { 7819 int flg = (bp->b_flags & B_READ) ? B_READ : B_WRITE; 7820 /* 7821 * We're going to do actual I/O. 7822 * Set things up for physio. 7823 */ 7824 struct iovec aiov; 7825 struct uio auio; 7826 struct uio *uio = &auio; 7827 7828 bzero(&auio, sizeof (struct uio)); 7829 bzero(&aiov, sizeof (struct iovec)); 7830 aiov.iov_base = bp->b_un.b_addr; 7831 aiov.iov_len = count; 7832 7833 uio->uio_iov = &aiov; 7834 uio->uio_iovcnt = 1; 7835 uio->uio_resid = aiov.iov_len; 7836 uio->uio_segflg = UIO_SYSSPACE; 7837 7838 /* 7839 * Let physio do the rest... 7840 */ 7841 bp->b_forw = (struct buf *)(uintptr_t)com; 7842 bp->b_back = NULL; 7843 err = physio(st_strategy, bp, dev, flg, st_minphys, uio); 7844 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7845 "st_setup_cmd: physio returns %d\n", err); 7846 } else { 7847 /* 7848 * Mimic physio 7849 */ 7850 bp->b_forw = (struct buf *)(uintptr_t)com; 7851 bp->b_back = NULL; 7852 bp->b_edev = dev; 7853 bp->b_dev = cmpdev(dev); 7854 bp->b_blkno = 0; 7855 bp->b_resid = 0; 7856 (void) st_strategy(bp); 7857 if (bp->b_flags & B_ASYNC) { 7858 /* 7859 * This is an async command- the caller won't wait 7860 * and doesn't care about errors. 7861 */ 7862 mutex_enter(ST_MUTEX); 7863 return (0); 7864 } 7865 7866 /* 7867 * BugTraq #4260046 7868 * ---------------- 7869 * Restore Solaris 2.5.1 behavior, namely call biowait 7870 * unconditionally. The old comment said... 7871 * 7872 * "if strategy was flagged with persistent errors, we would 7873 * have an error here, and the bp would never be sent, so we 7874 * don't want to wait on a bp that was never sent...or hang" 7875 * 7876 * The new rationale, courtesy of Chitrank... 7877 * 7878 * "we should unconditionally biowait() here because 7879 * st_strategy() will do a biodone() in the persistent error 7880 * case and the following biowait() will return immediately. 7881 * If not, in the case of "errors after pkt alloc" in 7882 * st_start(), we will not biowait here which will cause the 7883 * next biowait() to return immediately which will cause 7884 * us to send out the next command. In the case where both of 7885 * these use the sbuf, when the first command completes we'll 7886 * free the packet attached to sbuf and the same pkt will 7887 * get freed again when we complete the second command. 7888 * see esc 518987. BTW, it is necessary to do biodone() in 7889 * st_start() for the pkt alloc failure case because physio() 7890 * does biowait() and will hang if we don't do biodone()" 7891 */ 7892 7893 err = biowait(bp); 7894 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7895 "st_setup_cmd: biowait returns %d\n", err); 7896 } 7897 7898 mutex_enter(ST_MUTEX); 7899 7900 return (err); 7901 } 7902 7903 static int 7904 st_set_compression(struct scsi_tape *un) 7905 { 7906 int rval; 7907 int turn_compression_on; 7908 minor_t minor; 7909 7910 ST_FUNC(ST_DEVINFO, st_set_compression); 7911 7912 /* 7913 * Drive either dosn't have compression or it is controlled with 7914 * special density codes. Return ENOTTY so caller 7915 * knows nothing was done. 7916 */ 7917 if ((un->un_dp->options & ST_MODE_SEL_COMP) == 0) { 7918 un->un_comp_page = 0; 7919 return (ENOTTY); 7920 } 7921 7922 /* set compression based on minor node opened */ 7923 minor = MT_DENSITY(un->un_dev); 7924 7925 /* 7926 * If this the compression density or 7927 * the drive has two densities and uses mode select for 7928 * control of compression turn on compression for MT_DENSITY2 7929 * as well. 7930 */ 7931 if ((minor == ST_COMPRESSION_DENSITY) || 7932 (minor == MT_DENSITY(MT_DENSITY2)) && 7933 (un->un_dp->densities[0] == un->un_dp->densities[1]) && 7934 (un->un_dp->densities[2] == un->un_dp->densities[3]) && 7935 (un->un_dp->densities[0] != un->un_dp->densities[2])) { 7936 7937 turn_compression_on = 1; 7938 } else { 7939 turn_compression_on = 0; 7940 } 7941 7942 un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16); 7943 un->un_mspl->mid_bl = (uchar_t)(un->un_bsize >> 8); 7944 un->un_mspl->low_bl = (uchar_t)(un->un_bsize); 7945 7946 /* 7947 * Need to determine which page does the device use for compression. 7948 * First try the data compression page. If this fails try the device 7949 * configuration page 7950 */ 7951 7952 if ((un->un_comp_page & ST_DEV_DATACOMP_PAGE) == ST_DEV_DATACOMP_PAGE) { 7953 rval = st_set_datacomp_page(un, turn_compression_on); 7954 if (rval == EALREADY) { 7955 return (rval); 7956 } 7957 if (rval != 0) { 7958 if (un->un_status == KEY_ILLEGAL_REQUEST) { 7959 /* 7960 * This device does not support data 7961 * compression page 7962 */ 7963 un->un_comp_page = ST_DEV_CONFIG_PAGE; 7964 } else if (un->un_state >= ST_STATE_OPEN) { 7965 un->un_pos.pmode = invalid; 7966 rval = EIO; 7967 } else { 7968 rval = -1; 7969 } 7970 } else { 7971 un->un_comp_page = ST_DEV_DATACOMP_PAGE; 7972 } 7973 } 7974 7975 if ((un->un_comp_page & ST_DEV_CONFIG_PAGE) == ST_DEV_CONFIG_PAGE) { 7976 rval = st_set_devconfig_page(un, turn_compression_on); 7977 if (rval == EALREADY) { 7978 return (rval); 7979 } 7980 if (rval != 0) { 7981 if (un->un_status == KEY_ILLEGAL_REQUEST) { 7982 /* 7983 * This device does not support 7984 * compression at all advice the 7985 * user and unset ST_MODE_SEL_COMP 7986 */ 7987 un->un_dp->options &= ~ST_MODE_SEL_COMP; 7988 un->un_comp_page = 0; 7989 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7990 "Device Does Not Support Compression\n"); 7991 } else if (un->un_state >= ST_STATE_OPEN) { 7992 un->un_pos.pmode = invalid; 7993 rval = EIO; 7994 } else { 7995 rval = -1; 7996 } 7997 } 7998 } 7999 8000 return (rval); 8001 } 8002 8003 /* 8004 * set or unset compression thru device configuration page. 8005 */ 8006 static int 8007 st_set_devconfig_page(struct scsi_tape *un, int compression_on) 8008 { 8009 unsigned char cflag; 8010 int rval = 0; 8011 8012 8013 ST_FUNC(ST_DEVINFO, st_set_devconfig_page); 8014 8015 ASSERT(mutex_owned(ST_MUTEX)); 8016 8017 /* 8018 * if the mode sense page is not the correct one, load the correct one. 8019 */ 8020 if (un->un_mspl->page_code != ST_DEV_CONFIG_PAGE) { 8021 rval = st_gen_mode_sense(un, st_uscsi_cmd, ST_DEV_CONFIG_PAGE, 8022 un->un_mspl, sizeof (struct seq_mode)); 8023 if (rval) 8024 return (rval); 8025 } 8026 8027 /* 8028 * Figure what to set compression flag to. 8029 */ 8030 if (compression_on) { 8031 /* They have selected a compression node */ 8032 if (un->un_dp->type == ST_TYPE_FUJI) { 8033 cflag = 0x84; /* use EDRC */ 8034 } else { 8035 cflag = ST_DEV_CONFIG_DEF_COMP; 8036 } 8037 } else { 8038 cflag = ST_DEV_CONFIG_NO_COMP; 8039 } 8040 8041 /* 8042 * If compression is already set the way it was requested. 8043 * And if this not the first time we has tried. 8044 */ 8045 if ((cflag == un->un_mspl->page.dev.comp_alg) && 8046 (un->un_comp_page == ST_DEV_CONFIG_PAGE)) { 8047 return (EALREADY); 8048 } 8049 8050 un->un_mspl->page.dev.comp_alg = cflag; 8051 /* 8052 * need to send mode select even if correct compression is 8053 * already set since need to set density code 8054 */ 8055 8056 #ifdef STDEBUG 8057 if ((st_debug & 0x7) >= 6) { 8058 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 8059 "st_set_devconfig_page: sense data for mode select", 8060 (char *)un->un_mspl, sizeof (struct seq_mode)); 8061 } 8062 #endif 8063 rval = st_gen_mode_select(un, st_uscsi_cmd, un->un_mspl, 8064 sizeof (struct seq_mode)); 8065 8066 return (rval); 8067 } 8068 8069 /* 8070 * set/reset compression bit thru data compression page 8071 */ 8072 static int 8073 st_set_datacomp_page(struct scsi_tape *un, int compression_on) 8074 { 8075 int compression_on_already; 8076 int rval = 0; 8077 8078 8079 ST_FUNC(ST_DEVINFO, st_set_datacomp_page); 8080 8081 ASSERT(mutex_owned(ST_MUTEX)); 8082 8083 /* 8084 * if the mode sense page is not the correct one, load the correct one. 8085 */ 8086 if (un->un_mspl->page_code != ST_DEV_DATACOMP_PAGE) { 8087 rval = st_gen_mode_sense(un, st_uscsi_cmd, ST_DEV_DATACOMP_PAGE, 8088 un->un_mspl, sizeof (struct seq_mode)); 8089 if (rval) 8090 return (rval); 8091 } 8092 8093 /* 8094 * If drive is not capable of compression (at this time) 8095 * return EALREADY so caller doesn't think that this page 8096 * is not supported. This check is for drives that can 8097 * disable compression from the front panel or configuration. 8098 * I doubt that a drive that supports this page is not really 8099 * capable of compression. 8100 */ 8101 if (un->un_mspl->page.comp.dcc == 0) { 8102 return (EALREADY); 8103 } 8104 8105 /* See if compression currently turned on */ 8106 if (un->un_mspl->page.comp.dce) { 8107 compression_on_already = 1; 8108 } else { 8109 compression_on_already = 0; 8110 } 8111 8112 /* 8113 * If compression is already set the way it was requested. 8114 * And if this not the first time we has tried. 8115 */ 8116 if ((compression_on == compression_on_already) && 8117 (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) { 8118 return (EALREADY); 8119 } 8120 8121 /* 8122 * if we are already set to the appropriate compression 8123 * mode, don't set it again 8124 */ 8125 if (compression_on) { 8126 /* compression selected */ 8127 un->un_mspl->page.comp.dce = 1; 8128 } else { 8129 un->un_mspl->page.comp.dce = 0; 8130 } 8131 8132 8133 #ifdef STDEBUG 8134 if ((st_debug & 0x7) >= 6) { 8135 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 8136 "st_set_datacomp_page: sense data for mode select", 8137 (char *)un->un_mspl, sizeof (struct seq_mode)); 8138 } 8139 #endif 8140 rval = st_gen_mode_select(un, st_uscsi_cmd, un->un_mspl, 8141 sizeof (struct seq_mode)); 8142 8143 return (rval); 8144 } 8145 8146 static int 8147 st_modesense(struct scsi_tape *un) 8148 { 8149 int rval; 8150 uchar_t page; 8151 8152 ST_FUNC(ST_DEVINFO, st_modesense); 8153 8154 page = un->un_comp_page; 8155 8156 switch (page) { 8157 case ST_DEV_DATACOMP_PAGE: 8158 case ST_DEV_CONFIG_PAGE: /* FALLTHROUGH */ 8159 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, un->un_mspl, 8160 sizeof (struct seq_mode)); 8161 break; 8162 8163 case ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE: 8164 if (un->un_dp->options & ST_MODE_SEL_COMP) { 8165 page = ST_DEV_DATACOMP_PAGE; 8166 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, 8167 un->un_mspl, sizeof (struct seq_mode)); 8168 if (rval == 0 && un->un_mspl->page_code == page) { 8169 un->un_comp_page = page; 8170 break; 8171 } 8172 page = ST_DEV_CONFIG_PAGE; 8173 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, 8174 un->un_mspl, sizeof (struct seq_mode)); 8175 if (rval == 0 && un->un_mspl->page_code == page) { 8176 un->un_comp_page = page; 8177 break; 8178 } 8179 un->un_dp->options &= ~ST_MODE_SEL_COMP; 8180 un->un_comp_page = 0; 8181 } else { 8182 un->un_comp_page = 0; 8183 } 8184 8185 default: /* FALLTHROUGH */ 8186 rval = st_cmd(un, SCMD_MODE_SENSE, MSIZE, SYNC_CMD); 8187 } 8188 return (rval); 8189 } 8190 8191 static int 8192 st_modeselect(struct scsi_tape *un) 8193 { 8194 int rval = 0; 8195 int ix; 8196 8197 ST_FUNC(ST_DEVINFO, st_modeselect); 8198 8199 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8200 "st_modeselect(dev = 0x%lx): density = 0x%x\n", 8201 un->un_dev, un->un_mspl->density); 8202 8203 ASSERT(mutex_owned(ST_MUTEX)); 8204 8205 /* 8206 * The parameter list should be the same for all of the 8207 * cases that follow so set them here 8208 * 8209 * Try mode select first if if fails set fields manually 8210 */ 8211 rval = st_modesense(un); 8212 if (rval != 0) { 8213 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 8214 "st_modeselect: First mode sense failed\n"); 8215 un->un_mspl->bd_len = 8; 8216 un->un_mspl->high_nb = 0; 8217 un->un_mspl->mid_nb = 0; 8218 un->un_mspl->low_nb = 0; 8219 } 8220 un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16); 8221 un->un_mspl->mid_bl = (uchar_t)(un->un_bsize >> 8); 8222 un->un_mspl->low_bl = (uchar_t)(un->un_bsize); 8223 8224 8225 /* 8226 * If configured to use a specific density code for a media type. 8227 * curdens is previously set by the minor node opened. 8228 * If the media type doesn't match the minor node we change it so it 8229 * looks like the correct one was opened. 8230 */ 8231 if (un->un_dp->options & ST_KNOWS_MEDIA) { 8232 uchar_t best; 8233 8234 for (best = 0xff, ix = 0; ix < NDENSITIES; ix++) { 8235 if (un->un_mspl->media_type == 8236 un->un_dp->mediatype[ix]) { 8237 best = ix; 8238 /* 8239 * It matches but it might not be the only one. 8240 * Use the highest matching media type but not 8241 * to exceed the density selected by the open. 8242 */ 8243 if (ix < un->un_curdens) { 8244 continue; 8245 } 8246 un->un_curdens = ix; 8247 break; 8248 } 8249 } 8250 /* If a match was found best will not be 0xff any more */ 8251 if (best < NDENSITIES) { 8252 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 8253 "found media 0x%X using density 0x%X\n", 8254 un->un_mspl->media_type, 8255 un->un_dp->densities[best]); 8256 un->un_mspl->density = un->un_dp->densities[best]; 8257 } else { 8258 /* Otherwise set density based on minor node opened */ 8259 un->un_mspl->density = 8260 un->un_dp->densities[un->un_curdens]; 8261 } 8262 } else { 8263 un->un_mspl->density = un->un_dp->densities[un->un_curdens]; 8264 } 8265 8266 if (un->un_dp->options & ST_NOBUF) { 8267 un->un_mspl->bufm = 0; 8268 } else { 8269 un->un_mspl->bufm = 1; 8270 } 8271 8272 rval = st_set_compression(un); 8273 8274 /* 8275 * If st_set_compression returned invalid or already it 8276 * found no need to do the mode select. 8277 * So do it here. 8278 */ 8279 if ((rval == ENOTTY) || (rval == EALREADY)) { 8280 8281 /* Zero non-writeable fields */ 8282 un->un_mspl->data_len = 0; 8283 un->un_mspl->media_type = 0; 8284 un->un_mspl->wp = 0; 8285 8286 /* need to set the density code */ 8287 rval = st_cmd(un, SCMD_MODE_SELECT, MSIZE, SYNC_CMD); 8288 if (rval != 0) { 8289 if (un->un_state >= ST_STATE_OPEN) { 8290 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 8291 "unable to set tape mode\n"); 8292 un->un_pos.pmode = invalid; 8293 rval = EIO; 8294 } else { 8295 rval = -1; 8296 } 8297 } 8298 } 8299 8300 /* 8301 * The spec recommends to send a mode sense after a mode select 8302 */ 8303 (void) st_modesense(un); 8304 8305 ASSERT(mutex_owned(ST_MUTEX)); 8306 8307 return (rval); 8308 } 8309 8310 /* 8311 * st_gen_mode_sense 8312 * 8313 * generic mode sense.. it allows for any page 8314 */ 8315 static int 8316 st_gen_mode_sense(struct scsi_tape *un, ubufunc_t ubf, int page, 8317 struct seq_mode *page_data, int page_size) 8318 { 8319 8320 int r; 8321 char cdb[CDB_GROUP0]; 8322 struct uscsi_cmd *com; 8323 struct scsi_arq_status status; 8324 8325 ST_FUNC(ST_DEVINFO, st_gen_mode_sense); 8326 8327 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8328 8329 bzero(cdb, CDB_GROUP0); 8330 cdb[0] = SCMD_MODE_SENSE; 8331 cdb[2] = (char)page; 8332 cdb[4] = (char)page_size; 8333 8334 com->uscsi_cdb = cdb; 8335 com->uscsi_cdblen = CDB_GROUP0; 8336 com->uscsi_bufaddr = (caddr_t)page_data; 8337 com->uscsi_buflen = page_size; 8338 com->uscsi_rqlen = sizeof (status); 8339 com->uscsi_rqbuf = (caddr_t)&status; 8340 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8341 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 8342 8343 r = ubf(un, com, FKIOCTL); 8344 kmem_free(com, sizeof (*com)); 8345 return (r); 8346 } 8347 8348 /* 8349 * st_gen_mode_select 8350 * 8351 * generic mode select.. it allows for any page 8352 */ 8353 static int 8354 st_gen_mode_select(struct scsi_tape *un, ubufunc_t ubf, 8355 struct seq_mode *page_data, int page_size) 8356 { 8357 8358 int r; 8359 char cdb[CDB_GROUP0]; 8360 struct uscsi_cmd *com; 8361 struct scsi_arq_status status; 8362 8363 ST_FUNC(ST_DEVINFO, st_gen_mode_select); 8364 8365 /* Zero non-writeable fields */ 8366 page_data->data_len = 0; 8367 page_data->media_type = 0; 8368 page_data->wp = 0; 8369 8370 /* 8371 * If mode select has any page data, zero the ps (Page Savable) bit. 8372 */ 8373 if (page_size > MSIZE) { 8374 page_data->ps = 0; 8375 } 8376 8377 8378 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8379 8380 /* 8381 * then, do a mode select to set what ever info 8382 */ 8383 bzero(cdb, CDB_GROUP0); 8384 cdb[0] = SCMD_MODE_SELECT; 8385 cdb[1] = 0x10; /* set PF bit for many third party drives */ 8386 cdb[4] = (char)page_size; 8387 8388 com->uscsi_cdb = cdb; 8389 com->uscsi_cdblen = CDB_GROUP0; 8390 com->uscsi_bufaddr = (caddr_t)page_data; 8391 com->uscsi_buflen = page_size; 8392 com->uscsi_rqlen = sizeof (status); 8393 com->uscsi_rqbuf = (caddr_t)&status; 8394 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8395 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_WRITE; 8396 8397 r = ubf(un, com, FKIOCTL); 8398 8399 kmem_free(com, sizeof (*com)); 8400 return (r); 8401 } 8402 8403 static int 8404 st_read_block_limits(struct scsi_tape *un, struct read_blklim *read_blk) 8405 { 8406 int rval; 8407 char cdb[CDB_GROUP0]; 8408 struct uscsi_cmd *com; 8409 struct scsi_arq_status status; 8410 8411 ST_FUNC(ST_DEVINFO, st_read_block_limits); 8412 8413 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8414 8415 bzero(cdb, CDB_GROUP0); 8416 cdb[0] = SCMD_READ_BLKLIM; 8417 8418 com->uscsi_cdb = cdb; 8419 com->uscsi_cdblen = CDB_GROUP0; 8420 com->uscsi_bufaddr = (caddr_t)read_blk; 8421 com->uscsi_buflen = sizeof (struct read_blklim); 8422 com->uscsi_rqlen = sizeof (status); 8423 com->uscsi_rqbuf = (caddr_t)&status; 8424 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8425 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 8426 8427 rval = st_uscsi_cmd(un, com, FKIOCTL); 8428 if (com->uscsi_status || com->uscsi_resid) { 8429 rval = -1; 8430 } 8431 8432 kmem_free(com, sizeof (*com)); 8433 return (rval); 8434 } 8435 8436 static int 8437 st_report_density_support(struct scsi_tape *un, uchar_t *density_data, 8438 size_t buflen) 8439 { 8440 int rval; 8441 char cdb[CDB_GROUP1]; 8442 struct uscsi_cmd *com; 8443 struct scsi_arq_status status; 8444 8445 ST_FUNC(ST_DEVINFO, st_report_density_support); 8446 8447 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8448 8449 bzero(cdb, CDB_GROUP1); 8450 cdb[0] = SCMD_REPORT_DENSITIES; 8451 cdb[7] = (buflen & 0xff00) >> 8; 8452 cdb[8] = buflen & 0xff; 8453 8454 com->uscsi_cdb = cdb; 8455 com->uscsi_cdblen = CDB_GROUP1; 8456 com->uscsi_bufaddr = (caddr_t)density_data; 8457 com->uscsi_buflen = buflen; 8458 com->uscsi_rqlen = sizeof (status); 8459 com->uscsi_rqbuf = (caddr_t)&status; 8460 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8461 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 8462 8463 rval = st_uscsi_cmd(un, com, FKIOCTL); 8464 if (com->uscsi_status || com->uscsi_resid) { 8465 rval = -1; 8466 } 8467 8468 kmem_free(com, sizeof (*com)); 8469 return (rval); 8470 } 8471 8472 static int 8473 st_report_supported_operation(struct scsi_tape *un, uchar_t *oper_data, 8474 uchar_t option_code, ushort_t service_action) 8475 { 8476 int rval; 8477 char cdb[CDB_GROUP5]; 8478 struct uscsi_cmd *com; 8479 struct scsi_arq_status status; 8480 uint32_t allo_length; 8481 8482 ST_FUNC(ST_DEVINFO, st_report_supported_operation); 8483 8484 allo_length = sizeof (struct one_com_des) + 8485 sizeof (struct com_timeout_des); 8486 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8487 8488 bzero(cdb, CDB_GROUP5); 8489 cdb[0] = (char)SCMD_MAINTENANCE_IN; 8490 cdb[1] = SSVC_ACTION_GET_SUPPORTED_OPERATIONS; 8491 if (service_action) { 8492 cdb[2] = (char)(ONE_COMMAND_DATA_FORMAT | 0x80); /* RCTD */ 8493 cdb[4] = (service_action & 0xff00) >> 8; 8494 cdb[5] = service_action & 0xff; 8495 } else { 8496 cdb[2] = (char)(ONE_COMMAND_NO_SERVICE_DATA_FORMAT | 8497 0x80); /* RCTD */ 8498 } 8499 cdb[3] = option_code; 8500 cdb[6] = (allo_length & 0xff000000) >> 24; 8501 cdb[7] = (allo_length & 0xff0000) >> 16; 8502 cdb[8] = (allo_length & 0xff00) >> 8; 8503 cdb[9] = allo_length & 0xff; 8504 8505 com->uscsi_cdb = cdb; 8506 com->uscsi_cdblen = CDB_GROUP5; 8507 com->uscsi_bufaddr = (caddr_t)oper_data; 8508 com->uscsi_buflen = allo_length; 8509 com->uscsi_rqlen = sizeof (status); 8510 com->uscsi_rqbuf = (caddr_t)&status; 8511 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8512 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 8513 8514 rval = st_uscsi_cmd(un, com, FKIOCTL); 8515 if (com->uscsi_status) { 8516 rval = -1; 8517 } 8518 8519 kmem_free(com, sizeof (*com)); 8520 return (rval); 8521 } 8522 8523 /* 8524 * Changes devices blocksize and bsize to requested blocksize nblksz. 8525 * Returns returned value from first failed call or zero on success. 8526 */ 8527 static int 8528 st_change_block_size(struct scsi_tape *un, uint32_t nblksz) 8529 { 8530 struct seq_mode *current; 8531 int rval; 8532 uint32_t oldblksz; 8533 8534 ST_FUNC(ST_DEVINFO, st_change_block_size); 8535 8536 current = kmem_zalloc(MSIZE, KM_SLEEP); 8537 8538 /* 8539 * If we haven't got the compression page yet, do that first. 8540 */ 8541 if (un->un_comp_page == (ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE)) { 8542 (void) st_modesense(un); 8543 } 8544 8545 /* Read current settings */ 8546 rval = st_gen_mode_sense(un, st_uscsi_cmd, 0, current, MSIZE); 8547 if (rval != 0) { 8548 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8549 "mode sense for change block size failed: rval = %d", rval); 8550 goto finish; 8551 } 8552 8553 /* Figure the current block size */ 8554 oldblksz = 8555 (current->high_bl << 16) | 8556 (current->mid_bl << 8) | 8557 (current->low_bl); 8558 8559 /* If current block size is the same as requested were done */ 8560 if (oldblksz == nblksz) { 8561 un->un_bsize = nblksz; 8562 rval = 0; 8563 goto finish; 8564 } 8565 8566 /* Change to requested block size */ 8567 current->high_bl = (uchar_t)(nblksz >> 16); 8568 current->mid_bl = (uchar_t)(nblksz >> 8); 8569 current->low_bl = (uchar_t)(nblksz); 8570 8571 /* Attempt to change block size */ 8572 rval = st_gen_mode_select(un, st_uscsi_cmd, current, MSIZE); 8573 if (rval != 0) { 8574 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8575 "Set new block size failed: rval = %d", rval); 8576 goto finish; 8577 } 8578 8579 /* Read back and verify setting */ 8580 rval = st_modesense(un); 8581 if (rval == 0) { 8582 un->un_bsize = 8583 (un->un_mspl->high_bl << 16) | 8584 (un->un_mspl->mid_bl << 8) | 8585 (un->un_mspl->low_bl); 8586 8587 if (un->un_bsize != nblksz) { 8588 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8589 "Blocksize set does not equal requested blocksize" 8590 "(read: %u requested: %u)\n", nblksz, un->un_bsize); 8591 rval = EIO; 8592 } 8593 } 8594 finish: 8595 kmem_free(current, MSIZE); 8596 return (rval); 8597 } 8598 8599 8600 static void 8601 st_init(struct scsi_tape *un) 8602 { 8603 ST_FUNC(ST_DEVINFO, st_init); 8604 8605 ASSERT(mutex_owned(ST_MUTEX)); 8606 8607 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8608 "st_init(): dev = 0x%lx, will reset fileno, blkno, eof\n", 8609 un->un_dev); 8610 8611 un->un_pos.blkno = 0; 8612 un->un_pos.fileno = 0; 8613 un->un_lastop = ST_OP_NIL; 8614 un->un_pos.eof = ST_NO_EOF; 8615 un->un_pwr_mgmt = ST_PWR_NORMAL; 8616 if (st_error_level != SCSI_ERR_ALL) { 8617 if (DEBUGGING) { 8618 st_error_level = SCSI_ERR_ALL; 8619 } else { 8620 st_error_level = SCSI_ERR_RETRYABLE; 8621 } 8622 } 8623 } 8624 8625 8626 static void 8627 st_make_cmd(struct scsi_tape *un, struct buf *bp, int (*func)(caddr_t)) 8628 { 8629 struct scsi_pkt *pkt; 8630 struct uscsi_cmd *ucmd; 8631 recov_info *ri; 8632 int tval = 0; 8633 int64_t count; 8634 uint32_t additional = 0; 8635 uint32_t address = 0; 8636 union scsi_cdb *ucdb; 8637 int flags = 0; 8638 int cdb_len = CDB_GROUP0; /* default */ 8639 uchar_t com; 8640 char fixbit; 8641 char short_fm = 0; 8642 optype prev_op = un->un_lastop; 8643 int stat_size = 8644 (un->un_arq_enabled ? sizeof (struct scsi_arq_status) : 1); 8645 8646 ST_FUNC(ST_DEVINFO, st_make_cmd); 8647 8648 ASSERT(mutex_owned(ST_MUTEX)); 8649 8650 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8651 "st_make_cmd(): dev = 0x%lx\n", un->un_dev); 8652 8653 8654 /* 8655 * fixbit is for setting the Fixed Mode and Suppress Incorrect 8656 * Length Indicator bits on read/write commands, for setting 8657 * the Long bit on erase commands, and for setting the Code 8658 * Field bits on space commands. 8659 */ 8660 8661 /* regular raw I/O */ 8662 if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) { 8663 pkt = scsi_init_pkt(ROUTE, NULL, bp, 8664 CDB_GROUP0, stat_size, st_recov_sz, 0, func, 8665 (caddr_t)un); 8666 if (pkt == NULL) { 8667 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 8668 "Read Write scsi_init_pkt() failure\n"); 8669 goto exit; 8670 } 8671 ASSERT(pkt->pkt_resid == 0); 8672 #ifdef STDEBUG 8673 bzero(pkt->pkt_private, st_recov_sz); 8674 bzero(pkt->pkt_scbp, stat_size); 8675 #endif 8676 ri = (recov_info *)pkt->pkt_private; 8677 ri->privatelen = st_recov_sz; 8678 if (un->un_bsize == 0) { 8679 count = bp->b_bcount; 8680 fixbit = 0; 8681 } else { 8682 count = bp->b_bcount / un->un_bsize; 8683 fixbit = 1; 8684 } 8685 if (bp->b_flags & B_READ) { 8686 com = SCMD_READ; 8687 un->un_lastop = ST_OP_READ; 8688 if ((un->un_bsize == 0) && /* Not Fixed Block */ 8689 (un->un_dp->options & ST_READ_IGNORE_ILI)) { 8690 fixbit = 2; 8691 } 8692 } else { 8693 com = SCMD_WRITE; 8694 un->un_lastop = ST_OP_WRITE; 8695 } 8696 tval = un->un_dp->io_timeout; 8697 8698 /* 8699 * For really large xfers, increase timeout 8700 */ 8701 if (bp->b_bcount > (10 * ONE_MEG)) 8702 tval *= bp->b_bcount/(10 * ONE_MEG); 8703 8704 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8705 "%s %d amt 0x%lx\n", (com == SCMD_WRITE) ? 8706 wr_str: rd_str, un->un_pos.blkno, bp->b_bcount); 8707 8708 } else if ((ucmd = BP_UCMD(bp)) != NULL) { 8709 /* 8710 * uscsi - build command, allocate scsi resources 8711 */ 8712 st_make_uscsi_cmd(un, ucmd, bp, func); 8713 goto exit; 8714 8715 } else { /* special I/O */ 8716 struct buf *allocbp = NULL; 8717 com = (uchar_t)(uintptr_t)bp->b_forw; 8718 count = bp->b_bcount; 8719 8720 switch (com) { 8721 case SCMD_READ: 8722 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8723 "special read %"PRId64"\n", count); 8724 if (un->un_bsize == 0) { 8725 fixbit = 2; /* suppress SILI */ 8726 } else { 8727 fixbit = 1; /* Fixed Block Mode */ 8728 count /= un->un_bsize; 8729 } 8730 allocbp = bp; 8731 un->un_lastop = ST_OP_READ; 8732 tval = un->un_dp->io_timeout; 8733 break; 8734 8735 case SCMD_WRITE: 8736 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8737 "special write %"PRId64"\n", count); 8738 if (un->un_bsize != 0) { 8739 fixbit = 1; /* Fixed Block Mode */ 8740 count /= un->un_bsize; 8741 } else { 8742 fixbit = 0; 8743 } 8744 allocbp = bp; 8745 un->un_lastop = ST_OP_WRITE; 8746 tval = un->un_dp->io_timeout; 8747 break; 8748 8749 case SCMD_WRITE_FILE_MARK: 8750 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8751 "write %"PRId64" file marks\n", count); 8752 un->un_lastop = ST_OP_WEOF; 8753 fixbit = 0; 8754 tval = un->un_dp->io_timeout; 8755 /* 8756 * If ST_SHORT_FILEMARKS bit is ON for EXABYTE 8757 * device, set the Vendor Unique bit to 8758 * write Short File Mark. 8759 */ 8760 if ((un->un_dp->options & ST_SHORT_FILEMARKS) && 8761 ((un->un_dp->type == ST_TYPE_EXB8500) || 8762 (un->un_dp->type == ST_TYPE_EXABYTE))) { 8763 /* 8764 * Now the Vendor Unique bit 7 in Byte 5 of CDB 8765 * is set to to write Short File Mark 8766 */ 8767 short_fm = 1; 8768 } 8769 break; 8770 8771 case SCMD_REWIND: 8772 /* 8773 * In the case of rewind we're gona do the rewind with 8774 * the immediate bit set so status will be retured when 8775 * the command is accepted by the device. We clear the 8776 * B_ASYNC flag so we wait for that acceptance. 8777 */ 8778 fixbit = 0; 8779 if (bp->b_flags & B_ASYNC) { 8780 allocbp = bp; 8781 if (count) { 8782 fixbit = 1; 8783 bp->b_flags &= ~B_ASYNC; 8784 } 8785 } 8786 count = 0; 8787 bp->b_bcount = 0; 8788 un->un_lastop = ST_OP_CTL; 8789 tval = un->un_dp->rewind_timeout; 8790 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8791 "rewind\n"); 8792 break; 8793 8794 case SCMD_SPACE_G4: 8795 cdb_len = CDB_GROUP4; 8796 fixbit = SPACE_TYPE(bp->b_bcount); 8797 count = SPACE_CNT(bp->b_bcount); 8798 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 8799 " %s space %s %"PRId64" from file %d blk %d\n", 8800 bp->b_bcount & SP_BACKSP ? "backward" : "forward", 8801 space_strs[fixbit & 7], count, 8802 un->un_pos.fileno, un->un_pos.blkno); 8803 address = (count >> 48) & 0x1fff; 8804 additional = (count >> 16) & 0xffffffff; 8805 count &= 0xffff; 8806 count <<= 16; 8807 un->un_lastop = ST_OP_CTL; 8808 tval = un->un_dp->space_timeout; 8809 break; 8810 8811 case SCMD_SPACE: 8812 fixbit = SPACE_TYPE(bp->b_bcount); 8813 count = SPACE_CNT(bp->b_bcount); 8814 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8815 " %s space %s %"PRId64" from file %d blk %d\n", 8816 bp->b_bcount & SP_BACKSP ? "backward" : "forward", 8817 space_strs[fixbit & 7], count, 8818 un->un_pos.fileno, un->un_pos.blkno); 8819 count &= 0xffffffff; 8820 un->un_lastop = ST_OP_CTL; 8821 tval = un->un_dp->space_timeout; 8822 break; 8823 8824 case SCMD_LOAD: 8825 ASSERT(count < 10); 8826 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8827 "%s tape\n", load_strs[count]); 8828 fixbit = 0; 8829 8830 /* Loading or Unloading */ 8831 if (count & LD_LOAD) { 8832 tval = un->un_dp->load_timeout; 8833 } else { 8834 tval = un->un_dp->unload_timeout; 8835 } 8836 /* Is Retension requested */ 8837 if (count & LD_RETEN) { 8838 tval += un->un_dp->rewind_timeout; 8839 } 8840 un->un_lastop = ST_OP_CTL; 8841 break; 8842 8843 case SCMD_ERASE: 8844 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8845 "erase tape\n"); 8846 ASSERT(count == 1); /* mt sets this */ 8847 if (count == 1) { 8848 /* 8849 * do long erase 8850 */ 8851 fixbit = 1; /* Long */ 8852 8853 /* Drive might not honor immidiate bit */ 8854 tval = un->un_dp->erase_timeout; 8855 } else { 8856 /* Short Erase */ 8857 tval = un->un_dp->erase_timeout; 8858 fixbit = 0; 8859 } 8860 un->un_lastop = ST_OP_CTL; 8861 count = 0; 8862 break; 8863 8864 case SCMD_MODE_SENSE: 8865 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8866 "mode sense\n"); 8867 allocbp = bp; 8868 fixbit = 0; 8869 tval = un->un_dp->non_motion_timeout; 8870 un->un_lastop = ST_OP_CTL; 8871 break; 8872 8873 case SCMD_MODE_SELECT: 8874 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8875 "mode select\n"); 8876 allocbp = bp; 8877 fixbit = 0; 8878 tval = un->un_dp->non_motion_timeout; 8879 un->un_lastop = ST_OP_CTL; 8880 break; 8881 8882 case SCMD_RESERVE: 8883 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8884 "reserve\n"); 8885 fixbit = 0; 8886 tval = un->un_dp->non_motion_timeout; 8887 un->un_lastop = ST_OP_CTL; 8888 break; 8889 8890 case SCMD_RELEASE: 8891 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8892 "release\n"); 8893 fixbit = 0; 8894 tval = un->un_dp->non_motion_timeout; 8895 un->un_lastop = ST_OP_CTL; 8896 break; 8897 8898 case SCMD_READ_BLKLIM: 8899 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8900 "read block limits\n"); 8901 allocbp = bp; 8902 fixbit = count = 0; 8903 tval = un->un_dp->non_motion_timeout; 8904 un->un_lastop = ST_OP_CTL; 8905 break; 8906 8907 case SCMD_TEST_UNIT_READY: 8908 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8909 "test unit ready\n"); 8910 fixbit = 0; 8911 tval = un->un_dp->non_motion_timeout; 8912 un->un_lastop = ST_OP_CTL; 8913 break; 8914 8915 case SCMD_DOORLOCK: 8916 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8917 "prevent/allow media removal\n"); 8918 fixbit = 0; 8919 tval = un->un_dp->non_motion_timeout; 8920 un->un_lastop = ST_OP_CTL; 8921 break; 8922 8923 case SCMD_READ_POSITION: 8924 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8925 "read position\n"); 8926 fixbit = un->un_read_pos_type; 8927 cdb_len = CDB_GROUP1; 8928 tval = un->un_dp->non_motion_timeout; 8929 allocbp = bp; 8930 un->un_lastop = ST_OP_CTL; 8931 switch (un->un_read_pos_type) { 8932 case LONG_POS: 8933 count = 0; 8934 break; 8935 case EXT_POS: 8936 count = sizeof (tape_position_ext_t); 8937 break; 8938 case SHORT_POS: 8939 count = 0; 8940 break; 8941 default: 8942 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 8943 "Unknown read position type 0x%x in " 8944 " st_make_cmd()\n", un->un_read_pos_type); 8945 } 8946 break; 8947 8948 default: 8949 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 8950 "Unhandled scsi command 0x%x in st_make_cmd()\n", 8951 com); 8952 } 8953 8954 pkt = scsi_init_pkt(ROUTE, NULL, allocbp, cdb_len, stat_size, 8955 st_recov_sz, 0, func, (caddr_t)un); 8956 if (pkt == NULL) { 8957 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 8958 "generic command scsi_init_pkt() failure\n"); 8959 goto exit; 8960 } 8961 8962 ASSERT(pkt->pkt_resid == 0); 8963 #ifdef STDEBUG 8964 bzero(pkt->pkt_private, st_recov_sz); 8965 bzero(pkt->pkt_scbp, stat_size); 8966 #endif 8967 ri = (recov_info *)pkt->pkt_private; 8968 ri->privatelen = st_recov_sz; 8969 if (allocbp) { 8970 ASSERT(geterror(allocbp) == 0); 8971 } 8972 8973 } 8974 8975 ucdb = (union scsi_cdb *)pkt->pkt_cdbp; 8976 8977 (void) scsi_setup_cdb(ucdb, com, address, (uint_t)count, additional); 8978 FILL_SCSI1_LUN(un->un_sd, pkt); 8979 /* 8980 * Initialize the SILI/Fixed bits of the byte 1 of cdb. 8981 */ 8982 ucdb->t_code = fixbit; 8983 ucdb->g0_vu_1 = short_fm; 8984 pkt->pkt_flags = flags; 8985 8986 ASSERT(tval); 8987 pkt->pkt_time = tval; 8988 if (bp == un->un_recov_buf) { 8989 pkt->pkt_comp = st_recov_cb; 8990 } else { 8991 pkt->pkt_comp = st_intr; 8992 } 8993 8994 st_add_recovery_info_to_pkt(un, bp, pkt); 8995 8996 /* 8997 * If we just write data to tape and did a command that doesn't 8998 * change position, we still need to write a filemark. 8999 */ 9000 if ((prev_op == ST_OP_WRITE) || (prev_op == ST_OP_WEOF)) { 9001 recov_info *rcvi = pkt->pkt_private; 9002 cmd_attribute const *atrib; 9003 9004 if (rcvi->privatelen == sizeof (recov_info)) { 9005 atrib = rcvi->cmd_attrib; 9006 } else { 9007 atrib = st_lookup_cmd_attribute(com); 9008 } 9009 if (atrib->chg_tape_direction == DIR_NONE) { 9010 un->un_lastop = prev_op; 9011 } 9012 } 9013 9014 exit: 9015 ASSERT(mutex_owned(ST_MUTEX)); 9016 } 9017 9018 9019 /* 9020 * Build a command based on a uscsi command; 9021 */ 9022 static void 9023 st_make_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, 9024 struct buf *bp, int (*func)(caddr_t)) 9025 { 9026 struct scsi_pkt *pkt; 9027 recov_info *ri; 9028 caddr_t cdb; 9029 int cdblen; 9030 int stat_size = 1; 9031 int flags = 0; 9032 9033 ST_FUNC(ST_DEVINFO, st_make_uscsi_cmd); 9034 9035 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9036 "st_make_uscsi_cmd(): dev = 0x%lx\n", un->un_dev); 9037 9038 if (ucmd->uscsi_flags & USCSI_RQENABLE) { 9039 if (un->un_arq_enabled) { 9040 if (ucmd->uscsi_rqlen > SENSE_LENGTH) { 9041 stat_size = (int)(ucmd->uscsi_rqlen) + 9042 sizeof (struct scsi_arq_status) - 9043 sizeof (struct scsi_extended_sense); 9044 flags = PKT_XARQ; 9045 } else { 9046 stat_size = sizeof (struct scsi_arq_status); 9047 } 9048 } 9049 } 9050 9051 ASSERT(mutex_owned(ST_MUTEX)); 9052 9053 cdb = ucmd->uscsi_cdb; 9054 cdblen = ucmd->uscsi_cdblen; 9055 9056 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 9057 "st_make_uscsi_cmd: buflen=%ld bcount=%ld\n", 9058 ucmd->uscsi_buflen, bp->b_bcount); 9059 pkt = scsi_init_pkt(ROUTE, NULL, 9060 (bp->b_bcount > 0) ? bp : NULL, 9061 cdblen, stat_size, st_recov_sz, flags, func, (caddr_t)un); 9062 if (pkt == NULL) { 9063 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 9064 "uscsi command scsi_init_pkt() failure\n"); 9065 goto exit; 9066 } 9067 9068 ASSERT(pkt->pkt_resid == 0); 9069 #ifdef STDEBUG 9070 bzero(pkt->pkt_private, st_recov_sz); 9071 bzero(pkt->pkt_scbp, stat_size); 9072 #endif 9073 ri = (recov_info *)pkt->pkt_private; 9074 ri->privatelen = st_recov_sz; 9075 9076 bcopy(cdb, pkt->pkt_cdbp, (uint_t)cdblen); 9077 9078 #ifdef STDEBUG 9079 if ((st_debug & 0x7) >= 6) { 9080 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 9081 "pkt_cdbp", (char *)cdb, cdblen); 9082 } 9083 #endif 9084 9085 if (ucmd->uscsi_flags & USCSI_SILENT) { 9086 pkt->pkt_flags |= FLAG_SILENT; 9087 } 9088 9089 (void) scsi_uscsi_pktinit(ucmd, pkt); 9090 9091 pkt->pkt_time = ucmd->uscsi_timeout; 9092 if (bp == un->un_recov_buf) { 9093 pkt->pkt_comp = st_recov_cb; 9094 } else { 9095 pkt->pkt_comp = st_intr; 9096 } 9097 9098 st_add_recovery_info_to_pkt(un, bp, pkt); 9099 exit: 9100 ASSERT(mutex_owned(ST_MUTEX)); 9101 } 9102 9103 9104 /* 9105 * restart cmd currently at the head of the runq 9106 * 9107 * If scsi_transport() succeeds or the retries 9108 * count exhausted, restore the throttle that was 9109 * zeroed out in st_handle_intr_busy(). 9110 * 9111 */ 9112 static void 9113 st_intr_restart(void *arg) 9114 { 9115 struct scsi_tape *un = arg; 9116 struct buf *bp; 9117 int queued; 9118 int status = TRAN_ACCEPT; 9119 9120 mutex_enter(ST_MUTEX); 9121 9122 ST_FUNC(ST_DEVINFO, st_intr_restart); 9123 9124 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9125 "st_intr_restart(), un = 0x%p\n", (void *)un); 9126 9127 un->un_hib_tid = 0; 9128 9129 if (un->un_recov_buf_busy != 0) { 9130 bp = un->un_recov_buf; 9131 queued = 0; 9132 } else if (un->un_sbuf_busy != 0) { 9133 bp = un->un_sbufp; 9134 queued = 0; 9135 } else if (un->un_quef != NULL) { 9136 bp = un->un_quef; 9137 queued = 1; 9138 } else { 9139 mutex_exit(ST_MUTEX); 9140 return; 9141 } 9142 9143 /* 9144 * Here we know : 9145 * throttle = 0, via st_handle_intr_busy 9146 */ 9147 9148 if (queued) { 9149 /* 9150 * move from waitq to runq, if there is anything on the waitq 9151 */ 9152 (void) st_remove_from_queue(&un->un_quef, &un->un_quef, bp); 9153 9154 if (un->un_runqf) { 9155 /* 9156 * not good, we don't want to requeue something after 9157 * another. 9158 */ 9159 goto done_error; 9160 } else { 9161 un->un_runqf = bp; 9162 un->un_runql = bp; 9163 } 9164 } 9165 9166 ST_CDB(ST_DEVINFO, "Interrupt restart CDB", 9167 (char *)BP_PKT(bp)->pkt_cdbp); 9168 9169 ST_DO_KSTATS(bp, kstat_waitq_to_runq); 9170 9171 status = st_transport(un, BP_PKT(bp)); 9172 9173 if (status != TRAN_ACCEPT) { 9174 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 9175 9176 if (status == TRAN_BUSY) { 9177 pkt_info *pkti = BP_PKT(bp)->pkt_private; 9178 9179 if (pkti->privatelen == sizeof (recov_info) && 9180 un->un_unit_attention_flags && 9181 bp != un->un_recov_buf) { 9182 un->un_unit_attention_flags = 0; 9183 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 9184 "Command Recovery called on busy resend\n"); 9185 if (st_command_recovery(un, BP_PKT(bp), 9186 ATTEMPT_RETRY) == JUST_RETURN) { 9187 mutex_exit(ST_MUTEX); 9188 return; 9189 } 9190 } 9191 mutex_exit(ST_MUTEX); 9192 if (st_handle_intr_busy(un, bp, 9193 ST_TRAN_BUSY_TIMEOUT) == 0) 9194 return; /* timeout is setup again */ 9195 mutex_enter(ST_MUTEX); 9196 } 9197 9198 done_error: 9199 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 9200 "restart transport rejected\n"); 9201 bp->b_resid = bp->b_bcount; 9202 9203 if (un->un_last_throttle) { 9204 un->un_throttle = un->un_last_throttle; 9205 } 9206 if (status != TRAN_ACCEPT) { 9207 ST_DO_ERRSTATS(un, st_transerrs); 9208 } 9209 ST_DO_KSTATS(bp, kstat_waitq_exit); 9210 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 9211 "busy restart aborted\n"); 9212 st_set_pe_flag(un); 9213 st_bioerror(bp, EIO); 9214 st_done_and_mutex_exit(un, bp); 9215 } else { 9216 if (un->un_last_throttle) { 9217 un->un_throttle = un->un_last_throttle; 9218 } 9219 mutex_exit(ST_MUTEX); 9220 } 9221 } 9222 9223 /* 9224 * st_check_media(): 9225 * Periodically check the media state using scsi_watch service; 9226 * this service calls back after TUR and possibly request sense 9227 * the callback handler (st_media_watch_cb()) decodes the request sense 9228 * data (if any) 9229 */ 9230 9231 static int 9232 st_check_media(dev_t dev, enum mtio_state state) 9233 { 9234 int rval = 0; 9235 enum mtio_state prev_state; 9236 opaque_t token = NULL; 9237 9238 GET_SOFT_STATE(dev); 9239 9240 ST_FUNC(ST_DEVINFO, st_check_media); 9241 9242 mutex_enter(ST_MUTEX); 9243 9244 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9245 "st_check_media:state=%x, mediastate=%x\n", 9246 state, un->un_mediastate); 9247 9248 prev_state = un->un_mediastate; 9249 9250 /* 9251 * is there anything to do? 9252 */ 9253 retry: 9254 if (state == un->un_mediastate || un->un_mediastate == MTIO_NONE) { 9255 /* 9256 * submit the request to the scsi_watch service; 9257 * scsi_media_watch_cb() does the real work 9258 */ 9259 mutex_exit(ST_MUTEX); 9260 token = scsi_watch_request_submit(ST_SCSI_DEVP, 9261 st_check_media_time, SENSE_LENGTH, 9262 st_media_watch_cb, (caddr_t)dev); 9263 if (token == NULL) { 9264 rval = EAGAIN; 9265 goto done; 9266 } 9267 mutex_enter(ST_MUTEX); 9268 9269 un->un_swr_token = token; 9270 un->un_specified_mediastate = state; 9271 9272 /* 9273 * now wait for media change 9274 * we will not be signalled unless mediastate == state but it 9275 * still better to test for this condition, since there 9276 * is a 5 sec cv_broadcast delay when 9277 * mediastate == MTIO_INSERTED 9278 */ 9279 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9280 "st_check_media:waiting for media state change\n"); 9281 while (un->un_mediastate == state) { 9282 if (cv_wait_sig(&un->un_state_cv, ST_MUTEX) == 0) { 9283 mutex_exit(ST_MUTEX); 9284 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9285 "st_check_media:waiting for media state " 9286 "was interrupted\n"); 9287 rval = EINTR; 9288 goto done; 9289 } 9290 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9291 "st_check_media:received signal, state=%x\n", 9292 un->un_mediastate); 9293 } 9294 } 9295 9296 /* 9297 * if we transitioned to MTIO_INSERTED, media has really been 9298 * inserted. If TUR fails, it is probably a exabyte slow spin up. 9299 * Reset and retry the state change. If everything is ok, replay 9300 * the open() logic. 9301 */ 9302 if ((un->un_mediastate == MTIO_INSERTED) && 9303 (un->un_state == ST_STATE_OFFLINE)) { 9304 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9305 "st_check_media: calling st_cmd to confirm inserted\n"); 9306 9307 /* 9308 * set this early so that TUR will make it through strategy 9309 * without triggering a st_tape_init(). We needed it set 9310 * before calling st_tape_init() ourselves anyway. If TUR 9311 * fails, set it back 9312 */ 9313 un->un_state = ST_STATE_INITIALIZING; 9314 9315 /* 9316 * If not reserved fail as getting reservation conflict 9317 * will make this hang forever. 9318 */ 9319 if ((un->un_rsvd_status & 9320 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 9321 mutex_exit(ST_MUTEX); 9322 rval = EACCES; 9323 goto done; 9324 } 9325 rval = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 9326 if (rval == EACCES) { 9327 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9328 "st_check_media: TUR got Reservation Conflict\n"); 9329 mutex_exit(ST_MUTEX); 9330 goto done; 9331 } 9332 if (rval) { 9333 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9334 "st_check_media: TUR failed, going to retry\n"); 9335 un->un_mediastate = prev_state; 9336 un->un_state = ST_STATE_OFFLINE; 9337 goto retry; 9338 } 9339 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9340 "st_check_media: media inserted\n"); 9341 9342 /* this also rewinds the tape */ 9343 rval = st_tape_init(un); 9344 if (rval != 0) { 9345 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9346 "st_check_media : OFFLINE init failure "); 9347 un->un_state = ST_STATE_OFFLINE; 9348 un->un_pos.pmode = invalid; 9349 } else { 9350 un->un_state = ST_STATE_OPEN_PENDING_IO; 9351 } 9352 } else if ((un->un_mediastate == MTIO_EJECTED) && 9353 (un->un_state != ST_STATE_OFFLINE)) { 9354 /* 9355 * supported devices must be rewound before ejection 9356 * rewind resets fileno & blkno 9357 */ 9358 un->un_laststate = un->un_state; 9359 un->un_state = ST_STATE_OFFLINE; 9360 } 9361 mutex_exit(ST_MUTEX); 9362 done: 9363 if (token) { 9364 (void) scsi_watch_request_terminate(token, 9365 SCSI_WATCH_TERMINATE_WAIT); 9366 mutex_enter(ST_MUTEX); 9367 un->un_swr_token = (opaque_t)NULL; 9368 mutex_exit(ST_MUTEX); 9369 } 9370 9371 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_media: done\n"); 9372 9373 return (rval); 9374 } 9375 9376 /* 9377 * st_media_watch_cb() is called by scsi_watch_thread for 9378 * verifying the request sense data (if any) 9379 */ 9380 static int 9381 st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp) 9382 { 9383 struct scsi_status *statusp = resultp->statusp; 9384 struct scsi_extended_sense *sensep = resultp->sensep; 9385 uchar_t actual_sense_length = resultp->actual_sense_length; 9386 struct scsi_tape *un; 9387 enum mtio_state state = MTIO_NONE; 9388 int instance; 9389 dev_t dev = (dev_t)arg; 9390 9391 instance = MTUNIT(dev); 9392 if ((un = ddi_get_soft_state(st_state, instance)) == NULL) { 9393 return (-1); 9394 } 9395 9396 mutex_enter(ST_MUTEX); 9397 ST_FUNC(ST_DEVINFO, st_media_watch_cb); 9398 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9399 "st_media_watch_cb: status=%x, sensep=%p, len=%x\n", 9400 *((char *)statusp), (void *)sensep, 9401 actual_sense_length); 9402 9403 9404 /* 9405 * if there was a check condition then sensep points to valid 9406 * sense data 9407 * if status was not a check condition but a reservation or busy 9408 * status then the new state is MTIO_NONE 9409 */ 9410 if (sensep) { 9411 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9412 "st_media_watch_cb: KEY=%x, ASC=%x, ASCQ=%x\n", 9413 sensep->es_key, sensep->es_add_code, sensep->es_qual_code); 9414 9415 switch (un->un_dp->type) { 9416 default: 9417 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9418 "st_media_watch_cb: unknown drive type %d, " 9419 "default to ST_TYPE_HP\n", un->un_dp->type); 9420 /* FALLTHROUGH */ 9421 9422 case ST_TYPE_STC3490: /* STK 4220 1/2" cartridge */ 9423 case ST_TYPE_FUJI: /* 1/2" cartridge */ 9424 case ST_TYPE_HP: /* HP 88780 1/2" reel */ 9425 if (un->un_dp->type == ST_TYPE_FUJI) { 9426 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9427 "st_media_watch_cb: ST_TYPE_FUJI\n"); 9428 } else { 9429 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9430 "st_media_watch_cb: ST_TYPE_HP\n"); 9431 } 9432 switch (sensep->es_key) { 9433 case KEY_UNIT_ATTENTION: 9434 /* not ready to ready transition */ 9435 /* hp/es_qual_code == 80 on>off>on */ 9436 /* hp/es_qual_code == 0 on>off>unld>ld>on */ 9437 if (sensep->es_add_code == 0x28) { 9438 state = MTIO_INSERTED; 9439 } 9440 break; 9441 case KEY_NOT_READY: 9442 /* in process, rewinding or loading */ 9443 if ((sensep->es_add_code == 0x04) && 9444 (sensep->es_qual_code == 0x00)) { 9445 state = MTIO_EJECTED; 9446 } 9447 break; 9448 } 9449 break; 9450 9451 case ST_TYPE_EXB8500: /* Exabyte 8500 */ 9452 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9453 "st_media_watch_cb: ST_TYPE_EXB8500\n"); 9454 switch (sensep->es_key) { 9455 case KEY_UNIT_ATTENTION: 9456 /* operator medium removal request */ 9457 if ((sensep->es_add_code == 0x5a) && 9458 (sensep->es_qual_code == 0x01)) { 9459 state = MTIO_EJECTED; 9460 /* not ready to ready transition */ 9461 } else if ((sensep->es_add_code == 0x28) && 9462 (sensep->es_qual_code == 0x00)) { 9463 state = MTIO_INSERTED; 9464 } 9465 break; 9466 case KEY_NOT_READY: 9467 /* medium not present */ 9468 if (sensep->es_add_code == 0x3a) { 9469 state = MTIO_EJECTED; 9470 } 9471 break; 9472 } 9473 break; 9474 case ST_TYPE_EXABYTE: /* Exabyte 8200 */ 9475 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9476 "st_media_watch_cb: ST_TYPE_EXABYTE\n"); 9477 switch (sensep->es_key) { 9478 case KEY_NOT_READY: 9479 if ((sensep->es_add_code == 0x04) && 9480 (sensep->es_qual_code == 0x00)) { 9481 /* volume not mounted? */ 9482 state = MTIO_EJECTED; 9483 } else if (sensep->es_add_code == 0x3a) { 9484 state = MTIO_EJECTED; 9485 } 9486 break; 9487 case KEY_UNIT_ATTENTION: 9488 state = MTIO_EJECTED; 9489 break; 9490 } 9491 break; 9492 9493 case ST_TYPE_DLT: /* quantum DLT4xxx */ 9494 switch (sensep->es_key) { 9495 case KEY_UNIT_ATTENTION: 9496 if (sensep->es_add_code == 0x28) { 9497 state = MTIO_INSERTED; 9498 } 9499 break; 9500 case KEY_NOT_READY: 9501 if (sensep->es_add_code == 0x04) { 9502 /* in transition but could be either */ 9503 state = un->un_specified_mediastate; 9504 } else if ((sensep->es_add_code == 0x3a) && 9505 (sensep->es_qual_code == 0x00)) { 9506 state = MTIO_EJECTED; 9507 } 9508 break; 9509 } 9510 break; 9511 } 9512 } else if (*((char *)statusp) == STATUS_GOOD) { 9513 state = MTIO_INSERTED; 9514 } 9515 9516 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9517 "st_media_watch_cb:state=%x, specified=%x\n", 9518 state, un->un_specified_mediastate); 9519 9520 /* 9521 * now signal the waiting thread if this is *not* the specified state; 9522 * delay the signal if the state is MTIO_INSERTED 9523 * to allow the target to recover 9524 */ 9525 if (state != un->un_specified_mediastate) { 9526 un->un_mediastate = state; 9527 if (state == MTIO_INSERTED) { 9528 /* 9529 * delay the signal to give the drive a chance 9530 * to do what it apparently needs to do 9531 */ 9532 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9533 "st_media_watch_cb:delayed cv_broadcast\n"); 9534 un->un_delay_tid = timeout(st_delayed_cv_broadcast, 9535 un, drv_usectohz((clock_t)MEDIA_ACCESS_DELAY)); 9536 } else { 9537 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9538 "st_media_watch_cb:immediate cv_broadcast\n"); 9539 cv_broadcast(&un->un_state_cv); 9540 } 9541 } 9542 mutex_exit(ST_MUTEX); 9543 return (0); 9544 } 9545 9546 /* 9547 * delayed cv_broadcast to allow for target to recover 9548 * from media insertion 9549 */ 9550 static void 9551 st_delayed_cv_broadcast(void *arg) 9552 { 9553 struct scsi_tape *un = arg; 9554 9555 ST_FUNC(ST_DEVINFO, st_delayed_cv_broadcast); 9556 9557 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9558 "st_delayed_cv_broadcast:delayed cv_broadcast\n"); 9559 9560 mutex_enter(ST_MUTEX); 9561 cv_broadcast(&un->un_state_cv); 9562 mutex_exit(ST_MUTEX); 9563 } 9564 9565 /* 9566 * restart cmd currently at the start of the waitq 9567 */ 9568 static void 9569 st_start_restart(void *arg) 9570 { 9571 struct scsi_tape *un = arg; 9572 9573 ST_FUNC(ST_DEVINFO, st_start_restart); 9574 9575 ASSERT(un != NULL); 9576 9577 mutex_enter(ST_MUTEX); 9578 9579 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_tran_restart()\n"); 9580 9581 st_start(un); 9582 9583 mutex_exit(ST_MUTEX); 9584 } 9585 9586 9587 /* 9588 * Command completion processing 9589 * 9590 */ 9591 static void 9592 st_intr(struct scsi_pkt *pkt) 9593 { 9594 recov_info *rcv = pkt->pkt_private; 9595 struct buf *bp = rcv->cmd_bp; 9596 struct scsi_tape *un; 9597 errstate action = COMMAND_DONE; 9598 clock_t timout; 9599 int status; 9600 9601 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 9602 9603 ST_FUNC(ST_DEVINFO, st_intr); 9604 9605 ASSERT(un != NULL); 9606 9607 mutex_enter(ST_MUTEX); 9608 9609 ASSERT(bp != un->un_recov_buf); 9610 9611 un->un_rqs_state &= ~(ST_RQS_ERROR); 9612 9613 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_intr()\n"); 9614 9615 if (pkt->pkt_reason != CMD_CMPLT) { 9616 ST_DEBUG(ST_DEVINFO, st_label, CE_WARN, 9617 "Unhappy packet status reason = %s statistics = 0x%x\n", 9618 scsi_rname(pkt->pkt_reason), pkt->pkt_statistics); 9619 9620 /* If device has gone away not much else to do */ 9621 if (pkt->pkt_reason == CMD_DEV_GONE) { 9622 action = COMMAND_DONE_ERROR; 9623 } else if ((pkt == un->un_rqs) || 9624 (un->un_state == ST_STATE_SENSING)) { 9625 ASSERT(pkt == un->un_rqs); 9626 ASSERT(un->un_state == ST_STATE_SENSING); 9627 un->un_state = un->un_laststate; 9628 rcv->cmd_bp = un->un_rqs_bp; 9629 ST_DO_ERRSTATS(un, st_transerrs); 9630 action = COMMAND_DONE_ERROR; 9631 } else { 9632 action = st_handle_incomplete(un, bp); 9633 } 9634 /* 9635 * At this point we know that the command was successfully 9636 * completed. Now what? 9637 */ 9638 } else if ((pkt == un->un_rqs) || (un->un_state == ST_STATE_SENSING)) { 9639 /* 9640 * okay. We were running a REQUEST SENSE. Find 9641 * out what to do next. 9642 */ 9643 ASSERT(pkt == un->un_rqs); 9644 ASSERT(un->un_state == ST_STATE_SENSING); 9645 scsi_sync_pkt(pkt); 9646 action = st_handle_sense(un, bp, &un->un_pos); 9647 /* 9648 * Make rqs isn't going to be retied. 9649 */ 9650 if (action != QUE_BUSY_COMMAND && action != QUE_COMMAND) { 9651 /* 9652 * set pkt back to original packet in case we will have 9653 * to requeue it 9654 */ 9655 pkt = BP_PKT(bp); 9656 rcv->cmd_bp = un->un_rqs_bp; 9657 /* 9658 * some actions are based on un_state, hence 9659 * restore the state st was in before ST_STATE_SENSING. 9660 */ 9661 un->un_state = un->un_laststate; 9662 } 9663 9664 } else if (un->un_arq_enabled && (pkt->pkt_state & STATE_ARQ_DONE)) { 9665 /* 9666 * the transport layer successfully completed an autorqsense 9667 */ 9668 action = st_handle_autosense(un, bp, &un->un_pos); 9669 9670 } else if ((SCBP(pkt)->sts_busy) || 9671 (SCBP(pkt)->sts_chk) || 9672 (SCBP(pkt)->sts_vu7)) { 9673 /* 9674 * Okay, we weren't running a REQUEST SENSE. Call a routine 9675 * to see if the status bits we're okay. If a request sense 9676 * is to be run, that will happen. 9677 */ 9678 action = st_check_error(un, pkt); 9679 } 9680 9681 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 9682 switch (action) { 9683 case QUE_COMMAND: 9684 /* 9685 * return cmd to head to the queue 9686 * since we are suspending so that 9687 * it gets restarted during resume 9688 */ 9689 st_add_to_queue(&un->un_runqf, &un->un_runql, 9690 un->un_runqf, bp); 9691 9692 action = JUST_RETURN; 9693 break; 9694 9695 case QUE_SENSE: 9696 action = COMMAND_DONE_ERROR; 9697 break; 9698 9699 default: 9700 break; 9701 } 9702 } 9703 9704 /* 9705 * check for undetected path failover. 9706 */ 9707 if (un->un_multipath) { 9708 9709 struct uscsi_cmd *ucmd = BP_UCMD(bp); 9710 int pkt_valid = 0; 9711 9712 if (ucmd) { 9713 /* 9714 * Also copies path instance to the uscsi structure. 9715 */ 9716 pkt_valid = scsi_uscsi_pktfini(pkt, ucmd); 9717 9718 /* 9719 * scsi_uscsi_pktfini() zeros pkt_path_instance. 9720 */ 9721 pkt->pkt_path_instance = ucmd->uscsi_path_instance; 9722 } else { 9723 pkt_valid = scsi_pkt_allocated_correctly(pkt); 9724 } 9725 9726 /* 9727 * If the scsi_pkt was not allocated correctly the 9728 * pkt_path_instance is not even there. 9729 */ 9730 if ((pkt_valid != 0) && 9731 (un->un_last_path_instance != pkt->pkt_path_instance)) { 9732 /* 9733 * Don't recover the path change if it was done 9734 * intentionally or if the device has not completely 9735 * opened yet. 9736 */ 9737 if (((pkt->pkt_flags & FLAG_PKT_PATH_INSTANCE) == 0) && 9738 (un->un_state > ST_STATE_OPENING)) { 9739 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 9740 "Failover detected, action is %s\n", 9741 errstatenames[action]); 9742 if (action == COMMAND_DONE) { 9743 action = PATH_FAILED; 9744 } 9745 } 9746 un->un_last_path_instance = pkt->pkt_path_instance; 9747 } 9748 } 9749 9750 /* 9751 * Restore old state if we were sensing. 9752 */ 9753 if (un->un_state == ST_STATE_SENSING && action != QUE_SENSE) { 9754 un->un_state = un->un_laststate; 9755 } 9756 9757 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 9758 "st_intr: pkt=%p, bp=%p, action=%s, status=%x\n", 9759 (void *)pkt, (void *)bp, errstatenames[action], SCBP_C(pkt)); 9760 9761 again: 9762 switch (action) { 9763 case COMMAND_DONE_EACCES: 9764 /* this is to report a reservation conflict */ 9765 st_bioerror(bp, EACCES); 9766 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9767 "Reservation Conflict \n"); 9768 un->un_pos.pmode = invalid; 9769 9770 /*FALLTHROUGH*/ 9771 case COMMAND_DONE_ERROR: 9772 if (un->un_pos.eof < ST_EOT_PENDING && 9773 un->un_state >= ST_STATE_OPEN) { 9774 /* 9775 * all errors set state of the tape to 'unknown' 9776 * unless we're at EOT or are doing append testing. 9777 * If sense key was illegal request, preserve state. 9778 */ 9779 if (un->un_status != KEY_ILLEGAL_REQUEST) { 9780 un->un_pos.pmode = invalid; 9781 } 9782 } 9783 9784 un->un_err_resid = bp->b_resid = bp->b_bcount; 9785 /* 9786 * since we have an error (COMMAND_DONE_ERROR), we want to 9787 * make sure an error ocurrs, so make sure at least EIO is 9788 * returned 9789 */ 9790 if (geterror(bp) == 0) 9791 st_bioerror(bp, EIO); 9792 9793 st_set_pe_flag(un); 9794 if (!(un->un_rqs_state & ST_RQS_ERROR) && 9795 (un->un_errno == EIO)) { 9796 un->un_rqs_state &= ~(ST_RQS_VALID); 9797 } 9798 break; 9799 9800 case COMMAND_DONE_ERROR_RECOVERED: 9801 un->un_err_resid = bp->b_resid = bp->b_bcount; 9802 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 9803 "st_intr(): COMMAND_DONE_ERROR_RECOVERED"); 9804 if (geterror(bp) == 0) { 9805 st_bioerror(bp, EIO); 9806 } 9807 st_set_pe_flag(un); 9808 if (!(un->un_rqs_state & ST_RQS_ERROR) && 9809 (un->un_errno == EIO)) { 9810 un->un_rqs_state &= ~(ST_RQS_VALID); 9811 } 9812 /*FALLTHROUGH*/ 9813 case COMMAND_DONE: 9814 st_set_state(un, bp); 9815 break; 9816 9817 case QUE_SENSE: 9818 if ((un->un_ncmds > 1) && !un->un_flush_on_errors) 9819 goto sense_error; 9820 9821 if (un->un_state != ST_STATE_SENSING) { 9822 un->un_laststate = un->un_state; 9823 un->un_state = ST_STATE_SENSING; 9824 } 9825 9826 /* 9827 * zero the sense data. 9828 */ 9829 bzero(un->un_rqs->pkt_scbp, SENSE_LENGTH); 9830 9831 /* 9832 * If this is not a retry on QUE_SENSE point to the original 9833 * bp of the command that got us here. 9834 */ 9835 if (pkt != un->un_rqs) { 9836 ((recov_info *)un->un_rqs->pkt_private)->cmd_bp = bp; 9837 } 9838 9839 if (un->un_throttle) { 9840 un->un_last_throttle = un->un_throttle; 9841 un->un_throttle = 0; 9842 } 9843 9844 ST_CDB(ST_DEVINFO, "Queue sense CDB", 9845 (char *)BP_PKT(bp)->pkt_cdbp); 9846 9847 /* 9848 * never retry this, some other command will have nuked the 9849 * sense, anyway 9850 */ 9851 status = st_transport(un, un->un_rqs); 9852 9853 if (un->un_last_throttle) { 9854 un->un_throttle = un->un_last_throttle; 9855 } 9856 9857 if (status == TRAN_ACCEPT) { 9858 mutex_exit(ST_MUTEX); 9859 return; 9860 } 9861 if (status != TRAN_BUSY) 9862 ST_DO_ERRSTATS(un, st_transerrs); 9863 sense_error: 9864 un->un_pos.pmode = invalid; 9865 st_bioerror(bp, EIO); 9866 st_set_pe_flag(un); 9867 break; 9868 9869 case QUE_BUSY_COMMAND: 9870 /* longish timeout */ 9871 timout = ST_STATUS_BUSY_TIMEOUT; 9872 goto que_it_up; 9873 9874 case QUE_COMMAND: 9875 /* short timeout */ 9876 timout = ST_TRAN_BUSY_TIMEOUT; 9877 que_it_up: 9878 /* 9879 * let st_handle_intr_busy put this bp back on waitq and make 9880 * checks to see if it is ok to requeue the command. 9881 */ 9882 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 9883 9884 /* 9885 * Save the throttle before setting up the timeout 9886 */ 9887 if (un->un_throttle) { 9888 un->un_last_throttle = un->un_throttle; 9889 } 9890 mutex_exit(ST_MUTEX); 9891 if (st_handle_intr_busy(un, bp, timout) == 0) 9892 return; /* timeout is setup again */ 9893 9894 mutex_enter(ST_MUTEX); 9895 un->un_pos.pmode = invalid; 9896 un->un_err_resid = bp->b_resid = bp->b_bcount; 9897 st_bioerror(bp, EIO); 9898 st_set_pe_flag(un); 9899 break; 9900 9901 case QUE_LAST_COMMAND: 9902 9903 if ((un->un_ncmds > 1) && !un->un_flush_on_errors) { 9904 scsi_log(ST_DEVINFO, st_label, CE_CONT, 9905 "un_ncmds: %d can't retry cmd \n", un->un_ncmds); 9906 goto last_command_error; 9907 } 9908 mutex_exit(ST_MUTEX); 9909 if (st_handle_intr_retry_lcmd(un, bp) == 0) 9910 return; 9911 mutex_enter(ST_MUTEX); 9912 last_command_error: 9913 un->un_err_resid = bp->b_resid = bp->b_bcount; 9914 un->un_pos.pmode = invalid; 9915 st_bioerror(bp, EIO); 9916 st_set_pe_flag(un); 9917 break; 9918 9919 case COMMAND_TIMEOUT: 9920 case DEVICE_RESET: 9921 case DEVICE_TAMPER: 9922 case ATTEMPT_RETRY: 9923 case PATH_FAILED: 9924 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 9925 "Command Recovery called on %s status\n", 9926 errstatenames[action]); 9927 action = st_command_recovery(un, pkt, action); 9928 goto again; 9929 9930 default: 9931 ASSERT(0); 9932 /* FALLTHRU */ 9933 case JUST_RETURN: 9934 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 9935 mutex_exit(ST_MUTEX); 9936 return; 9937 } 9938 9939 ST_DO_KSTATS(bp, kstat_runq_exit); 9940 st_done_and_mutex_exit(un, bp); 9941 } 9942 9943 static errstate 9944 st_handle_incomplete(struct scsi_tape *un, struct buf *bp) 9945 { 9946 static char *fail = "SCSI transport failed: reason '%s': %s\n"; 9947 recov_info *rinfo; 9948 errstate rval = COMMAND_DONE_ERROR; 9949 struct scsi_pkt *pkt = (un->un_state == ST_STATE_SENSING) ? 9950 un->un_rqs : BP_PKT(bp); 9951 int result; 9952 9953 ST_FUNC(ST_DEVINFO, st_handle_incomplete); 9954 9955 rinfo = (recov_info *)pkt->pkt_private; 9956 9957 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9958 "st_handle_incomplete(): dev = 0x%lx\n", un->un_dev); 9959 9960 ASSERT(mutex_owned(ST_MUTEX)); 9961 9962 /* prevent infinite number of retries */ 9963 if (rinfo->pkt_retry_cnt++ > st_retry_count) { 9964 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 9965 "Recovery stopped for incomplete %s command, " 9966 "retries exhausted", 9967 st_print_scsi_cmd(pkt->pkt_cdbp[0])); 9968 return (COMMAND_DONE_ERROR); 9969 } 9970 9971 switch (pkt->pkt_reason) { 9972 case CMD_INCOMPLETE: /* tran stopped with not normal state */ 9973 /* 9974 * this occurs when accessing a powered down drive, no 9975 * need to complain; just fail the open 9976 */ 9977 ST_CDB(ST_DEVINFO, "Incomplete CDB", (char *)pkt->pkt_cdbp); 9978 9979 /* 9980 * if we have commands outstanding in HBA, and a command 9981 * comes back incomplete, we're hosed, so reset target 9982 * If we have the bus, but cmd_incomplete, we probably just 9983 * have a failed selection, so don't reset the target, just 9984 * requeue the command and try again 9985 */ 9986 if ((un->un_ncmds > 1) || (pkt->pkt_state != STATE_GOT_BUS)) { 9987 goto reset_target; 9988 } 9989 9990 /* 9991 * Retry selection a couple more times if we're 9992 * open. If opening, we only try just once to 9993 * reduce probe time for nonexistant devices. 9994 */ 9995 if ((un->un_laststate > ST_STATE_OPENING) && 9996 (rinfo->pkt_retry_cnt < st_selection_retry_count)) { 9997 /* XXX check retriable? */ 9998 rval = QUE_COMMAND; 9999 } 10000 ST_DO_ERRSTATS(un, st_transerrs); 10001 break; 10002 10003 case CMD_ABORTED: 10004 /* 10005 * most likely this is caused by flush-on-error support. If 10006 * it was not there, the we're in trouble. 10007 */ 10008 if (!un->un_flush_on_errors) { 10009 un->un_status = SUN_KEY_FATAL; 10010 goto reset_target; 10011 } 10012 10013 st_set_pe_errno(un); 10014 bioerror(bp, un->un_errno); 10015 if (un->un_errno) 10016 return (COMMAND_DONE_ERROR); 10017 else 10018 return (COMMAND_DONE); 10019 10020 case CMD_TIMEOUT: /* Command timed out */ 10021 un->un_status = SUN_KEY_TIMEOUT; 10022 return (COMMAND_TIMEOUT); 10023 10024 case CMD_TRAN_ERR: 10025 case CMD_RESET: 10026 if (pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET)) { 10027 if ((un->un_rsvd_status & 10028 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 10029 ST_RESERVE) { 10030 un->un_rsvd_status |= ST_LOST_RESERVE; 10031 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 10032 "Lost Reservation\n"); 10033 } 10034 rval = DEVICE_RESET; 10035 return (rval); 10036 } 10037 if (pkt->pkt_statistics & (STAT_ABORTED | STAT_TERMINATED)) { 10038 rval = DEVICE_RESET; 10039 return (rval); 10040 } 10041 /*FALLTHROUGH*/ 10042 default: 10043 scsi_log(ST_DEVINFO, st_label, CE_WARN, 10044 "Unhandled packet status reason = %s statistics = 0x%x\n", 10045 scsi_rname(pkt->pkt_reason), pkt->pkt_statistics); 10046 reset_target: 10047 10048 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10049 "transport completed with %s\n", 10050 scsi_rname(pkt->pkt_reason)); 10051 ST_DO_ERRSTATS(un, st_transerrs); 10052 if ((pkt->pkt_state & STATE_GOT_TARGET) && 10053 ((pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET | 10054 STAT_ABORTED)) == 0)) { 10055 10056 /* 10057 * If we haven't reserved the drive don't reset it. 10058 */ 10059 if ((un->un_rsvd_status & 10060 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 10061 return (rval); 10062 } 10063 10064 /* 10065 * if we aren't lost yet we will be soon. 10066 */ 10067 un->un_pos.pmode = invalid; 10068 10069 result = st_reset(un, RESET_LUN); 10070 10071 if ((result == 0) && (un->un_state >= ST_STATE_OPEN)) { 10072 /* no hope left to recover */ 10073 scsi_log(ST_DEVINFO, st_label, CE_WARN, 10074 "recovery by resets failed\n"); 10075 return (rval); 10076 } 10077 } 10078 } 10079 10080 10081 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 10082 rval = QUE_COMMAND; 10083 } else if (bp == un->un_sbufp) { 10084 if (rinfo->privatelen == sizeof (recov_info)) { 10085 if (rinfo->cmd_attrib->retriable) { 10086 /* 10087 * These commands can be rerun 10088 * with impunity 10089 */ 10090 rval = QUE_COMMAND; 10091 } 10092 } else { 10093 cmd_attribute const *attrib; 10094 attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 10095 if (attrib->retriable) { 10096 rval = QUE_COMMAND; 10097 } 10098 } 10099 } 10100 10101 if (un->un_state >= ST_STATE_OPEN) { 10102 scsi_log(ST_DEVINFO, st_label, CE_WARN, 10103 fail, scsi_rname(pkt->pkt_reason), 10104 (rval == COMMAND_DONE_ERROR)? 10105 "giving up" : "retrying command"); 10106 } 10107 return (rval); 10108 } 10109 10110 /* 10111 * if the device is busy, then put this bp back on the waitq, on the 10112 * interrupt thread, where we want the head of the queue and not the 10113 * end 10114 * 10115 * The callers of this routine should take measures to save the 10116 * un_throttle in un_last_throttle which will be restored in 10117 * st_intr_restart(). The only exception should be st_intr_restart() 10118 * calling this routine for which the saving is already done. 10119 */ 10120 static int 10121 st_handle_intr_busy(struct scsi_tape *un, struct buf *bp, 10122 clock_t timeout_interval) 10123 { 10124 10125 int queued; 10126 int rval = 0; 10127 pkt_info *pktinfo = BP_PKT(bp)->pkt_private; 10128 10129 mutex_enter(ST_MUTEX); 10130 10131 ST_FUNC(ST_DEVINFO, st_handle_intr_busy); 10132 10133 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10134 "st_handle_intr_busy(), un = 0x%p\n", (void *)un); 10135 10136 if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) { 10137 queued = 1; 10138 } else { 10139 queued = 0; 10140 } 10141 10142 /* 10143 * Check to see if we hit the retry timeout. We check to make sure 10144 * this is the first one on the runq and make sure we have not 10145 * queued up any more, so this one has to be the last on the list 10146 * also. If it is not, we have to fail. If it is not the first, but 10147 * is the last we are in trouble anyway, as we are in the interrupt 10148 * context here. 10149 */ 10150 if ((pktinfo->str_retry_cnt++ > st_retry_count) || 10151 ((un->un_runqf != bp) && (un->un_runql != bp) && (queued))) { 10152 rval = -1; 10153 goto exit; 10154 } 10155 10156 /* put the bp back on the waitq */ 10157 if (queued) { 10158 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 10159 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quef, bp); 10160 } 10161 10162 /* 10163 * We don't want any other commands being started in the mean time. 10164 * If start had just released mutex after putting something on the 10165 * runq, we won't even get here. 10166 */ 10167 un->un_throttle = 0; 10168 10169 /* 10170 * send a marker pkt, if appropriate 10171 */ 10172 st_hba_unflush(un); 10173 10174 /* 10175 * all queues are aligned, we are just waiting to 10176 * transport 10177 */ 10178 un->un_hib_tid = timeout(st_intr_restart, un, timeout_interval); 10179 10180 exit: 10181 mutex_exit(ST_MUTEX); 10182 return (rval); 10183 } 10184 10185 /* 10186 * To get one error entry from error stack 10187 */ 10188 static int 10189 st_get_error_entry(struct scsi_tape *un, intptr_t arg, int flag) 10190 { 10191 #ifdef _MULTI_DATAMODEL 10192 /* 10193 * For use when a 32 bit app makes a call into a 10194 * 64 bit ioctl 10195 */ 10196 struct mterror_entry32 err_entry32; 10197 #endif /* _MULTI_DATAMODEL */ 10198 10199 int rval = 0; 10200 struct mterror_entry err_entry; 10201 struct mterror_entry_stack *err_link_entry_p; 10202 size_t arq_status_len_in, arq_status_len_kr; 10203 10204 ST_FUNC(ST_DEVINFO, st_get_error_entry); 10205 10206 ASSERT(mutex_owned(ST_MUTEX)); 10207 10208 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10209 "st_get_error_entry()\n"); 10210 10211 /* 10212 * if error record stack empty, return ENXIO 10213 */ 10214 if (un->un_error_entry_stk == NULL) { 10215 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10216 "st_get_error_entry: Error Entry Stack Empty!\n"); 10217 rval = ENXIO; 10218 goto ret; 10219 } 10220 10221 /* 10222 * get the top entry from stack 10223 */ 10224 err_link_entry_p = un->un_error_entry_stk; 10225 arq_status_len_kr = 10226 err_link_entry_p->mtees_entry.mtee_arq_status_len; 10227 10228 #ifdef _MULTI_DATAMODEL 10229 switch (ddi_model_convert_from(flag & FMODELS)) { 10230 case DDI_MODEL_ILP32: 10231 if (ddi_copyin((void *)arg, &err_entry32, 10232 MTERROR_ENTRY_SIZE_32, flag)) { 10233 rval = EFAULT; 10234 goto ret; 10235 } 10236 10237 arq_status_len_in = 10238 (size_t)err_entry32.mtee_arq_status_len; 10239 10240 err_entry32.mtee_cdb_len = 10241 (size32_t)err_link_entry_p->mtees_entry.mtee_cdb_len; 10242 10243 if (arq_status_len_in > arq_status_len_kr) 10244 err_entry32.mtee_arq_status_len = 10245 (size32_t)arq_status_len_kr; 10246 10247 if (ddi_copyout( 10248 err_link_entry_p->mtees_entry.mtee_cdb_buf, 10249 (void *)(uintptr_t)err_entry32.mtee_cdb_buf, 10250 err_entry32.mtee_cdb_len, flag)) { 10251 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10252 "st_get_error_entry: Copy cdb buffer error!"); 10253 rval = EFAULT; 10254 } 10255 10256 if (ddi_copyout( 10257 err_link_entry_p->mtees_entry.mtee_arq_status, 10258 (void *)(uintptr_t)err_entry32.mtee_arq_status, 10259 err_entry32.mtee_arq_status_len, flag)) { 10260 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10261 "st_get_error_entry: copy arq status error!"); 10262 rval = EFAULT; 10263 } 10264 10265 if (ddi_copyout(&err_entry32, (void *)arg, 10266 MTERROR_ENTRY_SIZE_32, flag)) { 10267 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10268 "st_get_error_entry: copy arq status out error!"); 10269 rval = EFAULT; 10270 } 10271 break; 10272 10273 case DDI_MODEL_NONE: 10274 if (ddi_copyin((void *)arg, &err_entry, 10275 MTERROR_ENTRY_SIZE_64, flag)) { 10276 rval = EFAULT; 10277 goto ret; 10278 } 10279 arq_status_len_in = err_entry.mtee_arq_status_len; 10280 10281 err_entry.mtee_cdb_len = 10282 err_link_entry_p->mtees_entry.mtee_cdb_len; 10283 10284 if (arq_status_len_in > arq_status_len_kr) 10285 err_entry.mtee_arq_status_len = 10286 arq_status_len_kr; 10287 10288 if (ddi_copyout( 10289 err_link_entry_p->mtees_entry.mtee_cdb_buf, 10290 err_entry.mtee_cdb_buf, 10291 err_entry.mtee_cdb_len, flag)) { 10292 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10293 "st_get_error_entry: Copy cdb buffer error!"); 10294 rval = EFAULT; 10295 } 10296 10297 if (ddi_copyout( 10298 err_link_entry_p->mtees_entry.mtee_arq_status, 10299 err_entry.mtee_arq_status, 10300 err_entry.mtee_arq_status_len, flag)) { 10301 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10302 "st_get_error_entry: copy arq status error!"); 10303 rval = EFAULT; 10304 } 10305 10306 if (ddi_copyout(&err_entry, (void *)arg, 10307 MTERROR_ENTRY_SIZE_64, flag)) { 10308 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10309 "st_get_error_entry: copy arq status out error!"); 10310 rval = EFAULT; 10311 } 10312 break; 10313 } 10314 #else /* _MULTI_DATAMODEL */ 10315 if (ddi_copyin((void *)arg, &err_entry, 10316 MTERROR_ENTRY_SIZE_64, flag)) { 10317 rval = EFAULT; 10318 goto ret; 10319 } 10320 arq_status_len_in = err_entry.mtee_arq_status_len; 10321 10322 err_entry.mtee_cdb_len = 10323 err_link_entry_p->mtees_entry.mtee_cdb_len; 10324 10325 if (arq_status_len_in > arq_status_len_kr) 10326 err_entry.mtee_arq_status_len = 10327 arq_status_len_kr; 10328 10329 if (ddi_copyout( 10330 err_link_entry_p->mtees_entry.mtee_cdb_buf, 10331 err_entry.mtee_cdb_buf, 10332 err_entry.mtee_cdb_len, flag)) { 10333 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10334 "st_get_error_entry: Copy cdb buffer error!"); 10335 rval = EFAULT; 10336 } 10337 10338 if (ddi_copyout( 10339 err_link_entry_p->mtees_entry.mtee_arq_status, 10340 err_entry.mtee_arq_status, 10341 err_entry.mtee_arq_status_len, flag)) { 10342 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10343 "st_get_error_entry: copy arq status buffer error!"); 10344 rval = EFAULT; 10345 } 10346 10347 if (ddi_copyout(&err_entry, (void *)arg, 10348 MTERROR_ENTRY_SIZE_64, flag)) { 10349 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10350 "st_get_error_entry: copy arq status out error!"); 10351 rval = EFAULT; 10352 } 10353 #endif /* _MULTI_DATAMODEL */ 10354 10355 /* 10356 * update stack 10357 */ 10358 un->un_error_entry_stk = err_link_entry_p->mtees_nextp; 10359 10360 kmem_free(err_link_entry_p->mtees_entry.mtee_cdb_buf, 10361 err_link_entry_p->mtees_entry.mtee_cdb_len); 10362 err_link_entry_p->mtees_entry.mtee_cdb_buf = NULL; 10363 10364 kmem_free(err_link_entry_p->mtees_entry.mtee_arq_status, 10365 SECMDS_STATUS_SIZE); 10366 err_link_entry_p->mtees_entry.mtee_arq_status = NULL; 10367 10368 kmem_free(err_link_entry_p, MTERROR_LINK_ENTRY_SIZE); 10369 err_link_entry_p = NULL; 10370 ret: 10371 return (rval); 10372 } 10373 10374 /* 10375 * MTIOCGETERROR ioctl needs to retrieve the current sense data along with 10376 * the scsi CDB command which causes the error and generates sense data and 10377 * the scsi status. 10378 * 10379 * error-record stack 10380 * 10381 * 10382 * TOP BOTTOM 10383 * ------------------------------------------ 10384 * | 0 | 1 | 2 | ... | n | 10385 * ------------------------------------------ 10386 * ^ 10387 * | 10388 * pointer to error entry 10389 * 10390 * when st driver generates one sense data record, it creates a error-entry 10391 * and pushes it onto the stack. 10392 * 10393 */ 10394 10395 static void 10396 st_update_error_stack(struct scsi_tape *un, 10397 struct scsi_pkt *pkt, 10398 struct scsi_arq_status *cmd) 10399 { 10400 struct mterror_entry_stack *err_entry_tmp; 10401 uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp; 10402 size_t cdblen = scsi_cdb_size[CDB_GROUPID(cdbp[0])]; 10403 10404 ST_FUNC(ST_DEVINFO, st_update_error_stack); 10405 10406 ASSERT(mutex_owned(ST_MUTEX)); 10407 10408 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10409 "st_update_error_stack()\n"); 10410 10411 ASSERT(cmd); 10412 ASSERT(cdbp); 10413 if (cdblen == 0) { 10414 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10415 "st_update_error_stack: CDB length error!\n"); 10416 return; 10417 } 10418 10419 err_entry_tmp = kmem_alloc(MTERROR_LINK_ENTRY_SIZE, KM_SLEEP); 10420 ASSERT(err_entry_tmp != NULL); 10421 10422 err_entry_tmp->mtees_entry.mtee_cdb_buf = 10423 kmem_alloc(cdblen, KM_SLEEP); 10424 ASSERT(err_entry_tmp->mtees_entry.mtee_cdb_buf != NULL); 10425 10426 err_entry_tmp->mtees_entry.mtee_arq_status = 10427 kmem_alloc(SECMDS_STATUS_SIZE, KM_SLEEP); 10428 ASSERT(err_entry_tmp->mtees_entry.mtee_arq_status != NULL); 10429 10430 /* 10431 * copy cdb command & length to current error entry 10432 */ 10433 err_entry_tmp->mtees_entry.mtee_cdb_len = cdblen; 10434 bcopy(cdbp, err_entry_tmp->mtees_entry.mtee_cdb_buf, cdblen); 10435 10436 /* 10437 * copy scsi status length to current error entry 10438 */ 10439 err_entry_tmp->mtees_entry.mtee_arq_status_len = 10440 SECMDS_STATUS_SIZE; 10441 10442 /* 10443 * copy sense data and scsi status to current error entry 10444 */ 10445 bcopy(cmd, err_entry_tmp->mtees_entry.mtee_arq_status, 10446 SECMDS_STATUS_SIZE); 10447 10448 err_entry_tmp->mtees_nextp = un->un_error_entry_stk; 10449 un->un_error_entry_stk = err_entry_tmp; 10450 10451 } 10452 10453 /* 10454 * Empty all the error entry in stack 10455 */ 10456 static void 10457 st_empty_error_stack(struct scsi_tape *un) 10458 { 10459 struct mterror_entry_stack *linkp; 10460 10461 ST_FUNC(ST_DEVINFO, st_empty_error_stack); 10462 10463 ASSERT(mutex_owned(ST_MUTEX)); 10464 10465 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10466 "st_empty_entry_stack()\n"); 10467 10468 while (un->un_error_entry_stk != NULL) { 10469 linkp = un->un_error_entry_stk; 10470 un->un_error_entry_stk = 10471 un->un_error_entry_stk->mtees_nextp; 10472 10473 if (linkp->mtees_entry.mtee_cdb_buf != NULL) 10474 kmem_free(linkp->mtees_entry.mtee_cdb_buf, 10475 linkp->mtees_entry.mtee_cdb_len); 10476 10477 if (linkp->mtees_entry.mtee_arq_status != NULL) 10478 kmem_free(linkp->mtees_entry.mtee_arq_status, 10479 linkp->mtees_entry.mtee_arq_status_len); 10480 10481 kmem_free(linkp, MTERROR_LINK_ENTRY_SIZE); 10482 linkp = NULL; 10483 } 10484 } 10485 10486 static errstate 10487 st_handle_sense(struct scsi_tape *un, struct buf *bp, tapepos_t *pos) 10488 { 10489 struct scsi_pkt *pkt = BP_PKT(bp); 10490 struct scsi_pkt *rqpkt = un->un_rqs; 10491 struct scsi_arq_status arqstat; 10492 recov_info *rcif = pkt->pkt_private; 10493 10494 errstate rval = COMMAND_DONE_ERROR; 10495 int amt; 10496 10497 ST_FUNC(ST_DEVINFO, st_handle_sense); 10498 10499 ASSERT(mutex_owned(ST_MUTEX)); 10500 10501 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10502 "st_handle_sense()\n"); 10503 10504 if (SCBP(rqpkt)->sts_busy) { 10505 if (rcif->privatelen == sizeof (recov_info)) { 10506 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 10507 "Attempt recovery of busy unit on request sense\n"); 10508 rval = ATTEMPT_RETRY; 10509 } else if (rcif->pkt_retry_cnt++ < st_retry_count) { 10510 ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN, 10511 "Retry busy unit on request sense\n"); 10512 rval = QUE_BUSY_COMMAND; 10513 } 10514 return (rval); 10515 } else if (SCBP(rqpkt)->sts_chk) { 10516 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10517 "Check Condition on REQUEST SENSE\n"); 10518 return (rval); 10519 } 10520 10521 /* 10522 * Make sure there is sense data to look at. 10523 */ 10524 if ((rqpkt->pkt_state & (STATE_GOT_BUS | STATE_GOT_TARGET | 10525 STATE_SENT_CMD | STATE_GOT_STATUS)) != (STATE_GOT_BUS | 10526 STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS)) { 10527 return (rval); 10528 } 10529 10530 /* was there enough data? */ 10531 amt = (int)MAX_SENSE_LENGTH - rqpkt->pkt_resid; 10532 if ((rqpkt->pkt_state & STATE_XFERRED_DATA) == 0 || 10533 (amt < SUN_MIN_SENSE_LENGTH)) { 10534 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10535 "REQUEST SENSE couldn't get sense data\n"); 10536 return (rval); 10537 } 10538 10539 bcopy(SCBP(pkt), &arqstat.sts_status, 10540 sizeof (struct scsi_status)); 10541 bcopy(SCBP(rqpkt), &arqstat.sts_rqpkt_status, 10542 sizeof (struct scsi_status)); 10543 arqstat.sts_rqpkt_reason = rqpkt->pkt_reason; 10544 arqstat.sts_rqpkt_resid = rqpkt->pkt_resid; 10545 arqstat.sts_rqpkt_state = rqpkt->pkt_state; 10546 arqstat.sts_rqpkt_statistics = rqpkt->pkt_statistics; 10547 bcopy(ST_RQSENSE, &arqstat.sts_sensedata, SENSE_LENGTH); 10548 10549 /* 10550 * copy one arqstat entry in the sense data buffer 10551 */ 10552 st_update_error_stack(un, pkt, &arqstat); 10553 return (st_decode_sense(un, bp, amt, &arqstat, pos)); 10554 } 10555 10556 static errstate 10557 st_handle_autosense(struct scsi_tape *un, struct buf *bp, tapepos_t *pos) 10558 { 10559 struct scsi_pkt *pkt = BP_PKT(bp); 10560 struct scsi_arq_status *arqstat = 10561 (struct scsi_arq_status *)pkt->pkt_scbp; 10562 errstate rval = COMMAND_DONE_ERROR; 10563 int amt; 10564 10565 ST_FUNC(ST_DEVINFO, st_handle_autosense); 10566 10567 ASSERT(mutex_owned(ST_MUTEX)); 10568 10569 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10570 "st_handle_autosense()\n"); 10571 10572 if (arqstat->sts_rqpkt_status.sts_busy) { 10573 ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN, 10574 "busy unit on request sense\n"); 10575 /* 10576 * we return QUE_SENSE so st_intr will setup the SENSE cmd. 10577 * the disadvantage is that we do not have any delay for the 10578 * second retry of rqsense and we have to keep a packet around 10579 */ 10580 return (QUE_SENSE); 10581 10582 } else if (arqstat->sts_rqpkt_reason != CMD_CMPLT) { 10583 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10584 "transport error on REQUEST SENSE\n"); 10585 if ((arqstat->sts_rqpkt_state & STATE_GOT_TARGET) && 10586 ((arqstat->sts_rqpkt_statistics & 10587 (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) == 0)) { 10588 if (st_reset(un, RESET_LUN) == 0) { 10589 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10590 "recovery by resets failed\n"); 10591 } 10592 } 10593 return (rval); 10594 10595 } else if (arqstat->sts_rqpkt_status.sts_chk) { 10596 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10597 "Check Condition on REQUEST SENSE\n"); 10598 return (rval); 10599 } 10600 10601 10602 /* was there enough data? */ 10603 if (pkt->pkt_state & STATE_XARQ_DONE) { 10604 amt = (int)MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10605 } else { 10606 if (arqstat->sts_rqpkt_resid > SENSE_LENGTH) { 10607 amt = (int)MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10608 } else { 10609 amt = (int)SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10610 } 10611 } 10612 if ((arqstat->sts_rqpkt_state & STATE_XFERRED_DATA) == 0 || 10613 (amt < SUN_MIN_SENSE_LENGTH)) { 10614 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10615 "REQUEST SENSE couldn't get sense data\n"); 10616 return (rval); 10617 } 10618 10619 if (pkt->pkt_state & STATE_XARQ_DONE) { 10620 bcopy(&arqstat->sts_sensedata, ST_RQSENSE, MAX_SENSE_LENGTH); 10621 } else { 10622 bcopy(&arqstat->sts_sensedata, ST_RQSENSE, SENSE_LENGTH); 10623 } 10624 10625 /* 10626 * copy one arqstat entry in the sense data buffer 10627 */ 10628 st_update_error_stack(un, pkt, arqstat); 10629 10630 return (st_decode_sense(un, bp, amt, arqstat, pos)); 10631 } 10632 10633 static errstate 10634 st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt, 10635 struct scsi_arq_status *statusp, tapepos_t *pos) 10636 { 10637 struct scsi_pkt *pkt = BP_PKT(bp); 10638 recov_info *ri = pkt->pkt_private; 10639 errstate rval = COMMAND_DONE_ERROR; 10640 cmd_attribute const *attrib; 10641 long resid; 10642 struct scsi_extended_sense *sensep = ST_RQSENSE; 10643 int severity; 10644 int get_error; 10645 10646 ST_FUNC(ST_DEVINFO, st_decode_sense); 10647 10648 ASSERT(mutex_owned(ST_MUTEX)); 10649 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10650 "st_decode_sense()\n"); 10651 10652 /* 10653 * For uscsi commands, squirrel away a copy of the 10654 * results of the Request Sense. 10655 */ 10656 if (USCSI_CMD(bp)) { 10657 struct uscsi_cmd *ucmd = BP_UCMD(bp); 10658 ucmd->uscsi_rqstatus = *(uchar_t *)statusp; 10659 if (ucmd->uscsi_rqlen && un->un_srqbufp) { 10660 uchar_t rqlen = min((uchar_t)amt, ucmd->uscsi_rqlen); 10661 ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen; 10662 bcopy(ST_RQSENSE, un->un_srqbufp, rqlen); 10663 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10664 "st_decode_sense: stat=0x%x resid=0x%x\n", 10665 ucmd->uscsi_rqstatus, ucmd->uscsi_rqresid); 10666 } 10667 } 10668 10669 if (ri->privatelen == sizeof (recov_info)) { 10670 attrib = ri->cmd_attrib; 10671 } else { 10672 attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 10673 } 10674 10675 /* 10676 * If the drive is an MT-02, reposition the 10677 * secondary error code into the proper place. 10678 * 10679 * XXX MT-02 is non-CCS tape, so secondary error code 10680 * is in byte 8. However, in SCSI-2, tape has CCS definition 10681 * so it's in byte 12. 10682 */ 10683 if (un->un_dp->type == ST_TYPE_EMULEX) { 10684 sensep->es_code = sensep->es_add_info[0]; 10685 } 10686 10687 ST_CDB(ST_DEVINFO, "st_decode_sense failed CDB", 10688 (caddr_t)&CDBP(pkt)->scc_cmd); 10689 10690 ST_SENSE(ST_DEVINFO, "st_decode_sense sense data", (caddr_t)statusp, 10691 sizeof (*statusp)); 10692 10693 /* for normal I/O check extract the resid values. */ 10694 if (bp != un->un_sbufp && bp != un->un_recov_buf) { 10695 if (sensep->es_valid) { 10696 resid = 10697 (sensep->es_info_1 << 24) | 10698 (sensep->es_info_2 << 16) | 10699 (sensep->es_info_3 << 8) | 10700 (sensep->es_info_4); 10701 /* If fixed block */ 10702 if (un->un_bsize) { 10703 resid *= un->un_bsize; 10704 } 10705 } else if (pkt->pkt_state & STATE_XFERRED_DATA) { 10706 resid = pkt->pkt_resid; 10707 } else { 10708 resid = bp->b_bcount; 10709 } 10710 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10711 "st_decode_sense (rw): xferred bit = %d, resid=%ld (%d), " 10712 "pkt_resid=%ld\n", pkt->pkt_state & STATE_XFERRED_DATA, 10713 resid, 10714 (sensep->es_info_1 << 24) | 10715 (sensep->es_info_2 << 16) | 10716 (sensep->es_info_3 << 8) | 10717 (sensep->es_info_4), 10718 pkt->pkt_resid); 10719 /* 10720 * The problem is, what should we believe? 10721 */ 10722 if (resid && (pkt->pkt_resid == 0)) { 10723 pkt->pkt_resid = resid; 10724 } 10725 } else { 10726 /* 10727 * If the command is SCMD_SPACE, we need to get the 10728 * residual as returned in the sense data, to adjust 10729 * our idea of current tape position correctly 10730 */ 10731 if ((sensep->es_valid) && 10732 (CDBP(pkt)->scc_cmd == SCMD_LOCATE) || 10733 (CDBP(pkt)->scc_cmd == SCMD_LOCATE_G4) || 10734 (CDBP(pkt)->scc_cmd == SCMD_SPACE) || 10735 (CDBP(pkt)->scc_cmd == SCMD_SPACE_G4) || 10736 (CDBP(pkt)->scc_cmd == SCMD_WRITE_FILE_MARK)) { 10737 resid = 10738 (sensep->es_info_1 << 24) | 10739 (sensep->es_info_2 << 16) | 10740 (sensep->es_info_3 << 8) | 10741 (sensep->es_info_4); 10742 bp->b_resid = resid; 10743 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10744 "st_decode_sense(other): resid=%ld\n", resid); 10745 } else { 10746 /* 10747 * If the special command is SCMD_READ, 10748 * the correct resid will be set later. 10749 */ 10750 if (attrib->get_cnt != NULL) { 10751 resid = attrib->get_cnt(pkt->pkt_cdbp); 10752 } else { 10753 resid = bp->b_bcount; 10754 } 10755 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10756 "st_decode_sense(special read): resid=%ld\n", 10757 resid); 10758 } 10759 } 10760 10761 if ((un->un_state >= ST_STATE_OPEN) && 10762 (DEBUGGING || st_error_level == SCSI_ERR_ALL)) { 10763 st_print_cdb(ST_DEVINFO, st_label, CE_NOTE, 10764 "Failed CDB", (char *)pkt->pkt_cdbp); 10765 st_clean_print(ST_DEVINFO, st_label, CE_CONT, 10766 "sense data", (char *)sensep, amt); 10767 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10768 "count 0x%lx resid 0x%lx pktresid 0x%lx\n", 10769 bp->b_bcount, resid, pkt->pkt_resid); 10770 } 10771 10772 switch (un->un_status = sensep->es_key) { 10773 case KEY_NO_SENSE: 10774 severity = SCSI_ERR_INFO; 10775 10776 /* 10777 * Erase, locate or rewind operation in progress, retry 10778 * ASC ASCQ 10779 * 00 18 Erase operation in progress 10780 * 00 19 Locate operation in progress 10781 * 00 1A Rewind operation in progress 10782 */ 10783 if (sensep->es_add_code == 0 && 10784 ((sensep->es_qual_code == 0x18) || 10785 (sensep->es_qual_code == 0x19) || 10786 (sensep->es_qual_code == 0x1a))) { 10787 rval = QUE_BUSY_COMMAND; 10788 break; 10789 } 10790 10791 goto common; 10792 10793 case KEY_RECOVERABLE_ERROR: 10794 severity = SCSI_ERR_RECOVERED; 10795 if ((sensep->es_class == CLASS_EXTENDED_SENSE) && 10796 (sensep->es_code == ST_DEFERRED_ERROR)) { 10797 if (un->un_dp->options & 10798 ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) { 10799 rval = QUE_LAST_COMMAND; 10800 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, 10801 severity, pos->lgclblkno, 10802 un->un_err_pos.lgclblkno, scsi_cmds, 10803 sensep); 10804 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10805 "Command will be retried\n"); 10806 } else { 10807 severity = SCSI_ERR_FATAL; 10808 rval = COMMAND_DONE_ERROR_RECOVERED; 10809 ST_DO_ERRSTATS(un, st_softerrs); 10810 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, 10811 severity, pos->lgclblkno, 10812 un->un_err_pos.lgclblkno, scsi_cmds, 10813 sensep); 10814 } 10815 break; 10816 } 10817 common: 10818 /* 10819 * XXX only want reads to be stopped by filemarks. 10820 * Don't want them to be stopped by EOT. EOT matters 10821 * only on write. 10822 */ 10823 if (sensep->es_filmk && !sensep->es_eom) { 10824 rval = COMMAND_DONE; 10825 } else if (sensep->es_eom) { 10826 rval = COMMAND_DONE; 10827 } else if (sensep->es_ili) { 10828 /* 10829 * Fun with variable length record devices: 10830 * for specifying larger blocks sizes than the 10831 * actual physical record size. 10832 */ 10833 if (un->un_bsize == 0 && resid > 0) { 10834 /* 10835 * XXX! Ugly. 10836 * The requested blocksize is > tape blocksize, 10837 * so this is ok, so we just return the 10838 * actual size xferred. 10839 */ 10840 pkt->pkt_resid = resid; 10841 rval = COMMAND_DONE; 10842 } else if (un->un_bsize == 0 && resid < 0) { 10843 /* 10844 * The requested blocksize is < tape blocksize, 10845 * so this is not ok, so we err with ENOMEM 10846 */ 10847 rval = COMMAND_DONE_ERROR_RECOVERED; 10848 st_bioerror(bp, ENOMEM); 10849 } else { 10850 ST_DO_ERRSTATS(un, st_softerrs); 10851 severity = SCSI_ERR_FATAL; 10852 rval = COMMAND_DONE_ERROR; 10853 st_bioerror(bp, EINVAL); 10854 un->un_running.pmode = invalid; 10855 } 10856 } else { 10857 /* 10858 * we hope and pray for this just being 10859 * something we can ignore (ie. a 10860 * truly recoverable soft error) 10861 */ 10862 rval = COMMAND_DONE; 10863 } 10864 if (sensep->es_filmk) { 10865 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10866 "filemark\n"); 10867 un->un_status = SUN_KEY_EOF; 10868 pos->eof = ST_EOF_PENDING; 10869 st_set_pe_flag(un); 10870 } 10871 10872 /* 10873 * ignore eom when reading, a fmk should terminate reading 10874 */ 10875 if ((sensep->es_eom) && 10876 (CDBP(pkt)->scc_cmd != SCMD_READ)) { 10877 if ((sensep->es_add_code == 0) && 10878 (sensep->es_qual_code == 4)) { 10879 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10880 "bot\n"); 10881 un->un_status = SUN_KEY_BOT; 10882 pos->eof = ST_NO_EOF; 10883 pos->lgclblkno = 0; 10884 pos->fileno = 0; 10885 pos->blkno = 0; 10886 if (pos->pmode != legacy) 10887 pos->pmode = legacy; 10888 } else { 10889 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10890 "eom\n"); 10891 un->un_status = SUN_KEY_EOT; 10892 pos->eof = ST_EOM; 10893 } 10894 st_set_pe_flag(un); 10895 } 10896 10897 break; 10898 10899 case KEY_ILLEGAL_REQUEST: 10900 10901 if (un->un_laststate >= ST_STATE_OPEN) { 10902 ST_DO_ERRSTATS(un, st_softerrs); 10903 severity = SCSI_ERR_FATAL; 10904 } else { 10905 severity = SCSI_ERR_INFO; 10906 } 10907 break; 10908 10909 case KEY_MEDIUM_ERROR: 10910 ST_DO_ERRSTATS(un, st_harderrs); 10911 severity = SCSI_ERR_FATAL; 10912 un->un_pos.pmode = invalid; 10913 un->un_running.pmode = invalid; 10914 check_keys: 10915 /* 10916 * attempt to process the keys in the presence of 10917 * other errors 10918 */ 10919 if (sensep->es_ili && rval != COMMAND_DONE_ERROR) { 10920 /* 10921 * Fun with variable length record devices: 10922 * for specifying larger blocks sizes than the 10923 * actual physical record size. 10924 */ 10925 if (un->un_bsize == 0 && resid > 0) { 10926 /* 10927 * XXX! Ugly 10928 */ 10929 pkt->pkt_resid = resid; 10930 } else if (un->un_bsize == 0 && resid < 0) { 10931 st_bioerror(bp, EINVAL); 10932 } else { 10933 severity = SCSI_ERR_FATAL; 10934 rval = COMMAND_DONE_ERROR; 10935 st_bioerror(bp, EINVAL); 10936 } 10937 } 10938 if (sensep->es_filmk) { 10939 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10940 "filemark\n"); 10941 un->un_status = SUN_KEY_EOF; 10942 pos->eof = ST_EOF_PENDING; 10943 st_set_pe_flag(un); 10944 } 10945 10946 /* 10947 * ignore eom when reading, a fmk should terminate reading 10948 */ 10949 if ((sensep->es_eom) && 10950 (CDBP(pkt)->scc_cmd != SCMD_READ)) { 10951 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "eom\n"); 10952 un->un_status = SUN_KEY_EOT; 10953 pos->eof = ST_EOM; 10954 st_set_pe_flag(un); 10955 } 10956 10957 break; 10958 10959 case KEY_VOLUME_OVERFLOW: 10960 ST_DO_ERRSTATS(un, st_softerrs); 10961 pos->eof = ST_EOM; 10962 severity = SCSI_ERR_FATAL; 10963 rval = COMMAND_DONE_ERROR; 10964 goto check_keys; 10965 10966 case KEY_HARDWARE_ERROR: 10967 ST_DO_ERRSTATS(un, st_harderrs); 10968 severity = SCSI_ERR_FATAL; 10969 rval = COMMAND_DONE_ERROR; 10970 if (un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) 10971 un->un_eject_tape_on_failure = st_check_asc_ascq(un); 10972 break; 10973 10974 case KEY_BLANK_CHECK: 10975 ST_DO_ERRSTATS(un, st_softerrs); 10976 severity = SCSI_ERR_INFO; 10977 10978 /* 10979 * if not a special request and some data was xferred then it 10980 * it is not an error yet 10981 */ 10982 if (bp != un->un_sbufp && (bp->b_flags & B_READ)) { 10983 /* 10984 * no error for read with or without data xferred 10985 */ 10986 un->un_status = SUN_KEY_EOT; 10987 pos->eof = ST_EOT; 10988 rval = COMMAND_DONE_ERROR; 10989 un->un_running.pmode = invalid; 10990 st_set_pe_flag(un); 10991 goto check_keys; 10992 } else if (bp != un->un_sbufp && 10993 (pkt->pkt_state & STATE_XFERRED_DATA)) { 10994 rval = COMMAND_DONE; 10995 } else { 10996 rval = COMMAND_DONE_ERROR_RECOVERED; 10997 } 10998 10999 if (un->un_laststate >= ST_STATE_OPEN) { 11000 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11001 "blank check\n"); 11002 pos->eof = ST_EOM; 11003 } 11004 if ((CDBP(pkt)->scc_cmd == SCMD_LOCATE) || 11005 (CDBP(pkt)->scc_cmd == SCMD_LOCATE_G4) || 11006 (CDBP(pkt)->scc_cmd == SCMD_SPACE) && 11007 (un->un_dp->options & ST_KNOWS_EOD)) { 11008 /* 11009 * we were doing a fast forward by skipping 11010 * multiple fmk at the time 11011 */ 11012 st_bioerror(bp, EIO); 11013 severity = SCSI_ERR_RECOVERED; 11014 rval = COMMAND_DONE; 11015 } 11016 st_set_pe_flag(un); 11017 goto check_keys; 11018 11019 case KEY_WRITE_PROTECT: 11020 if (st_wrongtapetype(un)) { 11021 un->un_status = SUN_KEY_WRONGMEDIA; 11022 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11023 "wrong tape for writing- use DC6150 tape " 11024 "(or equivalent)\n"); 11025 severity = SCSI_ERR_UNKNOWN; 11026 } else { 11027 severity = SCSI_ERR_FATAL; 11028 } 11029 ST_DO_ERRSTATS(un, st_harderrs); 11030 rval = COMMAND_DONE_ERROR; 11031 st_bioerror(bp, EACCES); 11032 break; 11033 11034 case KEY_UNIT_ATTENTION: 11035 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11036 "KEY_UNIT_ATTENTION : un_state = %d\n", un->un_state); 11037 11038 un->un_unit_attention_flags |= 1; 11039 /* 11040 * If we have detected a Bus Reset and the tape 11041 * drive has been reserved. 11042 */ 11043 if (ST_RQSENSE->es_add_code == 0x29) { 11044 rval = DEVICE_RESET; 11045 if ((un->un_rsvd_status & 11046 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 11047 ST_RESERVE) { 11048 un->un_rsvd_status |= ST_LOST_RESERVE; 11049 ST_DEBUG(ST_DEVINFO, st_label, CE_WARN, 11050 "st_decode_sense: Lost Reservation\n"); 11051 } 11052 } 11053 11054 /* 11055 * If this is a recovery command and retrable, retry. 11056 */ 11057 if (bp == un->un_recov_buf) { 11058 severity = SCSI_ERR_INFO; 11059 if (attrib->retriable && 11060 ri->pkt_retry_cnt++ < st_retry_count) { 11061 rval = QUE_COMMAND; 11062 } else { 11063 rval = COMMAND_DONE_ERROR; 11064 } 11065 break; /* Don't set position invalid */ 11066 } 11067 11068 /* 11069 * If ST_APPLICATION_RESERVATIONS is set, 11070 * If the asc/ascq indicates that the reservation 11071 * has been cleared just allow the write to continue 11072 * which would force a scsi 2 reserve. 11073 * If preempted that persistent reservation 11074 * the scsi 2 reserve would get a reservation conflict. 11075 */ 11076 if ((un->un_rsvd_status & 11077 ST_APPLICATION_RESERVATIONS) != 0) { 11078 /* 11079 * RESERVATIONS PREEMPTED 11080 * With MPxIO this could be a fail over? XXX 11081 */ 11082 if (ST_RQSENSE->es_add_code == 0x2a && 11083 ST_RQSENSE->es_qual_code == 0x03) { 11084 severity = SCSI_ERR_INFO; 11085 rval = COMMAND_DONE_ERROR; 11086 pos->pmode = invalid; 11087 break; 11088 /* 11089 * RESERVATIONS RELEASED 11090 */ 11091 } else if (ST_RQSENSE->es_add_code == 0x2a && 11092 ST_RQSENSE->es_qual_code == 0x04) { 11093 severity = SCSI_ERR_INFO; 11094 rval = COMMAND_DONE; 11095 break; 11096 } 11097 } 11098 11099 if (un->un_state <= ST_STATE_OPENING) { 11100 /* 11101 * Look, the tape isn't open yet, now determine 11102 * if the cause is a BUS RESET, Save the file 11103 * and Block positions for the callers to 11104 * recover from the loss of position. 11105 */ 11106 severity = SCSI_ERR_INFO; 11107 if ((pos->pmode != invalid) && 11108 (rval == DEVICE_RESET) && 11109 (un->un_restore_pos != 1)) { 11110 un->un_save_fileno = pos->fileno; 11111 un->un_save_blkno = pos->blkno; 11112 un->un_restore_pos = 1; 11113 } 11114 11115 if (attrib->retriable && 11116 ri->pkt_retry_cnt++ < st_retry_count) { 11117 rval = QUE_COMMAND; 11118 } else if (rval == DEVICE_RESET) { 11119 break; 11120 } else { 11121 rval = COMMAND_DONE_ERROR; 11122 } 11123 /* 11124 * Means it thinks the mode parameters have changed. 11125 * This is the result of a reset clearing settings or 11126 * another initiator changing what we set. 11127 */ 11128 } 11129 if (ST_RQSENSE->es_add_code == 0x2a) { 11130 if (ST_RQSENSE->es_qual_code == 0x1) { 11131 /* Error recovery will modeselect and retry. */ 11132 rval = DEVICE_TAMPER; 11133 severity = SCSI_ERR_INFO; 11134 break; /* don't set position invalid */ 11135 } 11136 if (ST_RQSENSE->es_qual_code == 0x0 || 11137 ST_RQSENSE->es_qual_code == 0x2 || 11138 ST_RQSENSE->es_qual_code == 0x3 || 11139 ST_RQSENSE->es_qual_code == 0x4 || 11140 ST_RQSENSE->es_qual_code == 0x5 || 11141 ST_RQSENSE->es_qual_code == 0x6 || 11142 ST_RQSENSE->es_qual_code == 0x7) { 11143 rval = DEVICE_TAMPER; 11144 severity = SCSI_ERR_INFO; 11145 } 11146 } else if (ST_RQSENSE->es_add_code == 0x28 && 11147 ((ST_RQSENSE->es_qual_code == 0x0) || 11148 ST_RQSENSE->es_qual_code == 0x5)) { 11149 /* 11150 * Not Ready to Ready change, Media may have changed. 11151 */ 11152 rval = DEVICE_TAMPER; 11153 severity = SCSI_ERR_RETRYABLE; 11154 } else { 11155 if (rval != DEVICE_RESET) { 11156 rval = COMMAND_DONE_ERROR; 11157 } else { 11158 /* 11159 * Returning DEVICE_RESET will call 11160 * error recovery. 11161 */ 11162 severity = SCSI_ERR_INFO; 11163 break; /* don't set position invalid */ 11164 } 11165 /* 11166 * Check if it is an Unexpected Unit Attention. 11167 * If state is >= ST_STATE_OPEN, we have 11168 * already done the initialization . 11169 * In this case it is Fatal Error 11170 * since no further reading/writing 11171 * can be done with fileno set to < 0. 11172 */ 11173 if (un->un_state >= ST_STATE_OPEN) { 11174 ST_DO_ERRSTATS(un, st_harderrs); 11175 severity = SCSI_ERR_FATAL; 11176 } else { 11177 severity = SCSI_ERR_INFO; 11178 } 11179 } 11180 11181 pos->pmode = invalid; 11182 11183 break; 11184 11185 case KEY_NOT_READY: 11186 /* 11187 * If in process of getting ready retry. 11188 */ 11189 if (sensep->es_add_code == 0x04) { 11190 switch (sensep->es_qual_code) { 11191 case 0x07: 11192 /* 11193 * We get here when the tape is rewinding. 11194 * QUE_BUSY_COMMAND retries every 10 seconds. 11195 */ 11196 if (ri->pkt_retry_cnt++ < 11197 (un->un_dp->rewind_timeout / 10)) { 11198 rval = QUE_BUSY_COMMAND; 11199 severity = SCSI_ERR_INFO; 11200 } else { 11201 /* give up */ 11202 rval = COMMAND_DONE_ERROR; 11203 severity = SCSI_ERR_FATAL; 11204 } 11205 break; 11206 case 0x01: 11207 if (ri->pkt_retry_cnt++ < st_retry_count) { 11208 rval = QUE_COMMAND; 11209 severity = SCSI_ERR_INFO; 11210 break; 11211 } 11212 default: /* FALLTHRU */ 11213 /* give up */ 11214 rval = COMMAND_DONE_ERROR; 11215 severity = SCSI_ERR_FATAL; 11216 } 11217 } else { 11218 /* give up */ 11219 rval = COMMAND_DONE_ERROR; 11220 severity = SCSI_ERR_FATAL; 11221 } 11222 11223 /* 11224 * If this was an error and after device opened 11225 * do error stats. 11226 */ 11227 if (rval == COMMAND_DONE_ERROR && 11228 un->un_state > ST_STATE_OPENING) { 11229 ST_DO_ERRSTATS(un, st_harderrs); 11230 } 11231 11232 if (ST_RQSENSE->es_add_code == 0x3a) { 11233 if (st_error_level >= SCSI_ERR_FATAL) 11234 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 11235 "Tape not inserted in drive\n"); 11236 un->un_mediastate = MTIO_EJECTED; 11237 cv_broadcast(&un->un_state_cv); 11238 } 11239 if ((un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) && 11240 (rval != QUE_COMMAND)) 11241 un->un_eject_tape_on_failure = st_check_asc_ascq(un); 11242 break; 11243 11244 case KEY_ABORTED_COMMAND: 11245 /* XXX Do drives return this when they see a lost light? */ 11246 /* Testing would say yes */ 11247 11248 if (ri->pkt_retry_cnt++ < st_retry_count) { 11249 rval = ATTEMPT_RETRY; 11250 severity = SCSI_ERR_RETRYABLE; 11251 goto check_keys; 11252 } 11253 /* 11254 * Probably a parity error... 11255 * if we retry here then this may cause data to be 11256 * written twice or data skipped during reading 11257 */ 11258 ST_DO_ERRSTATS(un, st_harderrs); 11259 severity = SCSI_ERR_FATAL; 11260 rval = COMMAND_DONE_ERROR; 11261 goto check_keys; 11262 11263 default: 11264 /* 11265 * Undecoded sense key. Try retries and hope 11266 * that will fix the problem. Otherwise, we're 11267 * dead. 11268 */ 11269 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11270 "Unhandled Sense Key '%s'\n", 11271 sense_keys[un->un_status]); 11272 ST_DO_ERRSTATS(un, st_harderrs); 11273 severity = SCSI_ERR_FATAL; 11274 rval = COMMAND_DONE_ERROR; 11275 goto check_keys; 11276 } 11277 11278 if ((!(pkt->pkt_flags & FLAG_SILENT) && 11279 un->un_state >= ST_STATE_OPEN) && (DEBUGGING || 11280 (un->un_laststate > ST_STATE_OPENING) && 11281 (severity >= st_error_level))) { 11282 11283 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity, 11284 pos->lgclblkno, un->un_err_pos.lgclblkno, 11285 scsi_cmds, sensep); 11286 if (sensep->es_filmk) { 11287 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11288 "File Mark Detected\n"); 11289 } 11290 if (sensep->es_eom) { 11291 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11292 "End-of-Media Detected\n"); 11293 } 11294 if (sensep->es_ili) { 11295 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11296 "Incorrect Length Indicator Set\n"); 11297 } 11298 } 11299 get_error = geterror(bp); 11300 if (((rval == COMMAND_DONE_ERROR) || 11301 (rval == COMMAND_DONE_ERROR_RECOVERED)) && 11302 ((get_error == EIO) || (get_error == 0))) { 11303 un->un_rqs_state |= (ST_RQS_ERROR | ST_RQS_VALID); 11304 bcopy(ST_RQSENSE, un->un_uscsi_rqs_buf, SENSE_LENGTH); 11305 if (un->un_rqs_state & ST_RQS_READ) { 11306 un->un_rqs_state &= ~(ST_RQS_READ); 11307 } else { 11308 un->un_rqs_state |= ST_RQS_OVR; 11309 } 11310 } 11311 11312 return (rval); 11313 } 11314 11315 11316 static int 11317 st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp) 11318 { 11319 int status = TRAN_ACCEPT; 11320 pkt_info *pktinfo = BP_PKT(bp)->pkt_private; 11321 11322 mutex_enter(ST_MUTEX); 11323 11324 ST_FUNC(ST_DEVINFO, st_handle_intr_retry_lcmd); 11325 11326 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 11327 "st_handle_intr_rtr_lcmd(), un = 0x%p\n", (void *)un); 11328 11329 /* 11330 * Check to see if we hit the retry timeout. We check to make sure 11331 * this is the first one on the runq and make sure we have not 11332 * queued up any more, so this one has to be the last on the list 11333 * also. If it is not, we have to fail. If it is not the first, but 11334 * is the last we are in trouble anyway, as we are in the interrupt 11335 * context here. 11336 */ 11337 if ((pktinfo->pkt_retry_cnt > st_retry_count) || 11338 ((un->un_runqf != bp) && (un->un_runql != bp))) { 11339 goto exit; 11340 } 11341 11342 if (un->un_throttle) { 11343 un->un_last_throttle = un->un_throttle; 11344 un->un_throttle = 0; 11345 } 11346 11347 /* 11348 * Here we know : bp is the first and last one on the runq 11349 * it is not necessary to put it back on the head of the 11350 * waitq and then move from waitq to runq. Save this queuing 11351 * and call scsi_transport. 11352 */ 11353 ST_CDB(ST_DEVINFO, "Retry lcmd CDB", (char *)BP_PKT(bp)->pkt_cdbp); 11354 11355 status = st_transport(un, BP_PKT(bp)); 11356 11357 if (status == TRAN_ACCEPT) { 11358 if (un->un_last_throttle) { 11359 un->un_throttle = un->un_last_throttle; 11360 } 11361 mutex_exit(ST_MUTEX); 11362 11363 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11364 "restart transport \n"); 11365 return (0); 11366 } 11367 11368 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 11369 mutex_exit(ST_MUTEX); 11370 11371 if (status == TRAN_BUSY) { 11372 if (st_handle_intr_busy(un, bp, ST_TRAN_BUSY_TIMEOUT) == 0) { 11373 return (0); 11374 } 11375 } 11376 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11377 "restart transport rejected\n"); 11378 mutex_enter(ST_MUTEX); 11379 ST_DO_ERRSTATS(un, st_transerrs); 11380 if (un->un_last_throttle) { 11381 un->un_throttle = un->un_last_throttle; 11382 } 11383 exit: 11384 mutex_exit(ST_MUTEX); 11385 return (-1); 11386 } 11387 11388 static int 11389 st_wrongtapetype(struct scsi_tape *un) 11390 { 11391 11392 ST_FUNC(ST_DEVINFO, st_wrongtapetype); 11393 11394 ASSERT(mutex_owned(ST_MUTEX)); 11395 11396 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_wrongtapetype()\n"); 11397 11398 /* 11399 * Hack to handle 600A, 600XTD, 6150 && 660 vs. 300XL tapes... 11400 */ 11401 if (un->un_dp && (un->un_dp->options & ST_QIC) && un->un_mspl) { 11402 switch (un->un_dp->type) { 11403 case ST_TYPE_WANGTEK: 11404 case ST_TYPE_ARCHIVE: 11405 /* 11406 * If this really worked, we could go off of 11407 * the density codes set in the modesense 11408 * page. For this drive, 0x10 == QIC-120, 11409 * 0xf == QIC-150, and 0x5 should be for 11410 * both QIC-24 and, maybe, QIC-11. However, 11411 * the h/w doesn't do what the manual says 11412 * that it should, so we'll key off of 11413 * getting a WRITE PROTECT error AND wp *not* 11414 * set in the mode sense information. 11415 */ 11416 /* 11417 * XXX but we already know that status is 11418 * write protect, so don't check it again. 11419 */ 11420 11421 if (un->un_status == KEY_WRITE_PROTECT && 11422 un->un_mspl->wp == 0) { 11423 return (1); 11424 } 11425 break; 11426 default: 11427 break; 11428 } 11429 } 11430 return (0); 11431 } 11432 11433 static errstate 11434 st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt) 11435 { 11436 errstate action; 11437 recov_info *rcvi = pkt->pkt_private; 11438 buf_t *bp = rcvi->cmd_bp; 11439 struct scsi_arq_status *stat = (struct scsi_arq_status *)pkt->pkt_scbp; 11440 11441 ST_FUNC(ST_DEVINFO, st_check_error); 11442 11443 ASSERT(mutex_owned(ST_MUTEX)); 11444 11445 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_error()\n"); 11446 11447 switch (SCBP_C(pkt)) { 11448 case STATUS_RESERVATION_CONFLICT: 11449 /* 11450 * Command recovery is enabled, not just opening, 11451 * we had the drive reserved and we thing its ours. 11452 * Call recovery to attempt to take it back. 11453 */ 11454 if ((rcvi->privatelen == sizeof (recov_info)) && 11455 (bp != un->un_recov_buf) && 11456 (un->un_state > ST_STATE_OPEN_PENDING_IO) && 11457 ((un->un_rsvd_status & (ST_RESERVE | 11458 ST_APPLICATION_RESERVATIONS)) != 0)) { 11459 action = ATTEMPT_RETRY; 11460 un->un_rsvd_status |= ST_LOST_RESERVE; 11461 } else { 11462 action = COMMAND_DONE_EACCES; 11463 un->un_rsvd_status |= ST_RESERVATION_CONFLICT; 11464 } 11465 break; 11466 11467 case STATUS_BUSY: 11468 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, "unit busy\n"); 11469 if (rcvi->privatelen == sizeof (recov_info) && 11470 un->un_multipath && (pkt->pkt_state == (STATE_GOT_BUS | 11471 STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS))) { 11472 /* 11473 * Status returned by scsi_vhci indicating path 11474 * has failed over. 11475 */ 11476 action = PATH_FAILED; 11477 break; 11478 } 11479 /* FALLTHRU */ 11480 case STATUS_QFULL: 11481 if (rcvi->privatelen == sizeof (recov_info)) { 11482 /* 11483 * If recovery is inabled use it instead of 11484 * blind reties. 11485 */ 11486 action = ATTEMPT_RETRY; 11487 } else if (rcvi->pkt_retry_cnt++ < st_retry_count) { 11488 action = QUE_BUSY_COMMAND; 11489 } else if ((un->un_rsvd_status & 11490 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 11491 /* 11492 * If this is a command done before reserve is done 11493 * don't reset. 11494 */ 11495 action = COMMAND_DONE_ERROR; 11496 } else { 11497 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 11498 "unit busy too long\n"); 11499 (void) st_reset(un, RESET_ALL); 11500 action = COMMAND_DONE_ERROR; 11501 } 11502 break; 11503 11504 case STATUS_CHECK: 11505 case STATUS_TERMINATED: 11506 /* 11507 * we should only get here if the auto rqsense failed 11508 * thru a uscsi cmd without autorequest sense 11509 * so we just try again 11510 */ 11511 if (un->un_arq_enabled && 11512 stat->sts_rqpkt_reason == CMD_CMPLT && 11513 (stat->sts_rqpkt_state & (STATE_GOT_BUS | 11514 STATE_GOT_TARGET | STATE_SENT_CMD | STATE_GOT_STATUS)) == 11515 (STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD | 11516 STATE_GOT_STATUS)) { 11517 11518 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 11519 "Really got sense data\n"); 11520 action = st_decode_sense(un, bp, MAX_SENSE_LENGTH - 11521 pkt->pkt_resid, stat, &un->un_pos); 11522 } else { 11523 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 11524 "Trying to queue sense command\n"); 11525 action = QUE_SENSE; 11526 } 11527 break; 11528 11529 case STATUS_TASK_ABORT: 11530 /* 11531 * This is an aborted task. This can be a reset on the other 11532 * port of a multiport drive. Lets try and recover it. 11533 */ 11534 action = DEVICE_RESET; 11535 break; 11536 11537 default: 11538 action = COMMAND_DONE; 11539 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 11540 "Unexpected scsi status byte 0x%x\n", SCBP_C(pkt)); 11541 } 11542 return (action); 11543 } 11544 11545 static void 11546 st_calc_bnum(struct scsi_tape *un, struct buf *bp, struct scsi_pkt *pkt) 11547 { 11548 int nblks; 11549 int nfiles; 11550 long count; 11551 recov_info *ri = pkt->pkt_private; 11552 cmd_attribute const *attrib; 11553 11554 ST_FUNC(ST_DEVINFO, st_calc_bnum); 11555 11556 ASSERT(mutex_owned(ST_MUTEX)); 11557 11558 if (ri->privatelen == sizeof (recov_info)) { 11559 attrib = ri->cmd_attrib; 11560 ASSERT(attrib->recov_pos_type == POS_EXPECTED); 11561 ASSERT(attrib->chg_tape_pos); 11562 } else { 11563 ri = NULL; 11564 attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 11565 } 11566 11567 count = bp->b_bcount - bp->b_resid; 11568 11569 /* Command reads or writes data */ 11570 if (attrib->transfers_data != TRAN_NONE) { 11571 if (count == 0) { 11572 if (attrib->transfers_data == TRAN_WRTE) { 11573 ASSERT(un->un_pos.eof == ST_EOM); 11574 nblks = 0; 11575 nfiles = 0; 11576 } else { 11577 ASSERT(un->un_pos.eof == ST_EOF_PENDING); 11578 nblks = 0; 11579 nfiles = 1; 11580 } 11581 } else if (un->un_bsize == 0) { 11582 /* 11583 * If variable block mode. 11584 * Fixed bit in CBD should be zero. 11585 */ 11586 ASSERT((pkt->pkt_cdbp[1] & 1) == 0); 11587 nblks = 1; 11588 un->un_kbytes_xferred += (count / ONE_K); 11589 nfiles = 0; 11590 } else { 11591 /* 11592 * If fixed block mode. 11593 * Fixed bit in CBD should be one. 11594 */ 11595 ASSERT((pkt->pkt_cdbp[1] & 1) == 1); 11596 nblks = (count / un->un_bsize); 11597 un->un_kbytes_xferred += (nblks * un->un_bsize) / ONE_K; 11598 nfiles = 0; 11599 } 11600 /* 11601 * So its possable to read some blocks and hit a filemark. 11602 * Example reading in fixed block mode where more then one 11603 * block at a time is requested. In this case because the 11604 * filemark is hit something less then the requesed number 11605 * of blocks is read. 11606 */ 11607 if (un->un_pos.eof == ST_EOF_PENDING && bp->b_resid) { 11608 nfiles = 1; 11609 } 11610 } else { 11611 nblks = 0; 11612 nfiles = count; 11613 } 11614 11615 /* 11616 * If some command failed after this one started and it seems 11617 * to have finshed without error count the position. 11618 */ 11619 if (un->un_persistence && un->un_persist_errors) { 11620 ASSERT(un->un_pos.pmode != invalid); 11621 } 11622 11623 if (attrib->chg_tape_direction == DIR_FORW) { 11624 un->un_pos.blkno += nblks; 11625 un->un_pos.lgclblkno += nblks; 11626 un->un_pos.lgclblkno += nfiles; 11627 } else if (attrib->chg_tape_direction == DIR_REVC) { 11628 un->un_pos.blkno -= nblks; 11629 un->un_pos.lgclblkno -= nblks; 11630 un->un_pos.lgclblkno -= nfiles; 11631 } else { 11632 ASSERT(0); 11633 } 11634 11635 /* recovery disabled */ 11636 if (ri == NULL) { 11637 un->un_running.pmode = invalid; 11638 return; 11639 } 11640 11641 /* 11642 * If we didn't just read a filemark. 11643 */ 11644 if (un->un_pos.eof != ST_EOF_PENDING) { 11645 ASSERT(nblks != 0 && nfiles == 0); 11646 /* 11647 * If Previously calulated expected position does not match 11648 * debug the expected position. 11649 */ 11650 if ((ri->pos.pmode != invalid) && nblks && 11651 ((un->un_pos.blkno != ri->pos.blkno) || 11652 (un->un_pos.lgclblkno != ri->pos.lgclblkno))) { 11653 #ifdef STDEBUG 11654 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 11655 "Expected", &ri->pos); 11656 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 11657 "But Got", &un->un_pos); 11658 #endif 11659 un->un_running.pmode = invalid; 11660 } 11661 } else { 11662 ASSERT(nfiles != 0); 11663 if (un->un_running.pmode != invalid) { 11664 /* 11665 * blkno and lgclblkno already counted in 11666 * st_add_recovery_info_to_pkt(). Since a block was not 11667 * read and a filemark was. 11668 */ 11669 if (attrib->chg_tape_direction == DIR_FORW) { 11670 un->un_running.fileno++; 11671 un->un_running.blkno = 0; 11672 } else if (attrib->chg_tape_direction == DIR_REVC) { 11673 un->un_running.fileno--; 11674 un->un_running.blkno = LASTBLK; 11675 } 11676 } 11677 } 11678 } 11679 11680 static void 11681 st_set_state(struct scsi_tape *un, struct buf *bp) 11682 { 11683 struct scsi_pkt *sp = BP_PKT(bp); 11684 struct uscsi_cmd *ucmd; 11685 11686 ST_FUNC(ST_DEVINFO, st_set_state); 11687 11688 ASSERT(mutex_owned(ST_MUTEX)); 11689 ASSERT(bp != un->un_recov_buf); 11690 11691 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 11692 "st_set_state(): eof=%x fmneeded=%x pkt_resid=0x%lx (%ld)\n", 11693 un->un_pos.eof, un->un_fmneeded, sp->pkt_resid, sp->pkt_resid); 11694 11695 if (bp != un->un_sbufp) { 11696 #ifdef STDEBUG 11697 if (DEBUGGING && sp->pkt_resid) { 11698 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11699 "pkt_resid %ld bcount %ld\n", 11700 sp->pkt_resid, bp->b_bcount); 11701 } 11702 #endif 11703 bp->b_resid = sp->pkt_resid; 11704 if (geterror(bp) != EIO) { 11705 st_calc_bnum(un, bp, sp); 11706 } 11707 if (bp->b_flags & B_READ) { 11708 un->un_lastop = ST_OP_READ; 11709 un->un_fmneeded = 0; 11710 } else { 11711 un->un_lastop = ST_OP_WRITE; 11712 if (un->un_dp->options & ST_REEL) { 11713 un->un_fmneeded = 2; 11714 } else { 11715 un->un_fmneeded = 1; 11716 } 11717 } 11718 /* 11719 * all is honky dory at this point, so let's 11720 * readjust the throttle, to increase speed, if we 11721 * have not throttled down. 11722 */ 11723 if (un->un_throttle) { 11724 un->un_throttle = un->un_max_throttle; 11725 } 11726 } else { 11727 optype new_lastop = ST_OP_NIL; 11728 uchar_t cmd = (uchar_t)(intptr_t)bp->b_forw; 11729 11730 switch (cmd) { 11731 case SCMD_WRITE: 11732 case SCMD_WRITE_G4: 11733 bp->b_resid = sp->pkt_resid; 11734 new_lastop = ST_OP_WRITE; 11735 if (geterror(bp) == EIO) { 11736 break; 11737 } 11738 st_calc_bnum(un, bp, sp); 11739 if (un->un_dp->options & ST_REEL) { 11740 un->un_fmneeded = 2; 11741 } else { 11742 un->un_fmneeded = 1; 11743 } 11744 break; 11745 case SCMD_READ: 11746 case SCMD_READ_G4: 11747 bp->b_resid = sp->pkt_resid; 11748 new_lastop = ST_OP_READ; 11749 un->un_lastop = ST_OP_READ; 11750 if (geterror(bp) == EIO) { 11751 break; 11752 } 11753 st_calc_bnum(un, bp, sp); 11754 un->un_fmneeded = 0; 11755 break; 11756 case SCMD_WRITE_FILE_MARK_G4: 11757 case SCMD_WRITE_FILE_MARK: 11758 { 11759 int fmdone; 11760 11761 if (un->un_pos.eof != ST_EOM) { 11762 un->un_pos.eof = ST_NO_EOF; 11763 } 11764 fmdone = (bp->b_bcount - bp->b_resid); 11765 if (fmdone > 0) { 11766 un->un_lastop = new_lastop = ST_OP_WEOF; 11767 un->un_pos.lgclblkno += fmdone; 11768 un->un_pos.fileno += fmdone; 11769 un->un_pos.blkno = 0; 11770 } else { 11771 new_lastop = ST_OP_CTL; 11772 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 11773 "Flushed buffer\n"); 11774 } 11775 if (fmdone > un->un_fmneeded) { 11776 un->un_fmneeded = 0; 11777 } else { 11778 un->un_fmneeded -= fmdone; 11779 } 11780 break; 11781 } 11782 case SCMD_REWIND: 11783 un->un_pos.eof = ST_NO_EOF; 11784 un->un_pos.fileno = 0; 11785 un->un_pos.blkno = 0; 11786 un->un_pos.lgclblkno = 0; 11787 if (un->un_pos.pmode != legacy) 11788 un->un_pos.pmode = legacy; 11789 new_lastop = ST_OP_CTL; 11790 un->un_restore_pos = 0; 11791 break; 11792 11793 case SCMD_SPACE: 11794 case SCMD_SPACE_G4: 11795 { 11796 int64_t count; 11797 int64_t resid; 11798 int64_t done; 11799 cmd_attribute const *attrib; 11800 recov_info *ri = sp->pkt_private; 11801 11802 if (ri->privatelen == sizeof (recov_info)) { 11803 attrib = ri->cmd_attrib; 11804 } else { 11805 attrib = 11806 st_lookup_cmd_attribute(sp->pkt_cdbp[0]); 11807 } 11808 11809 resid = (int64_t)SPACE_CNT(bp->b_resid); 11810 count = (int64_t)attrib->get_cnt(sp->pkt_cdbp); 11811 11812 if (count >= 0) { 11813 done = (count - resid); 11814 } else { 11815 done = ((-count) - resid); 11816 } 11817 if (done > 0) { 11818 un->un_lastop = new_lastop = ST_OP_CTL; 11819 } else { 11820 new_lastop = ST_OP_CTL; 11821 } 11822 11823 ST_SPAC(ST_DEVINFO, st_label, CE_WARN, 11824 "space cmd: cdb[1] = %s\n" 11825 "space data: = 0x%lx\n" 11826 "space count: = %"PRId64"\n" 11827 "space resid: = %"PRId64"\n" 11828 "spaces done: = %"PRId64"\n" 11829 "fileno before = %d\n" 11830 "blkno before = %d\n", 11831 space_strs[sp->pkt_cdbp[1] & 7], 11832 bp->b_bcount, 11833 count, resid, done, 11834 un->un_pos.fileno, un->un_pos.blkno); 11835 11836 switch (sp->pkt_cdbp[1]) { 11837 case SPACE_TYPE(SP_FLM): 11838 /* Space file forward */ 11839 if (count >= 0) { 11840 if (un->un_pos.eof <= ST_EOF) { 11841 un->un_pos.eof = ST_NO_EOF; 11842 } 11843 un->un_pos.fileno += done; 11844 un->un_pos.blkno = 0; 11845 break; 11846 } 11847 /* Space file backward */ 11848 if (done > un->un_pos.fileno) { 11849 un->un_pos.fileno = 0; 11850 un->un_pos.blkno = 0; 11851 } else { 11852 un->un_pos.fileno -= done; 11853 un->un_pos.blkno = LASTBLK; 11854 un->un_running.pmode = invalid; 11855 } 11856 break; 11857 case SPACE_TYPE(SP_BLK): 11858 /* Space block forward */ 11859 if (count >= 0) { 11860 un->un_pos.blkno += done; 11861 break; 11862 } 11863 /* Space block backward */ 11864 if (un->un_pos.eof >= ST_EOF_PENDING) { 11865 /* 11866 * we stepped back into 11867 * a previous file; we are not 11868 * making an effort to pretend that 11869 * we are still in the current file 11870 * ie. logical == physical position 11871 * and leave it to st_ioctl to correct 11872 */ 11873 if (done > un->un_pos.blkno) { 11874 un->un_pos.blkno = 0; 11875 } else { 11876 un->un_pos.fileno--; 11877 un->un_pos.blkno = LASTBLK; 11878 un->un_running.pmode = invalid; 11879 } 11880 } else { 11881 un->un_pos.blkno -= done; 11882 } 11883 break; 11884 case SPACE_TYPE(SP_SQFLM): 11885 un->un_pos.pmode = logical; 11886 un->un_pos.blkno = 0; 11887 un->un_lastop = new_lastop = ST_OP_CTL; 11888 break; 11889 case SPACE_TYPE(SP_EOD): 11890 un->un_pos.pmode = logical; 11891 un->un_pos.eof = ST_EOM; 11892 un->un_status = KEY_BLANK_CHECK; 11893 break; 11894 default: 11895 un->un_pos.pmode = invalid; 11896 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 11897 "Unsupported space cmd: %s\n", 11898 space_strs[sp->pkt_cdbp[1] & 7]); 11899 11900 un->un_lastop = new_lastop = ST_OP_CTL; 11901 } 11902 11903 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11904 "after_space rs %"PRId64" fil %d blk %d\n", 11905 resid, un->un_pos.fileno, un->un_pos.blkno); 11906 11907 break; 11908 } 11909 case SCMD_LOAD: 11910 if ((bp->b_bcount & (LD_LOAD | LD_EOT)) == LD_LOAD) { 11911 un->un_pos.fileno = 0; 11912 if (un->un_pos.pmode != legacy) 11913 un->un_pos.pmode = legacy; 11914 } else { 11915 un->un_state = ST_STATE_OFFLINE; 11916 un->un_pos.pmode = invalid; 11917 11918 } 11919 /* 11920 * If we are loading or unloading we expect the media id 11921 * to change. Lets make it unknown. 11922 */ 11923 if (un->un_media_id != bogusID && un->un_media_id_len) { 11924 kmem_free(un->un_media_id, un->un_media_id_len); 11925 un->un_media_id = NULL; 11926 un->un_media_id_len = 0; 11927 } 11928 un->un_density_known = 0; 11929 un->un_pos.eof = ST_NO_EOF; 11930 un->un_pos.blkno = 0; 11931 un->un_lastop = new_lastop = ST_OP_CTL; 11932 break; 11933 case SCMD_ERASE: 11934 un->un_pos.eof = ST_NO_EOF; 11935 un->un_pos.blkno = 0; 11936 un->un_pos.fileno = 0; 11937 un->un_pos.lgclblkno = 0; 11938 if (un->un_pos.pmode != legacy) 11939 un->un_pos.pmode = legacy; 11940 new_lastop = ST_OP_CTL; 11941 break; 11942 case SCMD_RESERVE: 11943 un->un_rsvd_status |= ST_RESERVE; 11944 un->un_rsvd_status &= 11945 ~(ST_RELEASE | ST_LOST_RESERVE | 11946 ST_RESERVATION_CONFLICT | ST_INITIATED_RESET); 11947 new_lastop = ST_OP_CTL; 11948 break; 11949 case SCMD_RELEASE: 11950 un->un_rsvd_status |= ST_RELEASE; 11951 un->un_rsvd_status &= 11952 ~(ST_RESERVE | ST_LOST_RESERVE | 11953 ST_RESERVATION_CONFLICT | ST_INITIATED_RESET); 11954 new_lastop = ST_OP_CTL; 11955 break; 11956 case SCMD_PERSISTENT_RESERVE_IN: 11957 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11958 "PGR_IN command\n"); 11959 new_lastop = ST_OP_CTL; 11960 break; 11961 case SCMD_PERSISTENT_RESERVE_OUT: 11962 switch (sp->pkt_cdbp[1] & ST_SA_MASK) { 11963 case ST_SA_SCSI3_RESERVE: 11964 case ST_SA_SCSI3_PREEMPT: 11965 case ST_SA_SCSI3_PREEMPTANDABORT: 11966 un->un_rsvd_status |= 11967 (ST_APPLICATION_RESERVATIONS | ST_RESERVE); 11968 un->un_rsvd_status &= ~(ST_RELEASE | 11969 ST_LOST_RESERVE | ST_RESERVATION_CONFLICT | 11970 ST_INITIATED_RESET); 11971 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11972 "PGR Reserve and set: entering" 11973 " ST_APPLICATION_RESERVATIONS mode"); 11974 break; 11975 case ST_SA_SCSI3_REGISTER: 11976 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11977 "PGR Reserve register key"); 11978 un->un_rsvd_status |= ST_INIT_RESERVE; 11979 break; 11980 case ST_SA_SCSI3_CLEAR: 11981 un->un_rsvd_status &= ~ST_INIT_RESERVE; 11982 /* FALLTHROUGH */ 11983 case ST_SA_SCSI3_RELEASE: 11984 un->un_rsvd_status &= 11985 ~(ST_APPLICATION_RESERVATIONS | ST_RESERVE | 11986 ST_LOST_RESERVE | ST_RESERVATION_CONFLICT | 11987 ST_INITIATED_RESET); 11988 un->un_rsvd_status |= ST_RELEASE; 11989 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11990 "PGR Release and reset: exiting" 11991 " ST_APPLICATION_RESERVATIONS mode"); 11992 break; 11993 } 11994 new_lastop = ST_OP_CTL; 11995 break; 11996 case SCMD_TEST_UNIT_READY: 11997 case SCMD_READ_BLKLIM: 11998 case SCMD_REQUEST_SENSE: 11999 case SCMD_INQUIRY: 12000 case SCMD_RECOVER_BUF: 12001 case SCMD_MODE_SELECT: 12002 case SCMD_MODE_SENSE: 12003 case SCMD_DOORLOCK: 12004 case SCMD_READ_BUFFER: 12005 case SCMD_REPORT_DENSITIES: 12006 case SCMD_LOG_SELECT_G1: 12007 case SCMD_LOG_SENSE_G1: 12008 case SCMD_REPORT_LUNS: 12009 case SCMD_READ_ATTRIBUTE: 12010 case SCMD_WRITE_ATTRIBUTE: 12011 case SCMD_SVC_ACTION_IN_G5: 12012 case SCMD_SECURITY_PROTO_IN: 12013 case SCMD_SECURITY_PROTO_OUT: 12014 new_lastop = ST_OP_CTL; 12015 break; 12016 case SCMD_READ_POSITION: 12017 new_lastop = ST_OP_CTL; 12018 /* 12019 * Only if the buf used was un_sbufp. 12020 * Among other things the prevents read positions used 12021 * as part of error recovery from messing up our 12022 * current position as they will use un_recov_buf. 12023 */ 12024 if (USCSI_CMD(bp)) { 12025 (void) st_get_read_pos(un, bp); 12026 } 12027 break; 12028 case SCMD_LOCATE: 12029 case SCMD_LOCATE_G4: 12030 /* Locate makes position mode no longer legacy */ 12031 un->un_lastop = new_lastop = ST_OP_CTL; 12032 break; 12033 case SCMD_MAINTENANCE_IN: 12034 switch (sp->pkt_cdbp[1]) { 12035 case SSVC_ACTION_GET_SUPPORTED_OPERATIONS: 12036 case SSVC_ACTION_SET_TARGET_PORT_GROUPS: 12037 new_lastop = ST_OP_CTL; 12038 break; 12039 } 12040 if (new_lastop != ST_OP_NIL) { 12041 break; 12042 } 12043 default: 12044 /* 12045 * Unknown command, If was USCSI and USCSI_SILENT 12046 * flag was not set, set position to unknown. 12047 */ 12048 if ((((ucmd = BP_UCMD(bp)) != NULL) && 12049 (ucmd->uscsi_flags & USCSI_SILENT) == 0)) { 12050 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 12051 "unknown cmd 0x%X caused loss of state\n", 12052 cmd); 12053 } else { 12054 /* 12055 * keep the old agreement to allow unknown 12056 * commands with the USCSI_SILENT set. 12057 * This prevents ASSERT below. 12058 */ 12059 new_lastop = ST_OP_CTL; 12060 break; 12061 } 12062 /* FALLTHROUGH */ 12063 case SCMD_WRITE_BUFFER: /* Writes new firmware to device */ 12064 un->un_pos.pmode = invalid; 12065 un->un_lastop = new_lastop = ST_OP_CTL; 12066 break; 12067 } 12068 12069 /* new_lastop should have been changed */ 12070 ASSERT(new_lastop != ST_OP_NIL); 12071 12072 /* If un_lastop should copy new_lastop */ 12073 if (((un->un_lastop == ST_OP_WRITE) || 12074 (un->un_lastop == ST_OP_WEOF)) && 12075 new_lastop != ST_OP_CTL) { 12076 un->un_lastop = new_lastop; 12077 } 12078 } 12079 12080 /* 12081 * In the st driver we have a logical and physical file position. 12082 * Under BSD behavior, when you get a zero read, the logical position 12083 * is before the filemark but after the last record of the file. 12084 * The physical position is after the filemark. MTIOCGET should always 12085 * return the logical file position. 12086 * 12087 * The next read gives a silent skip to the next file. 12088 * Under SVR4, the logical file position remains before the filemark 12089 * until the file is closed or a space operation is performed. 12090 * Hence set err_resid and err_file before changing fileno if case 12091 * BSD Behaviour. 12092 */ 12093 un->un_err_resid = bp->b_resid; 12094 COPY_POS(&un->un_err_pos, &un->un_pos); 12095 12096 12097 /* 12098 * If we've seen a filemark via the last read operation 12099 * advance the file counter, but mark things such that 12100 * the next read operation gets a zero count. We have 12101 * to put this here to handle the case of sitting right 12102 * at the end of a tape file having seen the file mark, 12103 * but the tape is closed and then re-opened without 12104 * any further i/o. That is, the position information 12105 * must be updated before a close. 12106 */ 12107 12108 if (un->un_lastop == ST_OP_READ && un->un_pos.eof == ST_EOF_PENDING) { 12109 /* 12110 * If we're a 1/2" tape, and we get a filemark 12111 * right on block 0, *AND* we were not in the 12112 * first file on the tape, and we've hit logical EOM. 12113 * We'll mark the state so that later we do the 12114 * right thing (in st_close(), st_strategy() or 12115 * st_ioctl()). 12116 * 12117 */ 12118 if ((un->un_dp->options & ST_REEL) && 12119 !(un->un_dp->options & ST_READ_IGNORE_EOFS) && 12120 un->un_pos.blkno == 0 && un->un_pos.fileno > 0) { 12121 un->un_pos.eof = ST_EOT_PENDING; 12122 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12123 "eot pending\n"); 12124 un->un_pos.fileno++; 12125 un->un_pos.blkno = 0; 12126 } else if (BP_UCMD(bp)) { 12127 /* 12128 * Uscsi reads have no concept of Berkley ver System IV. 12129 * Counts here must match raw device. 12130 * A non-full resid implies fix block mode where an 12131 * attempt to read X blocks resulted in less then X. 12132 */ 12133 if (bp->b_resid != bp->b_bcount) { 12134 un->un_pos.eof = ST_EOF; 12135 } else { 12136 /* Read over a file mark */ 12137 un->un_pos.fileno++; 12138 /* logical block is counted up elsewhere */ 12139 /* we're before the first block in next file */ 12140 un->un_pos.blkno = 0; 12141 /* EOF is no longer pending */ 12142 un->un_pos.eof = ST_NO_EOF; 12143 } 12144 } else if (BSD_BEHAVIOR) { 12145 /* 12146 * If the read of the filemark was a side effect 12147 * of reading some blocks (i.e., data was actually 12148 * read), then the EOF mark is pending and the 12149 * bump into the next file awaits the next read 12150 * operation (which will return a zero count), or 12151 * a close or a space operation, else the bump 12152 * into the next file occurs now. 12153 */ 12154 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12155 "resid=%lx, bcount=%lx\n", 12156 bp->b_resid, bp->b_bcount); 12157 12158 if (bp->b_resid != bp->b_bcount) { 12159 un->un_pos.eof = ST_EOF; 12160 } else { 12161 un->un_silent_skip = 1; 12162 un->un_pos.eof = ST_NO_EOF; 12163 un->un_pos.fileno++; 12164 un->un_pos.lgclblkno++; 12165 un->un_save_blkno = un->un_pos.blkno; 12166 un->un_pos.blkno = 0; 12167 } 12168 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12169 "eof of file %d, eof=%d\n", 12170 un->un_pos.fileno, un->un_pos.eof); 12171 } else if (SVR4_BEHAVIOR) { 12172 /* 12173 * If the read of the filemark was a side effect 12174 * of reading some blocks (i.e., data was actually 12175 * read), then the next read should return 0 12176 */ 12177 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12178 "resid=%lx, bcount=%lx\n", 12179 bp->b_resid, bp->b_bcount); 12180 if (bp->b_resid == bp->b_bcount) { 12181 un->un_pos.eof = ST_EOF; 12182 } 12183 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 12184 "eof of file=%d, eof=%d\n", 12185 un->un_pos.fileno, un->un_pos.eof); 12186 } 12187 } 12188 } 12189 12190 /* 12191 * set the correct un_errno, to take corner cases into consideration 12192 */ 12193 static void 12194 st_set_pe_errno(struct scsi_tape *un) 12195 { 12196 ST_FUNC(ST_DEVINFO, st_set_pe_errno); 12197 12198 ASSERT(mutex_owned(ST_MUTEX)); 12199 12200 /* if errno is already set, don't reset it */ 12201 if (un->un_errno) 12202 return; 12203 12204 /* here un_errno == 0 */ 12205 /* 12206 * if the last transfer before flushing all the 12207 * waiting I/O's, was 0 (resid = count), then we 12208 * want to give the user an error on all the rest, 12209 * so here. If there was a transfer, we set the 12210 * resid and counts to 0, and let it drop through, 12211 * giving a zero return. the next I/O will then 12212 * give an error. 12213 */ 12214 if (un->un_last_resid == un->un_last_count) { 12215 switch (un->un_pos.eof) { 12216 case ST_EOM: 12217 un->un_errno = ENOMEM; 12218 break; 12219 case ST_EOT: 12220 case ST_EOF: 12221 un->un_errno = EIO; 12222 break; 12223 } 12224 } else { 12225 /* 12226 * we know they did not have a zero, so make 12227 * sure they get one 12228 */ 12229 un->un_last_resid = un->un_last_count = 0; 12230 } 12231 } 12232 12233 12234 /* 12235 * send in a marker pkt to terminate flushing of commands by BBA (via 12236 * flush-on-errors) property. The HBA will always return TRAN_ACCEPT 12237 */ 12238 static void 12239 st_hba_unflush(struct scsi_tape *un) 12240 { 12241 ST_FUNC(ST_DEVINFO, st_hba_unflush); 12242 12243 ASSERT(mutex_owned(ST_MUTEX)); 12244 12245 if (!un->un_flush_on_errors) 12246 return; 12247 12248 #ifdef FLUSH_ON_ERRORS 12249 12250 if (!un->un_mkr_pkt) { 12251 un->un_mkr_pkt = scsi_init_pkt(ROUTE, NULL, (struct buf *)NULL, 12252 NULL, 0, 0, 0, SLEEP_FUNC, NULL); 12253 12254 /* we slept, so it must be there */ 12255 pkt->pkt_flags |= FLAG_FLUSH_MARKER; 12256 } 12257 12258 st_transport(un, un->un_mkr_pkt); 12259 #endif 12260 } 12261 12262 static char * 12263 st_print_scsi_cmd(char cmd) 12264 { 12265 char tmp[64]; 12266 char *cpnt; 12267 12268 cpnt = scsi_cmd_name(cmd, scsi_cmds, tmp); 12269 /* tmp goes out of scope on return and caller sees garbage */ 12270 if (cpnt == tmp) { 12271 cpnt = "Unknown Command"; 12272 } 12273 return (cpnt); 12274 } 12275 12276 static void 12277 st_print_cdb(dev_info_t *dip, char *label, uint_t level, 12278 char *title, char *cdb) 12279 { 12280 int len = scsi_cdb_size[CDB_GROUPID(cdb[0])]; 12281 char buf[256]; 12282 struct scsi_tape *un; 12283 int instance = ddi_get_instance(dip); 12284 12285 un = ddi_get_soft_state(st_state, instance); 12286 12287 ST_FUNC(dip, st_print_cdb); 12288 12289 /* force one line output so repeated commands are printed once */ 12290 if ((st_debug & 0x180) == 0x100) { 12291 scsi_log(dip, label, level, "node %s cmd %s\n", 12292 st_dev_name(un->un_dev), st_print_scsi_cmd(*cdb)); 12293 return; 12294 } 12295 12296 /* force one line output so repeated CDB's are printed once */ 12297 if ((st_debug & 0x180) == 0x80) { 12298 st_clean_print(dip, label, level, NULL, cdb, len); 12299 } else { 12300 (void) sprintf(buf, "%s for cmd(%s)", title, 12301 st_print_scsi_cmd(*cdb)); 12302 st_clean_print(dip, label, level, buf, cdb, len); 12303 } 12304 } 12305 12306 static void 12307 st_clean_print(dev_info_t *dev, char *label, uint_t level, 12308 char *title, char *data, int len) 12309 { 12310 int i; 12311 int c; 12312 char *format; 12313 char buf[256]; 12314 uchar_t byte; 12315 12316 ST_FUNC(dev, st_clean_print); 12317 12318 12319 if (title) { 12320 (void) sprintf(buf, "%s:\n", title); 12321 scsi_log(dev, label, level, "%s", buf); 12322 level = CE_CONT; 12323 } 12324 12325 for (i = 0; i < len; ) { 12326 buf[0] = 0; 12327 for (c = 0; c < 8 && i < len; c++, i++) { 12328 byte = (uchar_t)data[i]; 12329 if (byte < 0x10) 12330 format = "0x0%x "; 12331 else 12332 format = "0x%x "; 12333 (void) sprintf(&buf[(int)strlen(buf)], format, byte); 12334 } 12335 (void) sprintf(&buf[(int)strlen(buf)], "\n"); 12336 12337 scsi_log(dev, label, level, "%s\n", buf); 12338 level = CE_CONT; 12339 } 12340 } 12341 12342 /* 12343 * Conditionally enabled debugging 12344 */ 12345 #ifdef STDEBUG 12346 static void 12347 st_debug_cmds(struct scsi_tape *un, int com, int count, int wait) 12348 { 12349 char tmpbuf[64]; 12350 12351 ST_FUNC(ST_DEVINFO, st_debug_cmds); 12352 12353 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12354 "cmd=%s count=0x%x (%d) %ssync\n", 12355 scsi_cmd_name(com, scsi_cmds, tmpbuf), 12356 count, count, 12357 wait == ASYNC_CMD ? "a" : ""); 12358 } 12359 #endif /* STDEBUG */ 12360 12361 /* 12362 * Returns pointer to name of minor node name of device 'dev'. 12363 */ 12364 static char * 12365 st_dev_name(dev_t dev) 12366 { 12367 struct scsi_tape *un; 12368 const char density[] = { 'l', 'm', 'h', 'c' }; 12369 static char name[32]; 12370 minor_t minor; 12371 int instance; 12372 int nprt = 0; 12373 12374 minor = getminor(dev); 12375 instance = ((minor & 0xff80) >> 5) | (minor & 3); 12376 un = ddi_get_soft_state(st_state, instance); 12377 if (un) { 12378 ST_FUNC(ST_DEVINFO, st_dev_name); 12379 } 12380 12381 name[nprt] = density[(minor & MT_DENSITY_MASK) >> 3]; 12382 12383 if (minor & MT_BSD) { 12384 name[++nprt] = 'b'; 12385 } 12386 12387 if (minor & MT_NOREWIND) { 12388 name[++nprt] = 'n'; 12389 } 12390 12391 /* NULL terminator */ 12392 name[++nprt] = 0; 12393 12394 return (name); 12395 } 12396 12397 /* 12398 * Soft error reporting, so far unique to each drive 12399 * 12400 * Currently supported: exabyte and DAT soft error reporting 12401 */ 12402 static int 12403 st_report_exabyte_soft_errors(dev_t dev, int flag) 12404 { 12405 uchar_t *sensep; 12406 int amt; 12407 int rval = 0; 12408 char cdb[CDB_GROUP0], *c = cdb; 12409 struct uscsi_cmd *com; 12410 12411 GET_SOFT_STATE(dev); 12412 12413 ST_FUNC(ST_DEVINFO, st_report_exabyte_soft_errors); 12414 12415 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12416 "st_report_exabyte_soft_errors(dev = 0x%lx, flag = %d)\n", 12417 dev, flag); 12418 12419 ASSERT(mutex_owned(ST_MUTEX)); 12420 12421 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 12422 sensep = kmem_zalloc(TAPE_SENSE_LENGTH, KM_SLEEP); 12423 12424 *c++ = SCMD_REQUEST_SENSE; 12425 *c++ = 0; 12426 *c++ = 0; 12427 *c++ = 0; 12428 *c++ = TAPE_SENSE_LENGTH; 12429 /* 12430 * set CLRCNT (byte 5, bit 7 which clears the error counts) 12431 */ 12432 *c = (char)0x80; 12433 12434 com->uscsi_cdb = cdb; 12435 com->uscsi_cdblen = CDB_GROUP0; 12436 com->uscsi_bufaddr = (caddr_t)sensep; 12437 com->uscsi_buflen = TAPE_SENSE_LENGTH; 12438 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 12439 com->uscsi_timeout = un->un_dp->non_motion_timeout; 12440 12441 rval = st_uscsi_cmd(un, com, FKIOCTL); 12442 if (rval || com->uscsi_status) { 12443 goto done; 12444 } 12445 12446 /* 12447 * was there enough data? 12448 */ 12449 amt = (int)TAPE_SENSE_LENGTH - com->uscsi_resid; 12450 12451 if ((amt >= 19) && un->un_kbytes_xferred) { 12452 uint_t count, error_rate; 12453 uint_t rate; 12454 12455 if (sensep[21] & CLN) { 12456 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12457 "Periodic head cleaning required"); 12458 } 12459 if (un->un_kbytes_xferred < (EXABYTE_MIN_TRANSFER/ONE_K)) { 12460 goto done; 12461 } 12462 /* 12463 * check if soft error reporting needs to be done. 12464 */ 12465 count = sensep[16] << 16 | sensep[17] << 8 | sensep[18]; 12466 count &= 0xffffff; 12467 error_rate = (count * 100)/un->un_kbytes_xferred; 12468 12469 #ifdef STDEBUG 12470 if (st_soft_error_report_debug) { 12471 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 12472 "Exabyte Soft Error Report:\n"); 12473 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12474 "read/write error counter: %d\n", count); 12475 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12476 "number of bytes transferred: %dK\n", 12477 un->un_kbytes_xferred); 12478 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12479 "error_rate: %d%%\n", error_rate); 12480 12481 if (amt >= 22) { 12482 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12483 "unit sense: 0x%b 0x%b 0x%b\n", 12484 sensep[19], SENSE_19_BITS, 12485 sensep[20], SENSE_20_BITS, 12486 sensep[21], SENSE_21_BITS); 12487 } 12488 if (amt >= 27) { 12489 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12490 "tracking retry counter: %d\n", 12491 sensep[26]); 12492 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12493 "read/write retry counter: %d\n", 12494 sensep[27]); 12495 } 12496 } 12497 #endif 12498 12499 if (flag & FWRITE) { 12500 rate = EXABYTE_WRITE_ERROR_THRESHOLD; 12501 } else { 12502 rate = EXABYTE_READ_ERROR_THRESHOLD; 12503 } 12504 if (error_rate >= rate) { 12505 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12506 "Soft error rate (%d%%) during %s was too high", 12507 error_rate, 12508 ((flag & FWRITE) ? wrg_str : rdg_str)); 12509 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12510 "Please, replace tape cartridge\n"); 12511 } 12512 } 12513 12514 done: 12515 kmem_free(com, sizeof (*com)); 12516 kmem_free(sensep, TAPE_SENSE_LENGTH); 12517 12518 if (rval != 0) { 12519 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12520 "exabyte soft error reporting failed\n"); 12521 } 12522 return (rval); 12523 } 12524 12525 /* 12526 * this is very specific to Archive 4mm dat 12527 */ 12528 #define ONE_GIG (ONE_K * ONE_K * ONE_K) 12529 12530 static int 12531 st_report_dat_soft_errors(dev_t dev, int flag) 12532 { 12533 uchar_t *sensep; 12534 int amt, i; 12535 int rval = 0; 12536 char cdb[CDB_GROUP1], *c = cdb; 12537 struct uscsi_cmd *com; 12538 struct scsi_arq_status status; 12539 12540 GET_SOFT_STATE(dev); 12541 12542 ST_FUNC(ST_DEVINFO, st_report_dat_soft_errors); 12543 12544 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12545 "st_report_dat_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag); 12546 12547 ASSERT(mutex_owned(ST_MUTEX)); 12548 12549 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 12550 sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP); 12551 12552 *c++ = SCMD_LOG_SENSE_G1; 12553 *c++ = 0; 12554 *c++ = (flag & FWRITE) ? 0x42 : 0x43; 12555 *c++ = 0; 12556 *c++ = 0; 12557 *c++ = 0; 12558 *c++ = 2; 12559 *c++ = 0; 12560 *c++ = (char)LOG_SENSE_LENGTH; 12561 *c = 0; 12562 com->uscsi_cdb = cdb; 12563 com->uscsi_cdblen = CDB_GROUP1; 12564 com->uscsi_bufaddr = (caddr_t)sensep; 12565 com->uscsi_buflen = LOG_SENSE_LENGTH; 12566 com->uscsi_rqlen = sizeof (status); 12567 com->uscsi_rqbuf = (caddr_t)&status; 12568 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 12569 com->uscsi_timeout = un->un_dp->non_motion_timeout; 12570 rval = st_uscsi_cmd(un, com, FKIOCTL); 12571 if (rval) { 12572 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12573 "DAT soft error reporting failed\n"); 12574 } 12575 if (rval || com->uscsi_status) { 12576 goto done; 12577 } 12578 12579 /* 12580 * was there enough data? 12581 */ 12582 amt = (int)LOG_SENSE_LENGTH - com->uscsi_resid; 12583 12584 if ((amt >= MIN_LOG_SENSE_LENGTH) && un->un_kbytes_xferred) { 12585 int total, retries, param_code; 12586 12587 total = -1; 12588 retries = -1; 12589 amt = sensep[3] + 4; 12590 12591 12592 #ifdef STDEBUG 12593 if (st_soft_error_report_debug) { 12594 (void) printf("logsense:"); 12595 for (i = 0; i < MIN_LOG_SENSE_LENGTH; i++) { 12596 if (i % 16 == 0) { 12597 (void) printf("\t\n"); 12598 } 12599 (void) printf(" %x", sensep[i]); 12600 } 12601 (void) printf("\n"); 12602 } 12603 #endif 12604 12605 /* 12606 * parse the param_codes 12607 */ 12608 if (sensep[0] == 2 || sensep[0] == 3) { 12609 for (i = 4; i < amt; i++) { 12610 param_code = (sensep[i++] << 8); 12611 param_code += sensep[i++]; 12612 i++; /* skip control byte */ 12613 if (param_code == 5) { 12614 if (sensep[i++] == 4) { 12615 total = (sensep[i++] << 24); 12616 total += (sensep[i++] << 16); 12617 total += (sensep[i++] << 8); 12618 total += sensep[i]; 12619 } 12620 } else if (param_code == 0x8007) { 12621 if (sensep[i++] == 2) { 12622 retries = sensep[i++] << 8; 12623 retries += sensep[i]; 12624 } 12625 } else { 12626 i += sensep[i]; 12627 } 12628 } 12629 } 12630 12631 /* 12632 * if the log sense returned valid numbers then determine 12633 * the read and write error thresholds based on the amount of 12634 * data transferred 12635 */ 12636 12637 if (total > 0 && retries > 0) { 12638 short normal_retries = 0; 12639 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 12640 "total xferred (%s) =%x, retries=%x\n", 12641 ((flag & FWRITE) ? wrg_str : rdg_str), 12642 total, retries); 12643 12644 if (flag & FWRITE) { 12645 if (total <= 12646 WRITE_SOFT_ERROR_WARNING_THRESHOLD) { 12647 normal_retries = 12648 DAT_SMALL_WRITE_ERROR_THRESHOLD; 12649 } else { 12650 normal_retries = 12651 DAT_LARGE_WRITE_ERROR_THRESHOLD; 12652 } 12653 } else { 12654 if (total <= 12655 READ_SOFT_ERROR_WARNING_THRESHOLD) { 12656 normal_retries = 12657 DAT_SMALL_READ_ERROR_THRESHOLD; 12658 } else { 12659 normal_retries = 12660 DAT_LARGE_READ_ERROR_THRESHOLD; 12661 } 12662 } 12663 12664 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 12665 "normal retries=%d\n", normal_retries); 12666 12667 if (retries >= normal_retries) { 12668 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12669 "Soft error rate (retries = %d) during " 12670 "%s was too high", retries, 12671 ((flag & FWRITE) ? wrg_str : rdg_str)); 12672 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12673 "Periodic head cleaning required " 12674 "and/or replace tape cartridge\n"); 12675 } 12676 12677 } else if (total == -1 || retries == -1) { 12678 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12679 "log sense parameter code does not make sense\n"); 12680 } 12681 } 12682 12683 /* 12684 * reset all values 12685 */ 12686 c = cdb; 12687 *c++ = SCMD_LOG_SELECT_G1; 12688 *c++ = 2; /* this resets all values */ 12689 *c++ = (char)0xc0; 12690 *c++ = 0; 12691 *c++ = 0; 12692 *c++ = 0; 12693 *c++ = 0; 12694 *c++ = 0; 12695 *c++ = 0; 12696 *c = 0; 12697 com->uscsi_bufaddr = NULL; 12698 com->uscsi_buflen = 0; 12699 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT; 12700 rval = st_uscsi_cmd(un, com, FKIOCTL); 12701 if (rval) { 12702 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12703 "DAT soft error reset failed\n"); 12704 } 12705 done: 12706 kmem_free(com, sizeof (*com)); 12707 kmem_free(sensep, LOG_SENSE_LENGTH); 12708 return (rval); 12709 } 12710 12711 static int 12712 st_report_soft_errors(dev_t dev, int flag) 12713 { 12714 GET_SOFT_STATE(dev); 12715 12716 ST_FUNC(ST_DEVINFO, st_report_soft_errors); 12717 12718 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12719 "st_report_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag); 12720 12721 ASSERT(mutex_owned(ST_MUTEX)); 12722 12723 switch (un->un_dp->type) { 12724 case ST_TYPE_EXB8500: 12725 case ST_TYPE_EXABYTE: 12726 return (st_report_exabyte_soft_errors(dev, flag)); 12727 /*NOTREACHED*/ 12728 case ST_TYPE_PYTHON: 12729 return (st_report_dat_soft_errors(dev, flag)); 12730 /*NOTREACHED*/ 12731 default: 12732 un->un_dp->options &= ~ST_SOFT_ERROR_REPORTING; 12733 return (-1); 12734 } 12735 } 12736 12737 /* 12738 * persistent error routines 12739 */ 12740 12741 /* 12742 * enable persistent errors, and set the throttle appropriately, checking 12743 * for flush-on-errors capability 12744 */ 12745 static void 12746 st_turn_pe_on(struct scsi_tape *un) 12747 { 12748 ST_FUNC(ST_DEVINFO, st_turn_pe_on); 12749 12750 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_on\n"); 12751 ASSERT(mutex_owned(ST_MUTEX)); 12752 12753 un->un_persistence = 1; 12754 12755 /* 12756 * only use flush-on-errors if auto-request-sense and untagged-qing are 12757 * enabled. This will simplify the error handling for request senses 12758 */ 12759 12760 if (un->un_arq_enabled && un->un_untagged_qing) { 12761 uchar_t f_o_e; 12762 12763 mutex_exit(ST_MUTEX); 12764 f_o_e = (scsi_ifsetcap(ROUTE, "flush-on-errors", 1, 1) == 1) ? 12765 1 : 0; 12766 mutex_enter(ST_MUTEX); 12767 12768 un->un_flush_on_errors = f_o_e; 12769 } else { 12770 un->un_flush_on_errors = 0; 12771 } 12772 12773 if (un->un_flush_on_errors) 12774 un->un_max_throttle = (uchar_t)st_max_throttle; 12775 else 12776 un->un_max_throttle = 1; 12777 12778 if (un->un_dp->options & ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) 12779 un->un_max_throttle = 1; 12780 12781 /* this will send a marker pkt */ 12782 st_clear_pe(un); 12783 } 12784 12785 /* 12786 * This turns persistent errors permanently off 12787 */ 12788 static void 12789 st_turn_pe_off(struct scsi_tape *un) 12790 { 12791 ST_FUNC(ST_DEVINFO, st_turn_pe_off); 12792 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_off\n"); 12793 ASSERT(mutex_owned(ST_MUTEX)); 12794 12795 /* turn it off for good */ 12796 un->un_persistence = 0; 12797 12798 /* this will send a marker pkt */ 12799 st_clear_pe(un); 12800 12801 /* turn off flush on error capability, if enabled */ 12802 if (un->un_flush_on_errors) { 12803 mutex_exit(ST_MUTEX); 12804 (void) scsi_ifsetcap(ROUTE, "flush-on-errors", 0, 1); 12805 mutex_enter(ST_MUTEX); 12806 } 12807 12808 12809 un->un_flush_on_errors = 0; 12810 } 12811 12812 /* 12813 * This clear persistent errors, allowing more commands through, and also 12814 * sending a marker packet. 12815 */ 12816 static void 12817 st_clear_pe(struct scsi_tape *un) 12818 { 12819 ST_FUNC(ST_DEVINFO, st_clear_pe); 12820 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_clear\n"); 12821 ASSERT(mutex_owned(ST_MUTEX)); 12822 12823 un->un_persist_errors = 0; 12824 un->un_throttle = un->un_last_throttle = 1; 12825 un->un_errno = 0; 12826 st_hba_unflush(un); 12827 } 12828 12829 /* 12830 * This will flag persistent errors, shutting everything down, if the 12831 * application had enabled persistent errors via MTIOCPERSISTENT 12832 */ 12833 static void 12834 st_set_pe_flag(struct scsi_tape *un) 12835 { 12836 ST_FUNC(ST_DEVINFO, st_set_pe_flag); 12837 ASSERT(mutex_owned(ST_MUTEX)); 12838 12839 if (un->un_persistence) { 12840 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_flag\n"); 12841 un->un_persist_errors = 1; 12842 un->un_throttle = un->un_last_throttle = 0; 12843 cv_broadcast(&un->un_sbuf_cv); 12844 } 12845 } 12846 12847 static int 12848 st_do_reserve(struct scsi_tape *un) 12849 { 12850 int rval; 12851 int was_lost = un->un_rsvd_status & ST_LOST_RESERVE; 12852 12853 ST_FUNC(ST_DEVINFO, st_do_reserve); 12854 12855 /* 12856 * Issue a Throw-Away reserve command to clear the 12857 * check condition. 12858 * If the current behaviour of reserve/release is to 12859 * hold reservation across opens , and if a Bus reset 12860 * has been issued between opens then this command 12861 * would set the ST_LOST_RESERVE flags in rsvd_status. 12862 * In this case return an EACCES so that user knows that 12863 * reservation has been lost in between opens. 12864 * If this error is not returned and we continue with 12865 * successful open , then user may think position of the 12866 * tape is still the same but inreality we would rewind the 12867 * tape and continue from BOT. 12868 */ 12869 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12870 if (rval) { 12871 if ((un->un_rsvd_status & ST_LOST_RESERVE_BETWEEN_OPENS) == 12872 ST_LOST_RESERVE_BETWEEN_OPENS) { 12873 un->un_rsvd_status &= ~(ST_LOST_RESERVE | ST_RESERVE); 12874 un->un_errno = EACCES; 12875 return (EACCES); 12876 } 12877 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12878 } 12879 if (rval == 0) { 12880 un->un_rsvd_status |= ST_INIT_RESERVE; 12881 } 12882 if (was_lost) { 12883 un->un_running.pmode = invalid; 12884 } 12885 12886 return (rval); 12887 } 12888 12889 static int 12890 st_check_cdb_for_need_to_reserve(struct scsi_tape *un, uchar_t *cdb) 12891 { 12892 int rval; 12893 cmd_attribute const *attrib; 12894 12895 ST_FUNC(ST_DEVINFO, st_check_cdb_for_need_to_reserve); 12896 12897 /* 12898 * If already reserved no need to do it again. 12899 * Also if Reserve and Release are disabled Just return. 12900 */ 12901 if ((un->un_rsvd_status & (ST_APPLICATION_RESERVATIONS)) || 12902 ((un->un_rsvd_status & (ST_RESERVE | ST_LOST_RESERVE)) == 12903 ST_RESERVE) || (un->un_dp->options & ST_NO_RESERVE_RELEASE)) { 12904 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12905 "st_check_cdb_for_need_to_reserve() reserve unneeded %s", 12906 st_print_scsi_cmd((uchar_t)cdb[0])); 12907 return (0); 12908 } 12909 12910 /* See if command is on the list */ 12911 attrib = st_lookup_cmd_attribute(cdb[0]); 12912 12913 if (attrib == NULL) { 12914 rval = 1; /* Not found, when in doubt reserve */ 12915 } else if ((attrib->requires_reserve) != 0) { 12916 rval = 1; 12917 } else if ((attrib->reserve_byte) != 0) { 12918 /* 12919 * cmd is on list. 12920 * if byte is zero always allowed. 12921 */ 12922 rval = 1; 12923 } else if (((cdb[attrib->reserve_byte]) & 12924 (attrib->reserve_mask)) != 0) { 12925 rval = 1; 12926 } else { 12927 rval = 0; 12928 } 12929 12930 if (rval) { 12931 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12932 "Command %s requires reservation", 12933 st_print_scsi_cmd(cdb[0])); 12934 12935 rval = st_do_reserve(un); 12936 } 12937 12938 return (rval); 12939 } 12940 12941 static int 12942 st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd, int cnt) 12943 { 12944 int rval; 12945 cmd_attribute const *attrib; 12946 12947 ST_FUNC(ST_DEVINFO, st_check_cmd_for_need_to_reserve); 12948 12949 /* 12950 * Do not reserve when already reserved, when not supported or when 12951 * auto-rewinding on device closure. 12952 */ 12953 if ((un->un_rsvd_status & (ST_APPLICATION_RESERVATIONS)) || 12954 ((un->un_rsvd_status & (ST_RESERVE | ST_LOST_RESERVE)) == 12955 ST_RESERVE) || (un->un_dp->options & ST_NO_RESERVE_RELEASE) || 12956 ((un->un_state == ST_STATE_CLOSING) && (cmd == SCMD_REWIND))) { 12957 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12958 "st_check_cmd_for_need_to_reserve() reserve unneeded %s", 12959 st_print_scsi_cmd(cmd)); 12960 return (0); 12961 } 12962 12963 /* search for this command on the list */ 12964 attrib = st_lookup_cmd_attribute(cmd); 12965 12966 if (attrib == NULL) { 12967 rval = 1; /* Not found, when in doubt reserve */ 12968 } else if ((attrib->requires_reserve) != 0) { 12969 rval = 1; 12970 } else if ((attrib->reserve_byte) != 0) { 12971 /* 12972 * cmd is on list. 12973 * if byte is zero always allowed. 12974 */ 12975 rval = 1; 12976 } else if (((attrib->reserve_mask) & cnt) != 0) { 12977 rval = 1; 12978 } else { 12979 rval = 0; 12980 } 12981 12982 if (rval) { 12983 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12984 "Cmd %s requires reservation", st_print_scsi_cmd(cmd)); 12985 12986 rval = st_do_reserve(un); 12987 } 12988 12989 return (rval); 12990 } 12991 12992 static int 12993 st_reserve_release(struct scsi_tape *un, int cmd, ubufunc_t ubf) 12994 { 12995 struct uscsi_cmd uscsi_cmd; 12996 int rval; 12997 char cdb[CDB_GROUP0]; 12998 struct scsi_arq_status stat; 12999 13000 13001 13002 ST_FUNC(ST_DEVINFO, st_reserve_release); 13003 13004 ASSERT(mutex_owned(ST_MUTEX)); 13005 13006 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13007 "st_reserve_release: %s \n", 13008 (cmd == ST_RELEASE)? "Releasing":"Reserving"); 13009 13010 bzero(&cdb, CDB_GROUP0); 13011 if (cmd == ST_RELEASE) { 13012 cdb[0] = SCMD_RELEASE; 13013 } else { 13014 cdb[0] = SCMD_RESERVE; 13015 } 13016 bzero(&uscsi_cmd, sizeof (struct uscsi_cmd)); 13017 uscsi_cmd.uscsi_flags = USCSI_WRITE | USCSI_RQENABLE; 13018 uscsi_cmd.uscsi_cdb = cdb; 13019 uscsi_cmd.uscsi_cdblen = CDB_GROUP0; 13020 uscsi_cmd.uscsi_timeout = un->un_dp->non_motion_timeout; 13021 uscsi_cmd.uscsi_rqbuf = (caddr_t)&stat; 13022 uscsi_cmd.uscsi_rqlen = sizeof (stat); 13023 13024 rval = ubf(un, &uscsi_cmd, FKIOCTL); 13025 13026 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13027 "st_reserve_release: rval(1)=%d\n", rval); 13028 13029 if (rval) { 13030 if (uscsi_cmd.uscsi_status == STATUS_RESERVATION_CONFLICT) { 13031 rval = EACCES; 13032 } 13033 /* 13034 * dynamically turn off reserve/release support 13035 * in case of drives which do not support 13036 * reserve/release command(ATAPI drives). 13037 */ 13038 if (un->un_status == KEY_ILLEGAL_REQUEST) { 13039 if ((un->un_dp->options & ST_NO_RESERVE_RELEASE) == 0) { 13040 un->un_dp->options |= ST_NO_RESERVE_RELEASE; 13041 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13042 "Tape unit does not support " 13043 "reserve/release \n"); 13044 } 13045 rval = 0; 13046 } 13047 } 13048 return (rval); 13049 } 13050 13051 static int 13052 st_take_ownership(struct scsi_tape *un, ubufunc_t ubf) 13053 { 13054 int rval; 13055 13056 ST_FUNC(ST_DEVINFO, st_take_ownership); 13057 13058 ASSERT(mutex_owned(ST_MUTEX)); 13059 13060 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13061 "st_take_ownership: Entering ...\n"); 13062 13063 13064 rval = st_reserve_release(un, ST_RESERVE, ubf); 13065 /* 13066 * XXX -> Should reset be done only if we get EACCES. 13067 * . 13068 */ 13069 if (rval) { 13070 if (st_reset(un, RESET_LUN) == 0) { 13071 return (EIO); 13072 } 13073 un->un_rsvd_status &= 13074 ~(ST_LOST_RESERVE | ST_RESERVATION_CONFLICT); 13075 13076 mutex_exit(ST_MUTEX); 13077 delay(drv_usectohz(ST_RESERVATION_DELAY)); 13078 mutex_enter(ST_MUTEX); 13079 /* 13080 * remove the check condition. 13081 */ 13082 (void) st_reserve_release(un, ST_RESERVE, ubf); 13083 rval = st_reserve_release(un, ST_RESERVE, ubf); 13084 if (rval != 0) { 13085 if ((st_reserve_release(un, ST_RESERVE, ubf)) 13086 != 0) { 13087 rval = (un->un_rsvd_status & 13088 ST_RESERVATION_CONFLICT) ? EACCES : EIO; 13089 return (rval); 13090 } 13091 } 13092 /* 13093 * Set tape state to ST_STATE_OFFLINE , in case if 13094 * the user wants to continue and start using 13095 * the tape. 13096 */ 13097 un->un_state = ST_STATE_OFFLINE; 13098 un->un_rsvd_status |= ST_INIT_RESERVE; 13099 } 13100 return (rval); 13101 } 13102 13103 static int 13104 st_create_errstats(struct scsi_tape *un, int instance) 13105 { 13106 char kstatname[KSTAT_STRLEN]; 13107 13108 ST_FUNC(ST_DEVINFO, st_create_errstats); 13109 13110 /* 13111 * Create device error kstats 13112 */ 13113 13114 if (un->un_errstats == (kstat_t *)0) { 13115 (void) sprintf(kstatname, "st%d,err", instance); 13116 un->un_errstats = kstat_create("sterr", instance, kstatname, 13117 "device_error", KSTAT_TYPE_NAMED, 13118 sizeof (struct st_errstats) / sizeof (kstat_named_t), 13119 KSTAT_FLAG_PERSISTENT); 13120 13121 if (un->un_errstats) { 13122 struct st_errstats *stp; 13123 13124 stp = (struct st_errstats *)un->un_errstats->ks_data; 13125 kstat_named_init(&stp->st_softerrs, "Soft Errors", 13126 KSTAT_DATA_ULONG); 13127 kstat_named_init(&stp->st_harderrs, "Hard Errors", 13128 KSTAT_DATA_ULONG); 13129 kstat_named_init(&stp->st_transerrs, "Transport Errors", 13130 KSTAT_DATA_ULONG); 13131 kstat_named_init(&stp->st_vid, "Vendor", 13132 KSTAT_DATA_CHAR); 13133 kstat_named_init(&stp->st_pid, "Product", 13134 KSTAT_DATA_CHAR); 13135 kstat_named_init(&stp->st_revision, "Revision", 13136 KSTAT_DATA_CHAR); 13137 kstat_named_init(&stp->st_serial, "Serial No", 13138 KSTAT_DATA_CHAR); 13139 un->un_errstats->ks_private = un; 13140 un->un_errstats->ks_update = nulldev; 13141 kstat_install(un->un_errstats); 13142 /* 13143 * Fill in the static data 13144 */ 13145 (void) strncpy(&stp->st_vid.value.c[0], 13146 ST_INQUIRY->inq_vid, 8); 13147 /* 13148 * XXX: Emulex MT-02 (and emulators) predates 13149 * SCSI-1 and has no vid & pid inquiry data. 13150 */ 13151 if (ST_INQUIRY->inq_len != 0) { 13152 (void) strncpy(&stp->st_pid.value.c[0], 13153 ST_INQUIRY->inq_pid, 16); 13154 (void) strncpy(&stp->st_revision.value.c[0], 13155 ST_INQUIRY->inq_revision, 4); 13156 } 13157 } 13158 } 13159 return (0); 13160 } 13161 13162 static int 13163 st_validate_tapemarks(struct scsi_tape *un, ubufunc_t ubf, tapepos_t *pos) 13164 { 13165 int rval; 13166 bufunc_t bf = (ubf == st_uscsi_rcmd) ? st_rcmd : st_cmd; 13167 13168 ST_FUNC(ST_DEVINFO, st_validate_tapemarks); 13169 13170 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 13171 ASSERT(mutex_owned(ST_MUTEX)); 13172 13173 /* Can't restore an invalid position */ 13174 if (pos->pmode == invalid) { 13175 return (4); 13176 } 13177 13178 /* 13179 * Assumtions: 13180 * If a position was read and is in logical position mode. 13181 * If a drive supports read position it supports locate. 13182 * If the read position type is not NO_POS. even though 13183 * a read position make not have been attemped yet. 13184 * 13185 * The drive can locate to the position. 13186 */ 13187 if (pos->pmode == logical || un->un_read_pos_type != NO_POS) { 13188 /* 13189 * If position mode is logical or legacy mode try 13190 * to locate there as it is faster. 13191 * If it fails try the old way. 13192 */ 13193 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 13194 "Restoring tape position to lgclblkbo=0x%"PRIx64"....", 13195 pos->lgclblkno); 13196 13197 if (st_logical_block_locate(un, st_uscsi_cmd, &un->un_pos, 13198 pos->lgclblkno, pos->partition) == 0) { 13199 /* Assume we are there copy rest of position back */ 13200 if (un->un_pos.lgclblkno == pos->lgclblkno) { 13201 COPY_POS(&un->un_pos, pos); 13202 } 13203 return (0); 13204 } 13205 13206 /* 13207 * If logical block locate failed to restore a logical 13208 * position, can't recover. 13209 */ 13210 if (pos->pmode == logical) { 13211 return (-1); 13212 } 13213 } 13214 13215 13216 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 13217 "Restoring tape position at fileno=%x, blkno=%x....", 13218 pos->fileno, pos->blkno); 13219 13220 /* 13221 * Rewind ? Oh yeah, Fidelity has got the STK F/W changed 13222 * so as not to rewind tape on RESETS: Gee, Has life ever 13223 * been simple in tape land ? 13224 */ 13225 rval = bf(un, SCMD_REWIND, 0, SYNC_CMD); 13226 if (rval) { 13227 scsi_log(ST_DEVINFO, st_label, CE_WARN, 13228 "Failed to restore the last file and block position: In" 13229 " this state, Tape will be loaded at BOT during next open"); 13230 un->un_pos.pmode = invalid; 13231 return (rval); 13232 } 13233 13234 /* If the position was as the result of back space file */ 13235 if (pos->blkno > (INF / 2)) { 13236 /* Go one extra file forward */ 13237 pos->fileno++; 13238 /* Figure how many blocks to back into the previous file */ 13239 pos->blkno = -(INF - pos->blkno); 13240 } 13241 13242 /* Go to requested fileno */ 13243 if (pos->fileno) { 13244 rval = st_cmd(un, SCMD_SPACE, Fmk(pos->fileno), SYNC_CMD); 13245 if (rval) { 13246 scsi_log(ST_DEVINFO, st_label, CE_WARN, 13247 "Failed to restore the last file position: In this " 13248 " state, Tape will be loaded at BOT during next" 13249 " open %d", __LINE__); 13250 un->un_pos.pmode = invalid; 13251 pos->pmode = invalid; 13252 return (rval); 13253 } 13254 } 13255 13256 /* 13257 * If backing into a file we already did an extra file forward. 13258 * Now we have to back over the filemark to get to the end of 13259 * the previous file. The blkno has been ajusted to a negative 13260 * value so we will get to the expected location. 13261 */ 13262 if (pos->blkno) { 13263 rval = bf(un, SCMD_SPACE, Fmk(-1), SYNC_CMD); 13264 if (rval) { 13265 scsi_log(ST_DEVINFO, st_label, CE_WARN, 13266 "Failed to restore the last file position: In this " 13267 " state, Tape will be loaded at BOT during next" 13268 " open %d", __LINE__); 13269 un->un_pos.pmode = invalid; 13270 pos->pmode = invalid; 13271 return (rval); 13272 } 13273 } 13274 13275 /* 13276 * The position mode, block and fileno should be correct, 13277 * This updates eof and logical position information. 13278 */ 13279 un->un_pos.eof = pos->eof; 13280 un->un_pos.lgclblkno = pos->lgclblkno; 13281 13282 return (0); 13283 } 13284 13285 /* 13286 * check sense key, ASC, ASCQ in order to determine if the tape needs 13287 * to be ejected 13288 */ 13289 13290 static int 13291 st_check_asc_ascq(struct scsi_tape *un) 13292 { 13293 struct scsi_extended_sense *sensep = ST_RQSENSE; 13294 struct tape_failure_code *code; 13295 13296 ST_FUNC(ST_DEVINFO, st_check_asc_ascq); 13297 13298 for (code = st_tape_failure_code; code->key != 0xff; code++) { 13299 if ((code->key == sensep->es_key) && 13300 (code->add_code == sensep->es_add_code) && 13301 (code->qual_code == sensep->es_qual_code)) 13302 return (1); 13303 } 13304 return (0); 13305 } 13306 13307 /* 13308 * st_logpage_supported() sends a Log Sense command with 13309 * page code = 0 = Supported Log Pages Page to the device, 13310 * to see whether the page 'page' is supported. 13311 * Return values are: 13312 * -1 if the Log Sense command fails 13313 * 0 if page is not supported 13314 * 1 if page is supported 13315 */ 13316 13317 static int 13318 st_logpage_supported(struct scsi_tape *un, uchar_t page) 13319 { 13320 uchar_t *sp, *sensep; 13321 unsigned length; 13322 struct uscsi_cmd *com; 13323 struct scsi_arq_status status; 13324 int rval; 13325 char cdb[CDB_GROUP1] = { 13326 SCMD_LOG_SENSE_G1, 13327 0, 13328 SUPPORTED_LOG_PAGES_PAGE, 13329 0, 13330 0, 13331 0, 13332 0, 13333 0, 13334 (char)LOG_SENSE_LENGTH, 13335 0 13336 }; 13337 13338 ST_FUNC(ST_DEVINFO, st_logpage_supported); 13339 13340 ASSERT(mutex_owned(ST_MUTEX)); 13341 13342 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13343 sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP); 13344 13345 com->uscsi_cdb = cdb; 13346 com->uscsi_cdblen = CDB_GROUP1; 13347 com->uscsi_bufaddr = (caddr_t)sensep; 13348 com->uscsi_buflen = LOG_SENSE_LENGTH; 13349 com->uscsi_rqlen = sizeof (status); 13350 com->uscsi_rqbuf = (caddr_t)&status; 13351 com->uscsi_flags = 13352 USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 13353 com->uscsi_timeout = un->un_dp->non_motion_timeout; 13354 rval = st_uscsi_cmd(un, com, FKIOCTL); 13355 if (rval || com->uscsi_status) { 13356 /* uscsi-command failed */ 13357 rval = -1; 13358 } else { 13359 13360 sp = sensep + 3; 13361 13362 for (length = *sp++; length > 0; length--, sp++) { 13363 13364 if (*sp == page) { 13365 rval = 1; 13366 break; 13367 } 13368 } 13369 } 13370 kmem_free(com, sizeof (struct uscsi_cmd)); 13371 kmem_free(sensep, LOG_SENSE_LENGTH); 13372 return (rval); 13373 } 13374 13375 13376 /* 13377 * st_check_clean_bit() gets the status of the tape's cleaning bit. 13378 * 13379 * If the device does support the TapeAlert log page, then the cleaning bit 13380 * information will be read from this page. Otherwise we will see if one of 13381 * ST_CLN_TYPE_1, ST_CLN_TYPE_2 or ST_CLN_TYPE_3 is set in the properties of 13382 * the device, which means, that we can get the cleaning bit information via 13383 * a RequestSense command. 13384 * If both methods of getting cleaning bit information are not supported 13385 * st_check_clean_bit() will return with 0. Otherwise st_check_clean_bit() 13386 * returns with 13387 * - MTF_TAPE_CLN_SUPPORTED if cleaning bit is not set or 13388 * - MTF_TAPE_CLN_SUPPORTED | MTF_TAPE_HEAD_DIRTY if cleaning bit is set. 13389 * If the call to st_uscsi_cmd() to do the Log Sense or the Request Sense 13390 * command fails, or if the amount of Request Sense data is not enough, then 13391 * st_check_clean_bit() returns with -1. 13392 */ 13393 13394 static int 13395 st_check_clean_bit(struct scsi_tape *un) 13396 { 13397 int rval = 0; 13398 13399 ST_FUNC(ST_DEVINFO, st_check_clean_bit); 13400 13401 ASSERT(mutex_owned(ST_MUTEX)); 13402 13403 if (un->un_HeadClean & TAPE_ALERT_NOT_SUPPORTED) { 13404 return (rval); 13405 } 13406 13407 if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) { 13408 13409 rval = st_logpage_supported(un, TAPE_SEQUENTIAL_PAGE); 13410 if (rval == -1) { 13411 return (0); 13412 } 13413 if (rval == 1) { 13414 13415 un->un_HeadClean |= TAPE_SEQUENTIAL_SUPPORTED; 13416 } 13417 13418 rval = st_logpage_supported(un, TAPE_ALERT_PAGE); 13419 if (rval == -1) { 13420 return (0); 13421 } 13422 if (rval == 1) { 13423 13424 un->un_HeadClean |= TAPE_ALERT_SUPPORTED; 13425 } 13426 13427 if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) { 13428 13429 un->un_HeadClean = TAPE_ALERT_NOT_SUPPORTED; 13430 } 13431 } 13432 13433 rval = 0; 13434 13435 if (un->un_HeadClean & TAPE_SEQUENTIAL_SUPPORTED) { 13436 13437 rval = st_check_sequential_clean_bit(un); 13438 if (rval == -1) { 13439 return (0); 13440 } 13441 } 13442 13443 if ((rval == 0) && (un->un_HeadClean & TAPE_ALERT_SUPPORTED)) { 13444 13445 rval = st_check_alert_flags(un); 13446 if (rval == -1) { 13447 return (0); 13448 } 13449 } 13450 13451 if ((rval == 0) && (un->un_dp->options & ST_CLN_MASK)) { 13452 13453 rval = st_check_sense_clean_bit(un); 13454 if (rval == -1) { 13455 return (0); 13456 } 13457 } 13458 13459 /* 13460 * If found a supported means to check need to clean. 13461 */ 13462 if (rval & MTF_TAPE_CLN_SUPPORTED) { 13463 13464 /* 13465 * head needs to be cleaned. 13466 */ 13467 if (rval & MTF_TAPE_HEAD_DIRTY) { 13468 13469 /* 13470 * Print log message only first time 13471 * found needing cleaned. 13472 */ 13473 if ((un->un_HeadClean & TAPE_PREVIOUSLY_DIRTY) == 0) { 13474 13475 scsi_log(ST_DEVINFO, st_label, CE_WARN, 13476 "Periodic head cleaning required"); 13477 13478 un->un_HeadClean |= TAPE_PREVIOUSLY_DIRTY; 13479 } 13480 13481 } else { 13482 13483 un->un_HeadClean &= ~TAPE_PREVIOUSLY_DIRTY; 13484 } 13485 } 13486 13487 return (rval); 13488 } 13489 13490 13491 static int 13492 st_check_sequential_clean_bit(struct scsi_tape *un) 13493 { 13494 int rval; 13495 int ix; 13496 ushort_t parameter; 13497 struct uscsi_cmd *cmd; 13498 struct log_sequential_page *sp; 13499 struct log_sequential_page_parameter *prm; 13500 struct scsi_arq_status status; 13501 char cdb[CDB_GROUP1] = { 13502 SCMD_LOG_SENSE_G1, 13503 0, 13504 TAPE_SEQUENTIAL_PAGE | CURRENT_CUMULATIVE_VALUES, 13505 0, 13506 0, 13507 0, 13508 0, 13509 (char)(sizeof (struct log_sequential_page) >> 8), 13510 (char)(sizeof (struct log_sequential_page)), 13511 0 13512 }; 13513 13514 ST_FUNC(ST_DEVINFO, st_check_sequential_clean_bit); 13515 13516 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13517 sp = kmem_zalloc(sizeof (struct log_sequential_page), KM_SLEEP); 13518 13519 cmd->uscsi_flags = 13520 USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 13521 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 13522 cmd->uscsi_cdb = cdb; 13523 cmd->uscsi_cdblen = CDB_GROUP1; 13524 cmd->uscsi_bufaddr = (caddr_t)sp; 13525 cmd->uscsi_buflen = sizeof (struct log_sequential_page); 13526 cmd->uscsi_rqlen = sizeof (status); 13527 cmd->uscsi_rqbuf = (caddr_t)&status; 13528 13529 rval = st_uscsi_cmd(un, cmd, FKIOCTL); 13530 13531 if (rval || cmd->uscsi_status || cmd->uscsi_resid) { 13532 13533 rval = -1; 13534 13535 } else if (sp->log_page.code != TAPE_SEQUENTIAL_PAGE) { 13536 13537 rval = -1; 13538 } 13539 13540 prm = &sp->param[0]; 13541 13542 for (ix = 0; rval == 0 && ix < TAPE_SEQUENTIAL_PAGE_PARA; ix++) { 13543 13544 if (prm->log_param.length == 0) { 13545 break; 13546 } 13547 13548 parameter = (((prm->log_param.pc_hi << 8) & 0xff00) + 13549 (prm->log_param.pc_lo & 0xff)); 13550 13551 if (parameter == SEQUENTIAL_NEED_CLN) { 13552 13553 rval = MTF_TAPE_CLN_SUPPORTED; 13554 if (prm->param_value[prm->log_param.length - 1]) { 13555 13556 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13557 "sequential log says head dirty\n"); 13558 rval |= MTF_TAPE_HEAD_DIRTY; 13559 } 13560 } 13561 prm = (struct log_sequential_page_parameter *) 13562 &prm->param_value[prm->log_param.length]; 13563 } 13564 13565 kmem_free(cmd, sizeof (struct uscsi_cmd)); 13566 kmem_free(sp, sizeof (struct log_sequential_page)); 13567 13568 return (rval); 13569 } 13570 13571 13572 static int 13573 st_check_alert_flags(struct scsi_tape *un) 13574 { 13575 struct st_tape_alert *ta; 13576 struct uscsi_cmd *com; 13577 struct scsi_arq_status status; 13578 unsigned ix, length; 13579 int rval; 13580 tape_alert_flags flag; 13581 char cdb[CDB_GROUP1] = { 13582 SCMD_LOG_SENSE_G1, 13583 0, 13584 TAPE_ALERT_PAGE | CURRENT_THRESHOLD_VALUES, 13585 0, 13586 0, 13587 0, 13588 0, 13589 (char)(sizeof (struct st_tape_alert) >> 8), 13590 (char)(sizeof (struct st_tape_alert)), 13591 0 13592 }; 13593 13594 ST_FUNC(ST_DEVINFO, st_check_alert_clean_bit); 13595 13596 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13597 ta = kmem_zalloc(sizeof (struct st_tape_alert), KM_SLEEP); 13598 13599 com->uscsi_cdb = cdb; 13600 com->uscsi_cdblen = CDB_GROUP1; 13601 com->uscsi_bufaddr = (caddr_t)ta; 13602 com->uscsi_buflen = sizeof (struct st_tape_alert); 13603 com->uscsi_rqlen = sizeof (status); 13604 com->uscsi_rqbuf = (caddr_t)&status; 13605 com->uscsi_flags = 13606 USCSI_DIAGNOSE | USCSI_RQENABLE | USCSI_READ; 13607 com->uscsi_timeout = un->un_dp->non_motion_timeout; 13608 13609 rval = st_uscsi_cmd(un, com, FKIOCTL); 13610 13611 if (rval || com->uscsi_status || com->uscsi_resid) { 13612 13613 rval = -1; /* uscsi-command failed */ 13614 13615 } else if (ta->log_page.code != TAPE_ALERT_PAGE) { 13616 13617 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13618 "Not Alert Log Page returned 0x%X\n", ta->log_page.code); 13619 rval = -1; 13620 } 13621 13622 length = (ta->log_page.length_hi << 8) + ta->log_page.length_lo; 13623 13624 13625 if (length != TAPE_ALERT_PARAMETER_LENGTH) { 13626 13627 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13628 "TapeAlert length %d\n", length); 13629 } 13630 13631 13632 for (ix = 0; ix < TAPE_ALERT_MAX_PARA; ix++) { 13633 13634 /* 13635 * if rval is bad before the first pass don't bother 13636 */ 13637 if (ix == 0 && rval != 0) { 13638 13639 break; 13640 } 13641 13642 flag = ((ta->param[ix].log_param.pc_hi << 8) + 13643 ta->param[ix].log_param.pc_lo); 13644 13645 if ((ta->param[ix].param_value & 1) == 0) { 13646 continue; 13647 } 13648 /* 13649 * check to see if current parameter is of interest. 13650 * CLEAN_FOR_ERRORS is vendor specific to 9840 9940 stk's. 13651 */ 13652 if ((flag == TAF_CLEAN_NOW) || 13653 (flag == TAF_CLEAN_PERIODIC) || 13654 ((flag == CLEAN_FOR_ERRORS) && 13655 (un->un_dp->type == ST_TYPE_STK9840))) { 13656 13657 rval = MTF_TAPE_CLN_SUPPORTED; 13658 13659 13660 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13661 "alert_page drive needs clean %d\n", flag); 13662 un->un_HeadClean |= TAPE_ALERT_STILL_DIRTY; 13663 rval |= MTF_TAPE_HEAD_DIRTY; 13664 13665 } else if (flag == TAF_CLEANING_MEDIA) { 13666 13667 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13668 "alert_page drive was cleaned\n"); 13669 un->un_HeadClean &= ~TAPE_ALERT_STILL_DIRTY; 13670 } 13671 13672 } 13673 13674 /* 13675 * Report it as dirty till we see it cleaned 13676 */ 13677 if (un->un_HeadClean & TAPE_ALERT_STILL_DIRTY) { 13678 13679 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13680 "alert_page still dirty\n"); 13681 rval |= MTF_TAPE_HEAD_DIRTY; 13682 } 13683 13684 kmem_free(com, sizeof (struct uscsi_cmd)); 13685 kmem_free(ta, sizeof (struct st_tape_alert)); 13686 13687 return (rval); 13688 } 13689 13690 13691 static int 13692 st_check_sense_clean_bit(struct scsi_tape *un) 13693 { 13694 uchar_t *sensep; 13695 char cdb[CDB_GROUP0]; 13696 struct uscsi_cmd *com; 13697 ushort_t byte_pos; 13698 uchar_t bit_mask; 13699 unsigned length; 13700 int index; 13701 int rval; 13702 13703 ST_FUNC(ST_DEVINFO, st_check_sense_clean_bit); 13704 13705 /* 13706 * Since this tape does not support Tape Alert, 13707 * we now try to get the cleanbit status via 13708 * Request Sense. 13709 */ 13710 13711 if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_1) { 13712 13713 index = 0; 13714 13715 } else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_2) { 13716 13717 index = 1; 13718 13719 } else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_3) { 13720 13721 index = 2; 13722 13723 } else { 13724 13725 return (-1); 13726 } 13727 13728 byte_pos = st_cln_bit_position[index].cln_bit_byte; 13729 bit_mask = st_cln_bit_position[index].cln_bit_mask; 13730 length = byte_pos + 1; 13731 13732 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13733 sensep = kmem_zalloc(length, KM_SLEEP); 13734 13735 cdb[0] = SCMD_REQUEST_SENSE; 13736 cdb[1] = 0; 13737 cdb[2] = 0; 13738 cdb[3] = 0; 13739 cdb[4] = (char)length; 13740 cdb[5] = 0; 13741 13742 com->uscsi_cdb = cdb; 13743 com->uscsi_cdblen = CDB_GROUP0; 13744 com->uscsi_bufaddr = (caddr_t)sensep; 13745 com->uscsi_buflen = length; 13746 com->uscsi_flags = 13747 USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 13748 com->uscsi_timeout = un->un_dp->non_motion_timeout; 13749 13750 rval = st_uscsi_cmd(un, com, FKIOCTL); 13751 13752 if (rval || com->uscsi_status || com->uscsi_resid) { 13753 13754 rval = -1; 13755 13756 } else { 13757 13758 rval = MTF_TAPE_CLN_SUPPORTED; 13759 if ((sensep[byte_pos] & bit_mask) == bit_mask) { 13760 13761 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13762 "sense data says head dirty\n"); 13763 rval |= MTF_TAPE_HEAD_DIRTY; 13764 } 13765 } 13766 13767 kmem_free(com, sizeof (struct uscsi_cmd)); 13768 kmem_free(sensep, length); 13769 return (rval); 13770 } 13771 13772 /* 13773 * st_clear_unit_attention 13774 * 13775 * run test unit ready's to clear out outstanding 13776 * unit attentions. 13777 * returns zero for SUCCESS or the errno from st_cmd call 13778 */ 13779 static int 13780 st_clear_unit_attentions(dev_t dev_instance, int max_trys) 13781 { 13782 int i = 0; 13783 int rval; 13784 13785 GET_SOFT_STATE(dev_instance); 13786 ST_FUNC(ST_DEVINFO, st_clear_unit_attentions); 13787 13788 do { 13789 rval = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 13790 } while ((rval != 0) && (rval != ENXIO) && (++i < max_trys)); 13791 return (rval); 13792 } 13793 13794 static void 13795 st_calculate_timeouts(struct scsi_tape *un) 13796 { 13797 ST_FUNC(ST_DEVINFO, st_calculate_timeouts); 13798 13799 if (un->un_dp->non_motion_timeout == 0) { 13800 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13801 un->un_dp->non_motion_timeout = 13802 st_io_time * st_long_timeout_x; 13803 } else { 13804 un->un_dp->non_motion_timeout = (ushort_t)st_io_time; 13805 } 13806 } 13807 13808 if (un->un_dp->io_timeout == 0) { 13809 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13810 un->un_dp->io_timeout = st_io_time * st_long_timeout_x; 13811 } else { 13812 un->un_dp->io_timeout = (ushort_t)st_io_time; 13813 } 13814 } 13815 13816 if (un->un_dp->rewind_timeout == 0) { 13817 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13818 un->un_dp->rewind_timeout = 13819 st_space_time * st_long_timeout_x; 13820 } else { 13821 un->un_dp->rewind_timeout = (ushort_t)st_space_time; 13822 } 13823 } 13824 13825 if (un->un_dp->space_timeout == 0) { 13826 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13827 un->un_dp->space_timeout = 13828 st_space_time * st_long_timeout_x; 13829 } else { 13830 un->un_dp->space_timeout = (ushort_t)st_space_time; 13831 } 13832 } 13833 13834 if (un->un_dp->load_timeout == 0) { 13835 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13836 un->un_dp->load_timeout = 13837 st_space_time * st_long_timeout_x; 13838 } else { 13839 un->un_dp->load_timeout = (ushort_t)st_space_time; 13840 } 13841 } 13842 13843 if (un->un_dp->unload_timeout == 0) { 13844 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13845 un->un_dp->unload_timeout = 13846 st_space_time * st_long_timeout_x; 13847 } else { 13848 un->un_dp->unload_timeout = (ushort_t)st_space_time; 13849 } 13850 } 13851 13852 if (un->un_dp->erase_timeout == 0) { 13853 if (un->un_dp->options & ST_LONG_ERASE) { 13854 un->un_dp->erase_timeout = 13855 st_space_time * st_long_space_time_x; 13856 } else { 13857 un->un_dp->erase_timeout = (ushort_t)st_space_time; 13858 } 13859 } 13860 } 13861 13862 13863 static writablity 13864 st_is_not_wormable(struct scsi_tape *un) 13865 { 13866 ST_FUNC(ST_DEVINFO, st_is_not_wormable); 13867 return (RDWR); 13868 } 13869 13870 static writablity 13871 st_is_hp_dat_tape_worm(struct scsi_tape *un) 13872 { 13873 writablity wrt; 13874 13875 ST_FUNC(ST_DEVINFO, st_is_hp_dat_tape_worm); 13876 13877 /* Mode sense should be current */ 13878 if (un->un_mspl->media_type == 1) { 13879 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13880 "Drive has WORM media loaded\n"); 13881 wrt = WORM; 13882 } else { 13883 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13884 "Drive has non WORM media loaded\n"); 13885 wrt = RDWR; 13886 } 13887 return (wrt); 13888 } 13889 13890 #define HP_DAT_INQUIRY 0x4A 13891 static writablity 13892 st_is_hp_dat_worm(struct scsi_tape *un) 13893 { 13894 char *buf; 13895 int result; 13896 writablity wrt; 13897 13898 ST_FUNC(ST_DEVINFO, st_is_hp_dat_worm); 13899 13900 buf = kmem_zalloc(HP_DAT_INQUIRY, KM_SLEEP); 13901 13902 result = st_get_special_inquiry(un, HP_DAT_INQUIRY, buf, 0); 13903 13904 if (result != 0) { 13905 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13906 "Read Standard Inquiry for WORM support failed"); 13907 wrt = FAILED; 13908 } else if ((buf[40] & 1) == 0) { 13909 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13910 "Drive is NOT WORMable\n"); 13911 /* This drive doesn't support it so don't check again */ 13912 un->un_dp->options &= ~ST_WORMABLE; 13913 wrt = RDWR; 13914 un->un_wormable = st_is_not_wormable; 13915 } else { 13916 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13917 "Drive supports WORM version %d\n", buf[40] >> 1); 13918 un->un_wormable = st_is_hp_dat_tape_worm; 13919 wrt = un->un_wormable(un); 13920 } 13921 13922 kmem_free(buf, HP_DAT_INQUIRY); 13923 13924 /* 13925 * If drive doesn't support it no point in checking further. 13926 */ 13927 return (wrt); 13928 } 13929 13930 static writablity 13931 st_is_hp_lto_tape_worm(struct scsi_tape *un) 13932 { 13933 writablity wrt; 13934 13935 ST_FUNC(ST_DEVINFO, st_is_hp_lto_tape_worm); 13936 13937 /* Mode sense should be current */ 13938 switch (un->un_mspl->media_type) { 13939 case 0x00: 13940 switch (un->un_mspl->density) { 13941 case 0x40: 13942 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13943 "Drive has standard Gen I media loaded\n"); 13944 break; 13945 case 0x42: 13946 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13947 "Drive has standard Gen II media loaded\n"); 13948 break; 13949 case 0x44: 13950 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13951 "Drive has standard Gen III media loaded\n"); 13952 break; 13953 case 0x46: 13954 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13955 "Drive has standard Gen IV media loaded\n"); 13956 break; 13957 default: 13958 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13959 "Drive has standard unknown 0x%X media loaded\n", 13960 un->un_mspl->density); 13961 } 13962 wrt = RDWR; 13963 break; 13964 case 0x01: 13965 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13966 "Drive has WORM medium loaded\n"); 13967 wrt = WORM; 13968 break; 13969 case 0x80: 13970 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13971 "Drive has CD-ROM emulation medium loaded\n"); 13972 wrt = WORM; 13973 break; 13974 default: 13975 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13976 "Drive has an unexpected medium type 0x%X loaded\n", 13977 un->un_mspl->media_type); 13978 wrt = RDWR; 13979 } 13980 13981 return (wrt); 13982 } 13983 13984 #define LTO_REQ_INQUIRY 44 13985 static writablity 13986 st_is_hp_lto_worm(struct scsi_tape *un) 13987 { 13988 char *buf; 13989 int result; 13990 writablity wrt; 13991 13992 ST_FUNC(ST_DEVINFO, st_is_hp_lto_worm); 13993 13994 buf = kmem_zalloc(LTO_REQ_INQUIRY, KM_SLEEP); 13995 13996 result = st_get_special_inquiry(un, LTO_REQ_INQUIRY, buf, 0); 13997 13998 if (result != 0) { 13999 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14000 "Read Standard Inquiry for WORM support failed"); 14001 wrt = FAILED; 14002 } else if ((buf[40] & 1) == 0) { 14003 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14004 "Drive is NOT WORMable\n"); 14005 /* This drive doesn't support it so don't check again */ 14006 un->un_dp->options &= ~ST_WORMABLE; 14007 wrt = RDWR; 14008 un->un_wormable = st_is_not_wormable; 14009 } else { 14010 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14011 "Drive supports WORM version %d\n", buf[40] >> 1); 14012 un->un_wormable = st_is_hp_lto_tape_worm; 14013 wrt = un->un_wormable(un); 14014 } 14015 14016 kmem_free(buf, LTO_REQ_INQUIRY); 14017 14018 /* 14019 * If drive doesn't support it no point in checking further. 14020 */ 14021 return (wrt); 14022 } 14023 14024 static writablity 14025 st_is_t10_worm_device(struct scsi_tape *un) 14026 { 14027 writablity wrt; 14028 14029 ST_FUNC(ST_DEVINFO, st_is_t10_worm_device); 14030 14031 if (un->un_mspl->media_type == 0x3c) { 14032 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14033 "Drive has WORM media loaded\n"); 14034 wrt = WORM; 14035 } else { 14036 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14037 "Drive has non WORM media loaded\n"); 14038 wrt = RDWR; 14039 } 14040 return (wrt); 14041 } 14042 14043 #define SEQ_CAP_PAGE (char)0xb0 14044 static writablity 14045 st_is_t10_worm(struct scsi_tape *un) 14046 { 14047 char *buf; 14048 int result; 14049 writablity wrt; 14050 14051 ST_FUNC(ST_DEVINFO, st_is_t10_worm); 14052 14053 buf = kmem_zalloc(6, KM_SLEEP); 14054 14055 result = st_get_special_inquiry(un, 6, buf, SEQ_CAP_PAGE); 14056 14057 if (result != 0) { 14058 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14059 "Read Vitial Inquiry for Sequental Capability" 14060 " WORM support failed %x", result); 14061 wrt = FAILED; 14062 } else if ((buf[4] & 1) == 0) { 14063 ASSERT(buf[1] == SEQ_CAP_PAGE); 14064 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14065 "Drive is NOT WORMable\n"); 14066 /* This drive doesn't support it so don't check again */ 14067 un->un_dp->options &= ~ST_WORMABLE; 14068 wrt = RDWR; 14069 un->un_wormable = st_is_not_wormable; 14070 } else { 14071 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14072 "Drive supports WORM\n"); 14073 un->un_wormable = st_is_t10_worm_device; 14074 wrt = un->un_wormable(un); 14075 } 14076 14077 kmem_free(buf, 6); 14078 14079 return (wrt); 14080 } 14081 14082 14083 #define STK_REQ_SENSE 26 14084 14085 static writablity 14086 st_is_stk_worm(struct scsi_tape *un) 14087 { 14088 char cdb[CDB_GROUP0] = {SCMD_REQUEST_SENSE, 0, 0, 0, STK_REQ_SENSE, 0}; 14089 struct scsi_extended_sense *sense; 14090 struct uscsi_cmd *cmd; 14091 char *buf; 14092 int result; 14093 writablity wrt; 14094 14095 ST_FUNC(ST_DEVINFO, st_is_stk_worm); 14096 14097 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 14098 buf = kmem_alloc(STK_REQ_SENSE, KM_SLEEP); 14099 sense = (struct scsi_extended_sense *)buf; 14100 14101 cmd->uscsi_flags = USCSI_READ; 14102 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 14103 cmd->uscsi_cdb = &cdb[0]; 14104 cmd->uscsi_bufaddr = buf; 14105 cmd->uscsi_buflen = STK_REQ_SENSE; 14106 cmd->uscsi_cdblen = CDB_GROUP0; 14107 cmd->uscsi_rqlen = 0; 14108 cmd->uscsi_rqbuf = NULL; 14109 14110 result = st_uscsi_cmd(un, cmd, FKIOCTL); 14111 14112 if (result != 0 || cmd->uscsi_status != 0) { 14113 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14114 "Request Sense for WORM failed"); 14115 wrt = RDWR; 14116 } else if (sense->es_add_len + 8 < 24) { 14117 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14118 "Drive didn't send enough sense data for WORM byte %d\n", 14119 sense->es_add_len + 8); 14120 wrt = RDWR; 14121 un->un_wormable = st_is_not_wormable; 14122 } else if ((buf[24]) & 0x02) { 14123 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14124 "Drive has WORM tape loaded\n"); 14125 wrt = WORM; 14126 un->un_wormable = st_is_stk_worm; 14127 } else { 14128 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14129 "Drive has normal tape loaded\n"); 14130 wrt = RDWR; 14131 un->un_wormable = st_is_stk_worm; 14132 } 14133 14134 kmem_free(buf, STK_REQ_SENSE); 14135 kmem_free(cmd, sizeof (struct uscsi_cmd)); 14136 return (wrt); 14137 } 14138 14139 #define DLT_INQ_SZ 44 14140 14141 static writablity 14142 st_is_dlt_tape_worm(struct scsi_tape *un) 14143 { 14144 caddr_t buf; 14145 int result; 14146 writablity wrt; 14147 14148 ST_FUNC(ST_DEVINFO, st_is_dlt_tape_worm); 14149 14150 buf = kmem_alloc(DLT_INQ_SZ, KM_SLEEP); 14151 14152 /* Read Attribute Media Type */ 14153 14154 result = st_read_attributes(un, 0x0408, buf, 10, st_uscsi_cmd); 14155 14156 /* 14157 * If this quantum drive is attached via an HBA that cannot 14158 * support thr read attributes command return error in the 14159 * hope that someday they will support the t10 method. 14160 */ 14161 if (result == EINVAL && un->un_max_cdb_sz < CDB_GROUP4) { 14162 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14163 "Read Attribute Command for WORM Media detection is not " 14164 "supported on the HBA that this drive is attached to."); 14165 wrt = RDWR; 14166 un->un_wormable = st_is_not_wormable; 14167 goto out; 14168 } 14169 14170 if (result != 0) { 14171 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14172 "Read Attribute Command for WORM Media returned 0x%x", 14173 result); 14174 wrt = RDWR; 14175 un->un_dp->options &= ~ST_WORMABLE; 14176 goto out; 14177 } 14178 14179 if ((uchar_t)buf[9] == 0x80) { 14180 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14181 "Drive media is WORM\n"); 14182 wrt = WORM; 14183 } else { 14184 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14185 "Drive media is not WORM Media 0x%x\n", (uchar_t)buf[9]); 14186 wrt = RDWR; 14187 } 14188 14189 out: 14190 kmem_free(buf, DLT_INQ_SZ); 14191 return (wrt); 14192 } 14193 14194 static writablity 14195 st_is_dlt_worm(struct scsi_tape *un) 14196 { 14197 caddr_t buf; 14198 int result; 14199 writablity wrt; 14200 14201 ST_FUNC(ST_DEVINFO, st_is_dlt_worm); 14202 14203 buf = kmem_alloc(DLT_INQ_SZ, KM_SLEEP); 14204 14205 result = st_get_special_inquiry(un, DLT_INQ_SZ, buf, 0xC0); 14206 14207 if (result != 0) { 14208 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14209 "Read Vendor Specific Inquiry for WORM support failed"); 14210 wrt = RDWR; 14211 goto out; 14212 } 14213 14214 if ((buf[2] & 1) == 0) { 14215 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14216 "Drive is not WORMable\n"); 14217 wrt = RDWR; 14218 un->un_dp->options &= ~ST_WORMABLE; 14219 un->un_wormable = st_is_not_wormable; 14220 goto out; 14221 } else { 14222 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14223 "Drive is WORMable\n"); 14224 un->un_wormable = st_is_dlt_tape_worm; 14225 wrt = un->un_wormable(un); 14226 } 14227 out: 14228 kmem_free(buf, DLT_INQ_SZ); 14229 14230 return (wrt); 14231 } 14232 14233 typedef struct { 14234 struct modeheader_seq header; 14235 #if defined(_BIT_FIELDS_LTOH) /* X86 */ 14236 uchar_t pagecode :6, 14237 :2; 14238 uchar_t page_len; 14239 uchar_t syslogalive :2, 14240 device :1, 14241 abs :1, 14242 ulpbot :1, 14243 prth :1, 14244 ponej :1, 14245 ait :1; 14246 uchar_t span; 14247 14248 uchar_t :6, 14249 worm :1, 14250 mic :1; 14251 uchar_t worm_cap :1, 14252 :7; 14253 uint32_t :32; 14254 #else /* SPARC */ 14255 uchar_t :2, 14256 pagecode :6; 14257 uchar_t page_len; 14258 uchar_t ait :1, 14259 device :1, 14260 abs :1, 14261 ulpbot :1, 14262 prth :1, 14263 ponej :1, 14264 syslogalive :2; 14265 uchar_t span; 14266 uchar_t mic :1, 14267 worm :1, 14268 :6; 14269 uchar_t :7, 14270 worm_cap :1; 14271 uint32_t :32; 14272 #endif 14273 }ait_dev_con; 14274 14275 #define AIT_DEV_PAGE 0x31 14276 static writablity 14277 st_is_sony_worm(struct scsi_tape *un) 14278 { 14279 int result; 14280 writablity wrt; 14281 ait_dev_con *ait_conf; 14282 14283 ST_FUNC(ST_DEVINFO, st_is_sony_worm); 14284 14285 ait_conf = kmem_zalloc(sizeof (ait_dev_con), KM_SLEEP); 14286 14287 result = st_gen_mode_sense(un, st_uscsi_cmd, AIT_DEV_PAGE, 14288 (struct seq_mode *)ait_conf, sizeof (ait_dev_con)); 14289 14290 if (result == 0) { 14291 14292 if (ait_conf->pagecode != AIT_DEV_PAGE) { 14293 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14294 "returned page 0x%x not 0x%x AIT_DEV_PAGE\n", 14295 ait_conf->pagecode, AIT_DEV_PAGE); 14296 wrt = RDWR; 14297 un->un_wormable = st_is_not_wormable; 14298 14299 } else if (ait_conf->worm_cap) { 14300 14301 un->un_wormable = st_is_sony_worm; 14302 14303 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14304 "Drives is WORMable\n"); 14305 if (ait_conf->worm) { 14306 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14307 "Media is WORM\n"); 14308 wrt = WORM; 14309 } else { 14310 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14311 "Media is not WORM\n"); 14312 wrt = RDWR; 14313 } 14314 14315 } else { 14316 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14317 "Drives not is WORMable\n"); 14318 wrt = RDWR; 14319 /* No further checking required */ 14320 un->un_dp->options &= ~ST_WORMABLE; 14321 } 14322 14323 } else { 14324 14325 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14326 "AIT device config mode sense page read command failed" 14327 " result = %d ", result); 14328 wrt = FAILED; 14329 un->un_wormable = st_is_not_wormable; 14330 } 14331 14332 kmem_free(ait_conf, sizeof (ait_dev_con)); 14333 return (wrt); 14334 } 14335 14336 static writablity 14337 st_is_drive_worm(struct scsi_tape *un) 14338 { 14339 writablity wrt; 14340 14341 ST_FUNC(ST_DEVINFO, st_is_sony_worm); 14342 14343 switch (un->un_dp->type) { 14344 case MT_ISDLT: 14345 wrt = st_is_dlt_worm(un); 14346 break; 14347 14348 case MT_ISSTK9840: 14349 wrt = st_is_stk_worm(un); 14350 break; 14351 14352 case MT_IS8MM: 14353 case MT_ISAIT: 14354 wrt = st_is_sony_worm(un); 14355 break; 14356 14357 case MT_LTO: 14358 if (strncmp("HP ", un->un_dp->vid, 3) == 0) { 14359 wrt = st_is_hp_lto_worm(un); 14360 } else { 14361 wrt = st_is_t10_worm(un); 14362 } 14363 break; 14364 14365 case MT_ISDAT: 14366 if (strncmp("HP ", un->un_dp->vid, 3) == 0) { 14367 wrt = st_is_hp_dat_worm(un); 14368 } else { 14369 wrt = st_is_t10_worm(un); 14370 } 14371 break; 14372 14373 default: 14374 wrt = FAILED; 14375 break; 14376 } 14377 14378 /* 14379 * If any of the above failed try the t10 standard method. 14380 */ 14381 if (wrt == FAILED) { 14382 wrt = st_is_t10_worm(un); 14383 } 14384 14385 /* 14386 * Unknown method for detecting WORM media. 14387 */ 14388 if (wrt == FAILED) { 14389 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14390 "Unknown method for WORM media detection\n"); 14391 wrt = RDWR; 14392 un->un_dp->options &= ~ST_WORMABLE; 14393 } 14394 14395 return (wrt); 14396 } 14397 14398 static int 14399 st_read_attributes(struct scsi_tape *un, uint16_t attribute, void *pnt, 14400 size_t size, ubufunc_t bufunc) 14401 { 14402 char cdb[CDB_GROUP4]; 14403 int result; 14404 struct uscsi_cmd *cmd; 14405 struct scsi_arq_status status; 14406 14407 caddr_t buf = (caddr_t)pnt; 14408 14409 ST_FUNC(ST_DEVINFO, st_read_attributes); 14410 14411 if (un->un_sd->sd_inq->inq_ansi < 3) { 14412 return (ENOTTY); 14413 } 14414 14415 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 14416 14417 cdb[0] = (char)SCMD_READ_ATTRIBUTE; 14418 cdb[1] = 0; 14419 cdb[2] = 0; 14420 cdb[3] = 0; 14421 cdb[4] = 0; 14422 cdb[5] = 0; 14423 cdb[6] = 0; 14424 cdb[7] = 0; 14425 cdb[8] = (char)(attribute >> 8); 14426 cdb[9] = (char)(attribute); 14427 cdb[10] = (char)(size >> 24); 14428 cdb[11] = (char)(size >> 16); 14429 cdb[12] = (char)(size >> 8); 14430 cdb[13] = (char)(size); 14431 cdb[14] = 0; 14432 cdb[15] = 0; 14433 14434 14435 cmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE | USCSI_DIAGNOSE; 14436 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 14437 cmd->uscsi_cdb = &cdb[0]; 14438 cmd->uscsi_bufaddr = (caddr_t)buf; 14439 cmd->uscsi_buflen = size; 14440 cmd->uscsi_cdblen = sizeof (cdb); 14441 cmd->uscsi_rqlen = sizeof (status); 14442 cmd->uscsi_rqbuf = (caddr_t)&status; 14443 14444 result = bufunc(un, cmd, FKIOCTL); 14445 14446 if (result != 0 || cmd->uscsi_status != 0) { 14447 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 14448 "st_read_attribute failed: result %d status %d\n", 14449 result, cmd->uscsi_status); 14450 /* 14451 * If this returns invalid operation code don't try again. 14452 */ 14453 if (un->un_sd->sd_sense->es_key == KEY_ILLEGAL_REQUEST && 14454 un->un_sd->sd_sense->es_add_code == 0x20) { 14455 result = ENOTTY; 14456 } else if (result == 0) { 14457 result = EIO; 14458 } 14459 14460 } else { 14461 14462 /* 14463 * The attribute retured should match the attribute requested. 14464 */ 14465 if (buf[4] != cdb[8] || buf[5] != cdb[9]) { 14466 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14467 "st_read_attribute got wrong data back expected " 14468 "0x%x got 0x%x\n", attribute, buf[6] << 8 | buf[7]); 14469 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 14470 "bad? data", buf, size); 14471 result = EIO; 14472 } 14473 } 14474 14475 kmem_free(cmd, sizeof (struct uscsi_cmd)); 14476 14477 return (result); 14478 } 14479 14480 static int 14481 st_get_special_inquiry(struct scsi_tape *un, uchar_t size, caddr_t dest, 14482 uchar_t page) 14483 { 14484 char cdb[CDB_GROUP0]; 14485 struct scsi_extended_sense *sense; 14486 struct uscsi_cmd *cmd; 14487 int result; 14488 14489 ST_FUNC(ST_DEVINFO, st_get_special_inquiry); 14490 14491 cdb[0] = SCMD_INQUIRY; 14492 cdb[1] = page ? 1 : 0; 14493 cdb[2] = page; 14494 cdb[3] = 0; 14495 cdb[4] = size; 14496 cdb[5] = 0; 14497 14498 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 14499 sense = kmem_alloc(sizeof (struct scsi_extended_sense), KM_SLEEP); 14500 14501 cmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE; 14502 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 14503 cmd->uscsi_cdb = &cdb[0]; 14504 cmd->uscsi_bufaddr = dest; 14505 cmd->uscsi_buflen = size; 14506 cmd->uscsi_cdblen = CDB_GROUP0; 14507 cmd->uscsi_rqlen = sizeof (struct scsi_extended_sense); 14508 cmd->uscsi_rqbuf = (caddr_t)sense; 14509 14510 result = st_uscsi_cmd(un, cmd, FKIOCTL); 14511 14512 if (result != 0 || cmd->uscsi_status != 0) { 14513 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14514 "st_get_special_inquiry() failed for page %x", page); 14515 if (result == 0) { 14516 result = EIO; 14517 } 14518 } 14519 14520 kmem_free(sense, sizeof (struct scsi_extended_sense)); 14521 kmem_free(cmd, sizeof (struct uscsi_cmd)); 14522 14523 return (result); 14524 } 14525 14526 14527 static int 14528 st_update_block_pos(struct scsi_tape *un, bufunc_t bf, int post_space) 14529 { 14530 int rval = ENOTTY; 14531 uchar_t status = un->un_status; 14532 posmode previous_pmode = un->un_running.pmode; 14533 14534 ST_FUNC(ST_DEVINFO, st_update_block_pos); 14535 14536 while (un->un_read_pos_type != NO_POS) { 14537 rval = bf(un, SCMD_READ_POSITION, 32, SYNC_CMD); 14538 14539 /* 14540 * If read position command returned good status 14541 * Parse the data to see if the position can be interpreted. 14542 */ 14543 if ((rval == 0) && 14544 ((rval = st_interpret_read_pos(un, &un->un_pos, 14545 un->un_read_pos_type, 32, (caddr_t)un->un_read_pos_data, 14546 post_space)) == 0)) { 14547 /* 14548 * Update the running position as well if un_pos was 14549 * ok. But only if recovery is enabled. 14550 */ 14551 if (st_recov_sz != sizeof (recov_info)) { 14552 break; 14553 } 14554 rval = st_interpret_read_pos(un, &un->un_running, 14555 un->un_read_pos_type, 32, 14556 (caddr_t)un->un_read_pos_data, post_space); 14557 un->un_status = status; 14558 break; 14559 } else if (un->un_status == KEY_UNIT_ATTENTION) { 14560 un->un_running.pmode = previous_pmode; 14561 continue; 14562 } else if (un->un_status != KEY_ILLEGAL_REQUEST) { 14563 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 14564 "st_update_block_pos() read position cmd 0x%x" 14565 " returned 0x%x un_status = %d", 14566 un->un_read_pos_type, rval, un->un_status); 14567 /* ENOTTY means it read garbage. try something else. */ 14568 if (rval == ENOTTY) { 14569 rval = EIO; /* so ENOTTY is not final rval */ 14570 } else { 14571 break; 14572 } 14573 } else { 14574 ST_DEBUG4(ST_DEVINFO, st_label, CE_NOTE, 14575 "st_update_block_pos() read position cmd %x" 14576 " returned %x", un->un_read_pos_type, rval); 14577 un->un_running.pmode = previous_pmode; 14578 } 14579 14580 switch (un->un_read_pos_type) { 14581 case SHORT_POS: 14582 un->un_read_pos_type = NO_POS; 14583 break; 14584 14585 case LONG_POS: 14586 un->un_read_pos_type = EXT_POS; 14587 break; 14588 14589 case EXT_POS: 14590 un->un_read_pos_type = SHORT_POS; 14591 break; 14592 14593 default: 14594 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 14595 "Unexpected read position type 0x%x", 14596 un->un_read_pos_type); 14597 } 14598 un->un_status = KEY_NO_SENSE; 14599 } 14600 14601 return (rval); 14602 } 14603 14604 static int 14605 st_get_read_pos(struct scsi_tape *un, buf_t *bp) 14606 { 14607 int result; 14608 size_t d_sz; 14609 caddr_t pos_info; 14610 struct uscsi_cmd *cmd = (struct uscsi_cmd *)bp->b_back; 14611 14612 ST_FUNC(ST_DEVINFO, st_get_read_pos); 14613 14614 if (cmd->uscsi_bufaddr == NULL || cmd->uscsi_buflen <= 0) { 14615 return (0); 14616 } 14617 14618 if (bp_mapin_common(bp, VM_NOSLEEP) == NULL) { 14619 14620 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14621 "bp_mapin_common() failed"); 14622 14623 return (EIO); 14624 } 14625 14626 d_sz = bp->b_bcount - bp->b_resid; 14627 if (d_sz == 0) { 14628 bp_mapout(bp); 14629 return (EIO); 14630 } 14631 14632 /* 14633 * Copy the buf to a double-word aligned memory that can hold the 14634 * tape_position_t data structure. 14635 */ 14636 if ((pos_info = kmem_alloc(d_sz, KM_NOSLEEP)) == NULL) { 14637 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14638 "kmem_alloc() failed"); 14639 bp_mapout(bp); 14640 return (EIO); 14641 } 14642 bcopy(bp->b_un.b_addr, pos_info, d_sz); 14643 14644 #ifdef STDEBUG 14645 if ((st_debug & 0x7) > 2) { 14646 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 14647 "st_get_read_pos() position info", 14648 pos_info, bp->b_bcount); 14649 } 14650 #endif 14651 14652 result = st_interpret_read_pos(un, &un->un_pos, cmd->uscsi_cdb[1], 14653 d_sz, pos_info, 0); 14654 14655 COPY_POS(&un->un_running, &un->un_pos); 14656 14657 kmem_free(pos_info, d_sz); 14658 bp_mapout(bp); 14659 14660 return (result); 14661 } 14662 14663 #if defined(_BIG_ENDIAN) 14664 14665 #define FIX_ENDIAN16(x) 14666 #define FIX_ENDIAN32(x) 14667 #define FIX_ENDIAN64(x) 14668 14669 #elif defined(_LITTLE_ENDIAN) 14670 14671 static void 14672 st_swap16(uint16_t *val) 14673 { 14674 uint16_t tmp; 14675 14676 tmp = (*val >> 8) & 0xff; 14677 tmp |= (*val << 8) & 0xff00; 14678 14679 *val = tmp; 14680 } 14681 14682 static void 14683 st_swap32(uint32_t *val) 14684 { 14685 uint32_t tmp; 14686 14687 tmp = (*val >> 24) & 0xff; 14688 tmp |= (*val >> 8) & 0xff00; 14689 tmp |= (*val << 8) & 0xff0000; 14690 tmp |= (*val << 24) & 0xff000000; 14691 14692 *val = tmp; 14693 } 14694 14695 static void 14696 st_swap64(uint64_t *val) 14697 { 14698 uint32_t low; 14699 uint32_t high; 14700 14701 low = (uint32_t)(*val); 14702 high = (uint32_t)(*val >> 32); 14703 14704 st_swap32(&low); 14705 st_swap32(&high); 14706 14707 *val = high; 14708 *val |= ((uint64_t)low << 32); 14709 } 14710 14711 #define FIX_ENDIAN16(x) st_swap16(x) 14712 #define FIX_ENDIAN32(x) st_swap32(x) 14713 #define FIX_ENDIAN64(x) st_swap64(x) 14714 #endif 14715 14716 /* 14717 * st_interpret_read_pos() 14718 * 14719 * Returns: 14720 * 0 If secsessful. 14721 * EIO If read postion responce data was unuseable or invalid. 14722 * ERANGE If the position of the drive is too large for the read_p_type. 14723 * ENOTTY If the responce data looks invalid for the read position type. 14724 */ 14725 14726 static int 14727 st_interpret_read_pos(struct scsi_tape const *un, tapepos_t *dest, 14728 read_p_types type, size_t data_sz, const caddr_t responce, int post_space) 14729 { 14730 int rval = 0; 14731 int flag = 0; 14732 tapepos_t org; 14733 14734 ST_FUNC(ST_DEVINFO, st_interpret_read_pos); 14735 14736 /* 14737 * We expect the position value to change after a space command. 14738 * So if post_space is set we don't print out what has changed. 14739 */ 14740 if ((dest != &un->un_pos) && (post_space == 0) && 14741 (st_recov_sz == sizeof (recov_info))) { 14742 COPY_POS(&org, dest); 14743 flag = 1; 14744 } 14745 14746 /* 14747 * See what kind of read position was requested. 14748 */ 14749 switch (type) { 14750 14751 case SHORT_POS: /* Short data format */ 14752 { 14753 tape_position_t *pos_info = (tape_position_t *)responce; 14754 uint32_t value; 14755 14756 /* If reserved fields are non zero don't use the data */ 14757 if (pos_info->reserved0 || pos_info->reserved1 || 14758 pos_info->reserved2[0] || pos_info->reserved2[1] || 14759 pos_info->reserved3) { 14760 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14761 "Invalid Read Short Position Data returned\n"); 14762 rval = EIO; 14763 break; 14764 } 14765 /* 14766 * Position is to large to use this type of read position. 14767 */ 14768 if (pos_info->posi_err == 1) { 14769 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14770 "Drive reported position error\n"); 14771 rval = ERANGE; 14772 break; 14773 } 14774 /* 14775 * If your at the begining of partition and end at the same 14776 * time it's very small partition or bad data. 14777 */ 14778 if (pos_info->begin_of_part && pos_info->end_of_part) { 14779 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14780 "SHORT_POS returned begin and end of" 14781 " partition\n"); 14782 rval = EIO; 14783 break; 14784 } 14785 14786 if (pos_info->blk_posi_unkwn == 0) { 14787 14788 value = pos_info->host_block; 14789 FIX_ENDIAN32(&value); 14790 14791 /* 14792 * If the tape is rewound the host blcok should be 0. 14793 */ 14794 if ((pos_info->begin_of_part == 1) && 14795 (value != 0)) { 14796 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14797 "SHORT_POS returned begin of partition" 14798 " but host block was 0x%x\n", value); 14799 rval = EIO; 14800 break; 14801 } 14802 14803 if (dest->lgclblkno != value) { 14804 if (flag) 14805 flag++; 14806 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14807 "SHORT_POS current logical 0x%"PRIx64" read" 14808 " 0x%x\n", dest->lgclblkno, value); 14809 } 14810 14811 dest->lgclblkno = (uint64_t)value; 14812 14813 /* 14814 * If the begining of partition is true and the 14815 * block number is zero we will beleive that it is 14816 * rewound. Promote the pmode to legacy. 14817 */ 14818 if ((pos_info->begin_of_part == 1) && 14819 (value == 0)) { 14820 dest->blkno = 0; 14821 dest->fileno = 0; 14822 if (dest->pmode != legacy) 14823 dest->pmode = legacy; 14824 /* 14825 * otherwise if the pmode was invalid, 14826 * promote it to logical. 14827 */ 14828 } else if (dest->pmode == invalid) { 14829 dest->pmode = logical; 14830 } 14831 14832 if (dest->partition != pos_info->partition_number) { 14833 if (flag) 14834 flag++; 14835 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14836 "SHORT_POS current partition %d read %d\n", 14837 dest->partition, 14838 pos_info->partition_number); 14839 } 14840 14841 dest->partition = pos_info->partition_number; 14842 14843 } else { 14844 dest->pmode = invalid; 14845 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14846 "Tape drive reported block position as unknown\n"); 14847 } 14848 break; 14849 } 14850 14851 case LONG_POS: /* Long data format */ 14852 { 14853 uint64_t value; 14854 tape_position_long_t *long_pos_info = 14855 (tape_position_long_t *)responce; 14856 14857 /* If reserved fields are non zero don't use the data */ 14858 if ((long_pos_info->reserved0) || 14859 (long_pos_info->reserved1) || 14860 (long_pos_info->reserved2)) { 14861 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14862 "Invalid Read Long Position Data returned\n"); 14863 rval = ENOTTY; 14864 break; 14865 } 14866 14867 /* Is position Valid */ 14868 if (long_pos_info->blk_posi_unkwn == 0) { 14869 uint32_t part; 14870 14871 value = long_pos_info->block_number; 14872 FIX_ENDIAN64(&value); 14873 14874 /* 14875 * If it says we are at the begining of partition 14876 * the block value better be 0. 14877 */ 14878 if ((long_pos_info->begin_of_part == 1) && 14879 (value != 0)) { 14880 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14881 "LONG_POS returned begin of partition but" 14882 " block number was 0x%"PRIx64"\n", value); 14883 rval = ENOTTY; 14884 break; 14885 } 14886 /* 14887 * Can't be at the start and the end of the partition 14888 * at the same time if the partition is larger the 0. 14889 */ 14890 if (long_pos_info->begin_of_part && 14891 long_pos_info->end_of_part) { 14892 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14893 "LONG_POS returned begin and end of" 14894 " partition\n"); 14895 rval = ENOTTY; 14896 break; 14897 } 14898 14899 /* 14900 * If the logical block number is not what we expected. 14901 */ 14902 if (dest->lgclblkno != value) { 14903 if (flag) 14904 flag++; 14905 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14906 "LONG_POS current logical 0x%"PRIx64 14907 " read 0x%"PRIx64"\n", 14908 dest->lgclblkno, value); 14909 } 14910 dest->lgclblkno = value; 14911 14912 /* 14913 * If the begining of partition is true and the 14914 * block number is zero we will beleive that it is 14915 * rewound. Promote the pmode to legacy. 14916 */ 14917 if ((long_pos_info->begin_of_part == 1) && 14918 (long_pos_info->block_number == 0)) { 14919 dest->blkno = 0; 14920 dest->fileno = 0; 14921 if (dest->pmode != legacy) 14922 dest->pmode = legacy; 14923 /* 14924 * otherwise if the pmode was invalid, 14925 * promote it to logical. 14926 */ 14927 } else if (dest->pmode == invalid) { 14928 dest->pmode = logical; 14929 } 14930 14931 part = long_pos_info->partition; 14932 FIX_ENDIAN32(&part); 14933 if (dest->partition != part) { 14934 if (flag) 14935 flag++; 14936 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14937 "LONG_POS current partition %d" 14938 " read %d\n", dest->partition, part); 14939 } 14940 dest->partition = part; 14941 } else { 14942 /* 14943 * If the drive doesn't know location, 14944 * we don't either. 14945 */ 14946 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14947 "Tape drive reported block position as unknown\n"); 14948 dest->pmode = invalid; 14949 } 14950 14951 /* Is file position valid */ 14952 if (long_pos_info->mrk_posi_unkwn == 0) { 14953 value = long_pos_info->file_number; 14954 FIX_ENDIAN64(&value); 14955 /* 14956 * If it says we are at the begining of partition 14957 * the block value better be 0. 14958 */ 14959 if ((long_pos_info->begin_of_part == 1) && 14960 (value != 0)) { 14961 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14962 "LONG_POS returned begin of partition but" 14963 " block number was 0x%"PRIx64"\n", value); 14964 rval = ENOTTY; 14965 break; 14966 } 14967 if (((dest->pmode == legacy) || 14968 (dest->pmode == logical)) && 14969 (dest->fileno != value)) { 14970 if (flag) 14971 flag++; 14972 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14973 "LONG_POS fileno 0x%"PRIx64 14974 " not un_pos %x\n", value, 14975 dest->fileno); 14976 } else if (dest->pmode == invalid) { 14977 dest->pmode = logical; 14978 } 14979 dest->fileno = (int32_t)value; 14980 } 14981 14982 if (dest->pmode != invalid && long_pos_info->end_of_part) { 14983 dest->eof = ST_EOT; 14984 } 14985 14986 break; 14987 } 14988 14989 case EXT_POS: /* Extended data format */ 14990 { 14991 uint64_t value; 14992 uint16_t len; 14993 tape_position_ext_t *ext_pos_info = 14994 (tape_position_ext_t *)responce; 14995 14996 /* Make sure that there is enough data there */ 14997 if (data_sz < 16) { 14998 break; 14999 } 15000 15001 /* If reserved fields are non zero don't use the data */ 15002 if (ext_pos_info->reserved0 || ext_pos_info->reserved1) { 15003 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15004 "EXT_POS reserved fields not zero\n"); 15005 rval = ENOTTY; 15006 break; 15007 } 15008 15009 /* 15010 * In the unlikely event of overflowing 64 bits of position. 15011 */ 15012 if (ext_pos_info->posi_err != 0) { 15013 rval = ERANGE; 15014 break; 15015 } 15016 15017 len = ext_pos_info->parameter_len; 15018 FIX_ENDIAN16(&len); 15019 15020 if (len != 0x1c) { 15021 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15022 "EXT_POS parameter_len should be 0x1c was 0x%x\n", 15023 len); 15024 rval = ENOTTY; 15025 break; 15026 } 15027 15028 /* Is block position information valid */ 15029 if (ext_pos_info->blk_posi_unkwn == 0) { 15030 15031 value = ext_pos_info->host_block; 15032 FIX_ENDIAN64(&value); 15033 if ((ext_pos_info->begin_of_part == 1) && 15034 (value != 0)) { 15035 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15036 "EXT_POS returned begining of partition but" 15037 " the host block was 0x%"PRIx64"\n", value); 15038 rval = ENOTTY; 15039 break; 15040 } 15041 15042 if (dest->lgclblkno != value) { 15043 if (flag) 15044 flag++; 15045 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15046 "EXT_POS current logical 0x%"PRIx64 15047 " read 0x%"PRIx64"\n", 15048 dest->lgclblkno, value); 15049 } 15050 dest->lgclblkno = value; 15051 15052 /* 15053 * If the begining of partition is true and the 15054 * block number is zero we will beleive that it is 15055 * rewound. Promote the pmode to legacy. 15056 */ 15057 if ((ext_pos_info->begin_of_part == 1) && 15058 (ext_pos_info->host_block == 0)) { 15059 dest->blkno = 0; 15060 dest->fileno = 0; 15061 if (dest->pmode != legacy) { 15062 dest->pmode = legacy; 15063 } 15064 /* 15065 * otherwise if the pmode was invalid, 15066 * promote it to logical. 15067 */ 15068 } else if (dest->pmode == invalid) { 15069 dest->pmode = logical; 15070 } 15071 15072 if (dest->partition != ext_pos_info->partition) { 15073 if (flag) 15074 flag++; 15075 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15076 "EXT_POS current partition %d read %d\n", 15077 dest->partition, 15078 ext_pos_info->partition); 15079 } 15080 dest->partition = ext_pos_info->partition; 15081 15082 } else { 15083 dest->pmode = invalid; 15084 } 15085 break; 15086 } 15087 15088 default: 15089 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 15090 "Got unexpected SCMD_READ_POSITION type %d\n", type); 15091 rval = EIO; 15092 } 15093 15094 if ((flag > 1) && (rval == 0) && (org.pmode != invalid)) { 15095 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 15096 "position read in", &org); 15097 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 15098 "position read out", dest); 15099 } 15100 15101 return (rval); 15102 } 15103 15104 static int 15105 st_logical_block_locate(struct scsi_tape *un, ubufunc_t ubf, tapepos_t *pos, 15106 uint64_t lblk, uchar_t partition) 15107 { 15108 int rval; 15109 char cdb[CDB_GROUP4]; 15110 struct uscsi_cmd *cmd; 15111 struct scsi_extended_sense sense; 15112 bufunc_t bf = (ubf == st_uscsi_cmd) ? st_cmd : st_rcmd; 15113 15114 ST_FUNC(ST_DEVINFO, st_logical_block_locate); 15115 /* 15116 * Not sure what to do when doing recovery and not wanting 15117 * to update un_pos 15118 */ 15119 15120 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 15121 15122 if (lblk <= INT32_MAX) { 15123 cmd->uscsi_cdblen = CDB_GROUP1; 15124 cdb[0] = SCMD_LOCATE; 15125 cdb[1] = pos->partition == partition ? 0 : 2; 15126 cdb[2] = 0; 15127 cdb[3] = (char)(lblk >> 24); 15128 cdb[4] = (char)(lblk >> 16); 15129 cdb[5] = (char)(lblk >> 8); 15130 cdb[6] = (char)(lblk); 15131 cdb[7] = 0; 15132 cdb[8] = partition; 15133 cdb[9] = 0; 15134 } else { 15135 /* 15136 * If the drive doesn't give a 64 bit read position data 15137 * it is unlikely it will accept 64 bit locates. 15138 */ 15139 if (un->un_read_pos_type != LONG_POS) { 15140 kmem_free(cmd, sizeof (struct uscsi_cmd)); 15141 return (ERANGE); 15142 } 15143 cmd->uscsi_cdblen = CDB_GROUP4; 15144 cdb[0] = (char)SCMD_LOCATE_G4; 15145 cdb[1] = pos->partition == partition ? 0 : 2; 15146 cdb[2] = 0; 15147 cdb[3] = partition; 15148 cdb[4] = (char)(lblk >> 56); 15149 cdb[5] = (char)(lblk >> 48); 15150 cdb[6] = (char)(lblk >> 40); 15151 cdb[7] = (char)(lblk >> 32); 15152 cdb[8] = (char)(lblk >> 24); 15153 cdb[9] = (char)(lblk >> 16); 15154 cdb[10] = (char)(lblk >> 8); 15155 cdb[11] = (char)(lblk); 15156 cdb[12] = 0; 15157 cdb[13] = 0; 15158 cdb[14] = 0; 15159 cdb[15] = 0; 15160 } 15161 15162 15163 cmd->uscsi_flags = USCSI_WRITE | USCSI_DIAGNOSE | USCSI_RQENABLE; 15164 cmd->uscsi_rqbuf = (caddr_t)&sense; 15165 cmd->uscsi_rqlen = sizeof (sense); 15166 cmd->uscsi_timeout = un->un_dp->space_timeout; 15167 cmd->uscsi_cdb = cdb; 15168 15169 rval = ubf(un, cmd, FKIOCTL); 15170 15171 pos->pmode = logical; 15172 pos->eof = ST_NO_EOF; 15173 15174 if (lblk > INT32_MAX) { 15175 /* 15176 * XXX This is a work around till we handle Descriptor format 15177 * sense data. Since we are sending a command where the standard 15178 * sense data can not correctly represent a correct residual in 15179 * 4 bytes. 15180 */ 15181 if (un->un_status == KEY_ILLEGAL_REQUEST) { 15182 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15183 "Big LOCATE ILLEGAL_REQUEST: rval = %d\n", rval); 15184 /* Doesn't like big locate command */ 15185 un->un_status = 0; 15186 rval = ERANGE; 15187 } else if ((un->un_pos.pmode == invalid) || (rval != 0)) { 15188 /* Aborted big locate command */ 15189 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15190 "Big LOCATE resulted in invalid pos: rval = %d\n", 15191 rval); 15192 un->un_status = 0; 15193 rval = EIO; 15194 } else if (st_update_block_pos(un, bf, 1)) { 15195 /* read position failed */ 15196 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15197 "Big LOCATE and read pos: rval = %d\n", rval); 15198 rval = EIO; 15199 } else if (lblk > un->un_pos.lgclblkno) { 15200 /* read position worked but position was not expected */ 15201 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15202 "Big LOCATE and recover read less then desired 0x%" 15203 PRIx64"\n", un->un_pos.lgclblkno); 15204 un->un_err_resid = lblk - un->un_pos.lgclblkno; 15205 un->un_status = KEY_BLANK_CHECK; 15206 rval = ESPIPE; 15207 } else if (lblk == un->un_pos.lgclblkno) { 15208 /* read position was what was expected */ 15209 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15210 "Big LOCATE and recover seems to have worked\n"); 15211 un->un_err_resid = 0; 15212 rval = 0; 15213 } else { 15214 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 15215 "BIGLOCATE end up going backwards"); 15216 un->un_err_resid = lblk; 15217 rval = EIO; 15218 } 15219 15220 } else if (rval == 0) { 15221 /* Worked as requested */ 15222 pos->lgclblkno = lblk; 15223 15224 } else if (((cmd->uscsi_status & ST_STATUS_MASK) == STATUS_CHECK) && 15225 (cmd->uscsi_resid != 0)) { 15226 /* Got part way there but wasn't enough blocks on tape */ 15227 pos->lgclblkno = lblk - cmd->uscsi_resid; 15228 un->un_err_resid = cmd->uscsi_resid; 15229 un->un_status = KEY_BLANK_CHECK; 15230 rval = ESPIPE; 15231 15232 } else if (st_update_block_pos(un, bf, 1) == 0) { 15233 /* Got part way there but drive didn't tell what we missed by */ 15234 un->un_err_resid = lblk - pos->lgclblkno; 15235 un->un_status = KEY_BLANK_CHECK; 15236 rval = ESPIPE; 15237 15238 } else { 15239 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 15240 "Failed LOCATE and recover pos: rval = %d status = %d\n", 15241 rval, cmd->uscsi_status); 15242 un->un_err_resid = lblk; 15243 un->un_status = KEY_ILLEGAL_REQUEST; 15244 pos->pmode = invalid; 15245 rval = EIO; 15246 } 15247 15248 kmem_free(cmd, sizeof (struct uscsi_cmd)); 15249 15250 return (rval); 15251 } 15252 15253 static int 15254 st_mtfsf_ioctl(struct scsi_tape *un, int64_t files) 15255 { 15256 int rval; 15257 15258 ST_FUNC(ST_DEVINFO, st_mtfsf_ioctl); 15259 15260 15261 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15262 "st_mtfsf_ioctl: count=%"PRIx64", eof=%x\n", files, un->un_pos.eof); 15263 #if 0 15264 if ((IN_EOF(un->un_pos)) && (files == 1)) { 15265 un->un_pos.fileno++; 15266 un->un_pos.blkno = 0; 15267 return (0); 15268 } 15269 #endif 15270 /* pmode == invalid already handled */ 15271 if (un->un_pos.pmode == legacy) { 15272 /* 15273 * forward space over filemark 15274 * 15275 * For ASF we allow a count of 0 on fsf which means 15276 * we just want to go to beginning of current file. 15277 * Equivalent to "nbsf(0)" or "bsf(1) + fsf". 15278 * Allow stepping over double fmk with reel 15279 */ 15280 if ((un->un_pos.eof >= ST_EOT) && 15281 (files > 0) && 15282 ((un->un_dp->options & ST_REEL) == 0)) { 15283 /* we're at EOM */ 15284 un->un_err_resid = files; 15285 un->un_status = KEY_BLANK_CHECK; 15286 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15287 "st_mtfsf_ioctl: EIO : MTFSF at EOM"); 15288 return (EIO); 15289 } 15290 15291 /* 15292 * physical tape position may not be what we've been 15293 * telling the user; adjust the request accordingly 15294 */ 15295 if (IN_EOF(un->un_pos)) { 15296 un->un_pos.fileno++; 15297 un->un_pos.blkno = 0; 15298 /* 15299 * For positive direction case, we're now covered. 15300 * For zero or negative direction, we're covered 15301 * (almost) 15302 */ 15303 files--; 15304 } 15305 15306 } 15307 15308 if (st_check_density_or_wfm(un->un_dev, 1, B_READ, STEPBACK)) { 15309 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15310 "st_mtfsf_ioctl: EIO : MTFSF density/wfm failed"); 15311 return (EIO); 15312 } 15313 15314 15315 /* 15316 * Forward space file marks. 15317 * We leave ourselves at block zero 15318 * of the target file number. 15319 */ 15320 if (files < 0) { 15321 rval = st_backward_space_files(un, -files, 0); 15322 } else { 15323 rval = st_forward_space_files(un, files); 15324 } 15325 15326 return (rval); 15327 } 15328 15329 static int 15330 st_forward_space_files(struct scsi_tape *un, int64_t count) 15331 { 15332 int rval; 15333 15334 ST_FUNC(ST_DEVINFO, st_forward_space_files); 15335 15336 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15337 "fspace: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof); 15338 15339 ASSERT(count >= 0); 15340 ASSERT(un->un_pos.pmode != invalid); 15341 15342 /* 15343 * A space with a count of zero means take me to the start of file. 15344 */ 15345 if (count == 0) { 15346 15347 /* Hay look were already there */ 15348 if (un->un_pos.pmode == legacy && un->un_pos.blkno == 0) { 15349 un->un_err_resid = 0; 15350 COPY_POS(&un->un_err_pos, &un->un_pos); 15351 return (0); 15352 } 15353 15354 /* 15355 * Well we are in the first file. 15356 * A rewind will get to the start. 15357 */ 15358 if (un->un_pos.pmode == legacy && un->un_pos.fileno == 0) { 15359 rval = st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 15360 15361 /* 15362 * Can we backspace to get there? 15363 * This should work in logical mode. 15364 */ 15365 } else if (un->un_dp->options & ST_BSF) { 15366 rval = st_space_to_begining_of_file(un); 15367 15368 /* 15369 * Can't back space but current file number is known, 15370 * So rewind and space from the begining of the partition. 15371 */ 15372 } else if (un->un_pos.pmode == legacy) { 15373 rval = st_scenic_route_to_begining_of_file(un, 15374 un->un_pos.fileno); 15375 15376 /* 15377 * pmode is logical and ST_BSF is not set. 15378 * The LONG_POS read position contains the fileno. 15379 * If the read position works, rewind and space. 15380 */ 15381 } else if (un->un_read_pos_type == LONG_POS) { 15382 rval = st_cmd(un, SCMD_READ_POSITION, 0, SYNC_CMD); 15383 if (rval) { 15384 /* 15385 * We didn't get the file position from the 15386 * read position command. 15387 * We are going to trust the drive to backspace 15388 * and then position after the filemark. 15389 */ 15390 rval = st_space_to_begining_of_file(un); 15391 } 15392 rval = st_interpret_read_pos(un, &un->un_pos, LONG_POS, 15393 32, (caddr_t)un->un_read_pos_data, 0); 15394 if ((rval) && (un->un_pos.pmode == invalid)) { 15395 rval = st_space_to_begining_of_file(un); 15396 } else { 15397 rval = st_scenic_route_to_begining_of_file(un, 15398 un->un_pos.fileno); 15399 } 15400 } else { 15401 rval = EIO; 15402 } 15403 /* 15404 * If something didn't work we are lost 15405 */ 15406 if (rval != 0) { 15407 un->un_pos.pmode = invalid; 15408 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15409 "st_mtioctop : EIO : fspace pmode invalid"); 15410 15411 rval = EIO; 15412 } 15413 15414 } else { 15415 rval = st_space_fmks(un, count); 15416 } 15417 15418 if (rval != EIO && count < 0) { 15419 /* 15420 * we came here with a count < 0; we now need 15421 * to skip back to end up before the filemark 15422 */ 15423 rval = st_backward_space_files(un, 1, 1); 15424 } 15425 15426 return (rval); 15427 } 15428 15429 static int 15430 st_scenic_route_to_begining_of_file(struct scsi_tape *un, int32_t fileno) 15431 { 15432 int rval; 15433 15434 ST_FUNC(ST_DEVINFO, st_scenic_route_to_begining_of_file); 15435 15436 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 15437 rval = EIO; 15438 } else if (st_cmd(un, SCMD_SPACE, Fmk(fileno), SYNC_CMD)) { 15439 rval = EIO; 15440 } 15441 15442 return (rval); 15443 } 15444 15445 static int 15446 st_space_to_begining_of_file(struct scsi_tape *un) 15447 { 15448 int rval; 15449 15450 ST_FUNC(ST_DEVINFO, st_space_to_begining_of_file); 15451 15452 /* 15453 * Back space of the file at the begining of the file. 15454 */ 15455 rval = st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD); 15456 if (rval) { 15457 rval = EIO; 15458 return (rval); 15459 } 15460 15461 /* 15462 * Other interesting answers might be crashed BOT which isn't bad. 15463 */ 15464 if (un->un_status == SUN_KEY_BOT) { 15465 return (rval); 15466 } 15467 15468 un->un_running.pmode = invalid; 15469 15470 /* 15471 * Now we are on the BOP side of the filemark. Forward space to 15472 * the EOM side and we are at the begining of the file. 15473 */ 15474 rval = st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD); 15475 if (rval) { 15476 rval = EIO; 15477 } 15478 15479 return (rval); 15480 } 15481 15482 static int 15483 st_mtfsr_ioctl(struct scsi_tape *un, int64_t count) 15484 { 15485 15486 ST_FUNC(ST_DEVINFO, st_mtfsr_ioctl); 15487 15488 /* 15489 * forward space to inter-record gap 15490 * 15491 */ 15492 15493 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15494 "st_ioctl_fsr: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof); 15495 15496 if (un->un_pos.pmode == legacy) { 15497 /* 15498 * If were are at end of tape and count is forward. 15499 * Return blank check. 15500 */ 15501 if ((un->un_pos.eof >= ST_EOT) && (count > 0)) { 15502 /* we're at EOM */ 15503 un->un_err_resid = count; 15504 un->un_status = KEY_BLANK_CHECK; 15505 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15506 "st_mtfsr_ioctl: EIO : MTFSR eof > ST_EOT"); 15507 return (EIO); 15508 } 15509 15510 /* 15511 * If count is zero there is nothing to do. 15512 */ 15513 if (count == 0) { 15514 un->un_err_pos.fileno = un->un_pos.fileno; 15515 un->un_err_pos.blkno = un->un_pos.blkno; 15516 un->un_err_resid = 0; 15517 if (IN_EOF(un->un_pos) && SVR4_BEHAVIOR) { 15518 un->un_status = SUN_KEY_EOF; 15519 } 15520 return (0); 15521 } 15522 15523 /* 15524 * physical tape position may not be what we've been 15525 * telling the user; adjust the position accordingly 15526 */ 15527 if (IN_EOF(un->un_pos)) { 15528 daddr_t blkno = un->un_pos.blkno; 15529 int fileno = un->un_pos.fileno; 15530 15531 optype lastop = un->un_lastop; 15532 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD) 15533 == -1) { 15534 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15535 "st_mtfsr_ioctl:EIO:MTFSR count && IN_EOF"); 15536 return (EIO); 15537 } 15538 15539 un->un_pos.blkno = blkno; 15540 un->un_pos.fileno = fileno; 15541 un->un_lastop = lastop; 15542 } 15543 } 15544 15545 if (st_check_density_or_wfm(un->un_dev, 1, B_READ, STEPBACK)) { 15546 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15547 "st_mtfsr_ioctl: EIO : MTFSR st_check_den"); 15548 return (EIO); 15549 } 15550 15551 return (st_space_records(un, count)); 15552 } 15553 15554 static int 15555 st_space_records(struct scsi_tape *un, int64_t count) 15556 { 15557 int64_t dblk; 15558 int rval = 0; 15559 15560 ST_FUNC(ST_DEVINFO, st_space_records); 15561 15562 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15563 "st_space_records: count=%"PRIx64", eof=%x\n", 15564 count, un->un_pos.eof); 15565 15566 if (un->un_pos.pmode == logical) { 15567 rval = st_cmd(un, SCMD_SPACE, Blk(count), SYNC_CMD); 15568 if (rval != 0) { 15569 rval = EIO; 15570 } 15571 return (rval); 15572 } 15573 15574 dblk = count + un->un_pos.blkno; 15575 15576 /* Already there */ 15577 if (dblk == un->un_pos.blkno) { 15578 un->un_err_resid = 0; 15579 COPY_POS(&un->un_err_pos, &un->un_pos); 15580 return (0); 15581 } 15582 15583 /* 15584 * If the destination block is forward 15585 * or the drive will backspace records. 15586 */ 15587 if (un->un_pos.blkno < dblk || (un->un_dp->options & ST_BSR)) { 15588 /* 15589 * If we're spacing forward, or the device can 15590 * backspace records, we can just use the SPACE 15591 * command. 15592 */ 15593 dblk -= un->un_pos.blkno; 15594 if (st_cmd(un, SCMD_SPACE, Blk(dblk), SYNC_CMD)) { 15595 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15596 "st_space_records:EIO:space_records can't spc"); 15597 rval = EIO; 15598 } else if (un->un_pos.eof >= ST_EOF_PENDING) { 15599 /* 15600 * check if we hit BOT/EOT 15601 */ 15602 if (dblk < 0 && un->un_pos.eof == ST_EOM) { 15603 un->un_status = SUN_KEY_BOT; 15604 un->un_pos.eof = ST_NO_EOF; 15605 } else if (dblk < 0 && 15606 un->un_pos.eof == ST_EOF_PENDING) { 15607 int residue = un->un_err_resid; 15608 /* 15609 * we skipped over a filemark 15610 * and need to go forward again 15611 */ 15612 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 15613 ST_DEBUG2(ST_DEVINFO, st_label, 15614 SCSI_DEBUG, "st_space_records: EIO" 15615 " : can't space #2"); 15616 rval = EIO; 15617 } 15618 un->un_err_resid = residue; 15619 } 15620 if (rval == 0) { 15621 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15622 "st_space_records: EIO : space_rec rval" 15623 " == 0"); 15624 rval = EIO; 15625 } 15626 } 15627 } else { 15628 /* 15629 * else we rewind, space forward across filemarks to 15630 * the desired file, and then space records to the 15631 * desired block. 15632 */ 15633 15634 int dfile = un->un_pos.fileno; /* save current file */ 15635 15636 if (dblk < 0) { 15637 /* 15638 * Wups - we're backing up over a filemark 15639 */ 15640 if (un->un_pos.blkno != 0 && 15641 (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 15642 st_cmd(un, SCMD_SPACE, Fmk(dfile), SYNC_CMD))) { 15643 un->un_pos.pmode = invalid; 15644 } 15645 un->un_err_resid = -dblk; 15646 if (un->un_pos.fileno == 0 && un->un_pos.blkno == 0) { 15647 un->un_status = SUN_KEY_BOT; 15648 un->un_pos.eof = ST_NO_EOF; 15649 } else if (un->un_pos.fileno > 0) { 15650 un->un_status = SUN_KEY_EOF; 15651 un->un_pos.eof = ST_NO_EOF; 15652 } 15653 COPY_POS(&un->un_err_pos, &un->un_pos); 15654 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15655 "st_space_records:EIO:space_records : dblk < 0"); 15656 rval = EIO; 15657 } else if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 15658 st_cmd(un, SCMD_SPACE, Fmk(dfile), SYNC_CMD) || 15659 st_cmd(un, SCMD_SPACE, Blk(dblk), SYNC_CMD)) { 15660 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15661 "st_space_records: EIO :space_records : rewind " 15662 "and space failed"); 15663 un->un_pos.pmode = invalid; 15664 rval = EIO; 15665 } 15666 } 15667 15668 return (rval); 15669 } 15670 15671 static int 15672 st_mtbsf_ioctl(struct scsi_tape *un, int64_t files) 15673 { 15674 ST_FUNC(ST_DEVINFO, st_mtbsf_ioctl); 15675 15676 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15677 "st_mtbsf_ioctl: count=%"PRIx64", eof=%x\n", files, un->un_pos.eof); 15678 /* 15679 * backward space of file filemark (1/2" and 8mm) 15680 * tape position will end on the beginning of tape side 15681 * of the desired file mark 15682 */ 15683 if ((un->un_dp->options & ST_BSF) == 0) { 15684 return (ENOTTY); 15685 } 15686 15687 if (un->un_pos.pmode == legacy) { 15688 15689 /* 15690 * If a negative count (which implies a forward space op) 15691 * is specified, and we're at logical or physical eot, 15692 * bounce the request. 15693 */ 15694 15695 if (un->un_pos.eof >= ST_EOT && files < 0) { 15696 un->un_err_resid = files; 15697 un->un_status = SUN_KEY_EOT; 15698 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15699 "st_ioctl_mt_bsf : EIO : MTBSF : eof > ST_EOF"); 15700 return (EIO); 15701 } 15702 /* 15703 * physical tape position may not be what we've been 15704 * telling the user; adjust the request accordingly 15705 */ 15706 if (IN_EOF(un->un_pos)) { 15707 un->un_pos.fileno++; 15708 un->un_pos.blkno = 0; 15709 files++; 15710 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15711 "st_mtbsf_ioctl in eof: count=%"PRIx64", op=%x\n", 15712 files, MTBSF); 15713 15714 } 15715 } 15716 15717 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 15718 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15719 "st_ioctl : EIO : MTBSF : check den wfm"); 15720 return (EIO); 15721 } 15722 15723 if (files <= 0) { 15724 /* 15725 * for a negative count, we need to step forward 15726 * first and then step back again 15727 */ 15728 files = -files + 1; 15729 return (st_forward_space_files(un, files)); 15730 } 15731 return (st_backward_space_files(un, files, 1)); 15732 } 15733 15734 static int 15735 st_backward_space_files(struct scsi_tape *un, int64_t count, int infront) 15736 { 15737 int64_t end_fileno; 15738 int64_t skip_cnt; 15739 int rval = 0; 15740 15741 ST_FUNC(ST_DEVINFO, st_backward_space_files); 15742 15743 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15744 "st_backward_space_files: count=%"PRIx64" eof=%x\n", 15745 count, un->un_pos.eof); 15746 /* 15747 * Backspace files (MTNBSF): infront == 0 15748 * 15749 * For tapes that can backspace, backspace 15750 * count+1 filemarks and then run forward over 15751 * a filemark 15752 * 15753 * For tapes that can't backspace, 15754 * calculate desired filenumber 15755 * (un->un_pos.fileno - count), rewind, 15756 * and then space forward this amount 15757 * 15758 * Backspace filemarks (MTBSF) infront == 1 15759 * 15760 * For tapes that can backspace, backspace count 15761 * filemarks 15762 * 15763 * For tapes that can't backspace, calculate 15764 * desired filenumber (un->un_pos.fileno - count), 15765 * add 1, rewind, space forward this amount, 15766 * and mark state as ST_EOF_PENDING appropriately. 15767 */ 15768 15769 if (un->un_pos.pmode == logical) { 15770 15771 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15772 "st_backward_space_files: mt_op=%x count=%"PRIx64 15773 "lgclblkno=%"PRIx64"\n", infront?MTBSF:MTNBSF, count, 15774 un->un_pos.lgclblkno); 15775 15776 15777 /* In case a drive that won't back space gets in logical mode */ 15778 if ((un->un_dp->options & ST_BSF) == 0) { 15779 rval = EIO; 15780 return (rval); 15781 } 15782 if ((infront == 1) && 15783 (st_cmd(un, SCMD_SPACE, Fmk(-count), SYNC_CMD))) { 15784 rval = EIO; 15785 return (rval); 15786 } else if ((infront == 0) && 15787 (st_cmd(un, SCMD_SPACE, Fmk((-count)-1), SYNC_CMD)) && 15788 (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD))) { 15789 rval = EIO; 15790 return (rval); 15791 } 15792 return (rval); 15793 } 15794 15795 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15796 "st_backward_space_files: mt_op=%x count=%"PRIx64 15797 "fileno=%x blkno=%x\n", 15798 infront?MTBSF:MTNBSF, count, un->un_pos.fileno, un->un_pos.blkno); 15799 15800 15801 15802 /* 15803 * Handle the simple case of BOT 15804 * playing a role in these cmds. 15805 * We do this by calculating the 15806 * ending file number. If the ending 15807 * file is < BOT, rewind and set an 15808 * error and mark resid appropriately. 15809 * If we're backspacing a file (not a 15810 * filemark) and the target file is 15811 * the first file on the tape, just 15812 * rewind. 15813 */ 15814 15815 /* figure expected destination of this SPACE command */ 15816 end_fileno = un->un_pos.fileno - count; 15817 15818 /* 15819 * Would the end effect of this SPACE be the same as rewinding? 15820 * If so just rewind instead. 15821 */ 15822 if ((infront != 0) && (end_fileno < 0) || 15823 (infront == 0) && (end_fileno <= 0)) { 15824 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 15825 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15826 "st_backward_space_files: EIO : " 15827 "rewind in lou of BSF failed\n"); 15828 rval = EIO; 15829 } 15830 if (end_fileno < 0) { 15831 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15832 "st_backward_space_files: EIO : " 15833 "back space file greater then fileno\n"); 15834 rval = EIO; 15835 un->un_err_resid = -end_fileno; 15836 un->un_status = SUN_KEY_BOT; 15837 } 15838 return (rval); 15839 } 15840 15841 if (un->un_dp->options & ST_BSF) { 15842 skip_cnt = 1 - infront; 15843 /* 15844 * If we are going to end up at the beginning 15845 * of the file, we have to space one extra file 15846 * first, and then space forward later. 15847 */ 15848 end_fileno = -(count + skip_cnt); 15849 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 15850 "skip_cnt=%"PRIx64", tmp=%"PRIx64"\n", 15851 skip_cnt, end_fileno); 15852 if (st_cmd(un, SCMD_SPACE, Fmk(end_fileno), SYNC_CMD)) { 15853 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15854 "st_backward_space_files:EIO:back space fm failed"); 15855 rval = EIO; 15856 } 15857 } else { 15858 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 15859 rval = EIO; 15860 } else { 15861 skip_cnt = end_fileno + infront; 15862 } 15863 } 15864 15865 /* 15866 * If we have to space forward, do so... 15867 */ 15868 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 15869 "space forward skip_cnt=%"PRIx64", rval=%x\n", skip_cnt, rval); 15870 15871 if (rval == 0 && skip_cnt) { 15872 if (st_cmd(un, SCMD_SPACE, Fmk(skip_cnt), SYNC_CMD)) { 15873 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15874 "st_backward_space_files:EIO:space fm skip count"); 15875 rval = EIO; 15876 } else if (infront) { 15877 /* 15878 * If we had to space forward, and we're 15879 * not a tape that can backspace, mark state 15880 * as if we'd just seen a filemark during a 15881 * a read. 15882 */ 15883 if ((un->un_dp->options & ST_BSF) == 0) { 15884 un->un_pos.eof = ST_EOF_PENDING; 15885 un->un_pos.fileno -= 1; 15886 un->un_pos.blkno = LASTBLK; 15887 un->un_running.pmode = invalid; 15888 } 15889 } 15890 } 15891 15892 if (rval != 0) { 15893 un->un_pos.pmode = invalid; 15894 } 15895 15896 return (rval); 15897 } 15898 15899 static int 15900 st_mtnbsf_ioctl(struct scsi_tape *un, int64_t count) 15901 { 15902 int rval; 15903 15904 ST_FUNC(ST_DEVINFO, st_mtnbsf_ioctl); 15905 15906 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15907 "nbsf: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof); 15908 15909 if (un->un_pos.pmode == legacy) { 15910 /* 15911 * backward space file to beginning of file 15912 * 15913 * If a negative count (which implies a forward space op) 15914 * is specified, and we're at logical or physical eot, 15915 * bounce the request. 15916 */ 15917 15918 if (un->un_pos.eof >= ST_EOT && count < 0) { 15919 un->un_err_resid = count; 15920 un->un_status = SUN_KEY_EOT; 15921 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15922 "st_ioctl : EIO : > EOT and count < 0"); 15923 return (EIO); 15924 } 15925 /* 15926 * physical tape position may not be what we've been 15927 * telling the user; adjust the request accordingly 15928 */ 15929 if (IN_EOF(un->un_pos)) { 15930 un->un_pos.fileno++; 15931 un->un_pos.blkno = 0; 15932 count++; 15933 } 15934 } 15935 15936 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 15937 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15938 "st_ioctl : EIO : MTNBSF check den and wfm"); 15939 return (EIO); 15940 } 15941 15942 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15943 "mtnbsf: count=%"PRIx64", eof=%x\n", count, un->un_pos.eof); 15944 15945 if (count <= 0) { 15946 rval = st_forward_space_files(un, -count); 15947 } else { 15948 rval = st_backward_space_files(un, count, 0); 15949 } 15950 return (rval); 15951 } 15952 15953 static int 15954 st_mtbsr_ioctl(struct scsi_tape *un, int64_t num) 15955 { 15956 ST_FUNC(ST_DEVINFO, st_mtbsr_ioctl); 15957 15958 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15959 "bsr: count=%"PRIx64", eof=%x\n", num, un->un_pos.eof); 15960 15961 if (un->un_pos.pmode == legacy) { 15962 /* 15963 * backward space into inter-record gap 15964 * 15965 * If a negative count (which implies a forward space op) 15966 * is specified, and we're at logical or physical eot, 15967 * bounce the request. 15968 */ 15969 if (un->un_pos.eof >= ST_EOT && num < 0) { 15970 un->un_err_resid = num; 15971 un->un_status = SUN_KEY_EOT; 15972 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15973 "st_ioctl : EIO : MTBSR > EOT"); 15974 return (EIO); 15975 } 15976 15977 if (num == 0) { 15978 COPY_POS(&un->un_err_pos, &un->un_pos); 15979 un->un_err_resid = 0; 15980 if (IN_EOF(un->un_pos) && SVR4_BEHAVIOR) { 15981 un->un_status = SUN_KEY_EOF; 15982 } 15983 return (0); 15984 } 15985 15986 /* 15987 * physical tape position may not be what we've been 15988 * telling the user; adjust the position accordingly. 15989 * bsr can not skip filemarks and continue to skip records 15990 * therefore if we are logically before the filemark but 15991 * physically at the EOT side of the filemark, we need to step 15992 * back; this allows fsr N where N > number of blocks in file 15993 * followed by bsr 1 to position at the beginning of last block 15994 */ 15995 if (IN_EOF(un->un_pos)) { 15996 tapepos_t save; 15997 optype lastop = un->un_lastop; 15998 15999 COPY_POS(&save, &un->un_pos); 16000 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD) == -1) { 16001 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16002 "st_mtbsr_ioctl: EIO : MTBSR can't space"); 16003 return (EIO); 16004 } 16005 16006 COPY_POS(&un->un_pos, &save); 16007 un->un_lastop = lastop; 16008 } 16009 } 16010 16011 un->un_pos.eof = ST_NO_EOF; 16012 16013 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 16014 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16015 "st_ioctl : EIO : MTBSR : can't set density or wfm"); 16016 return (EIO); 16017 } 16018 16019 num = -num; 16020 return (st_space_records(un, num)); 16021 } 16022 16023 static int 16024 st_mtfsfm_ioctl(struct scsi_tape *un, int64_t cnt) 16025 { 16026 int rval; 16027 16028 ST_FUNC(ST_DEVINFO, st_mtfsfm_ioctl); 16029 16030 rval = st_cmd(un, SCMD_SPACE, SPACE(SP_SQFLM, cnt), SYNC_CMD); 16031 if (rval == 0) { 16032 un->un_pos.pmode = logical; 16033 } else if ((un->un_status == KEY_ILLEGAL_REQUEST) && 16034 (un->un_sd->sd_sense->es_add_code == 0x24)) { 16035 /* 16036 * Drive says invalid field in cdb. 16037 * Doesn't like space multiple. Position isn't lost. 16038 */ 16039 un->un_err_resid = cnt; 16040 un->un_status = 0; 16041 rval = ENOTTY; 16042 } else { 16043 un->un_err_resid = cnt; 16044 un->un_pos.pmode = invalid; 16045 } 16046 return (rval); 16047 } 16048 16049 static int 16050 st_mtbsfm_ioctl(struct scsi_tape *un, int64_t cnt) 16051 { 16052 int rval; 16053 16054 ST_FUNC(ST_DEVINFO, st_mtbsfm_ioctl); 16055 16056 rval = st_cmd(un, SCMD_SPACE, SPACE(SP_SQFLM, -cnt), SYNC_CMD); 16057 if (rval == 0) { 16058 un->un_pos.pmode = logical; 16059 } else if ((un->un_status == KEY_ILLEGAL_REQUEST) && 16060 (un->un_sd->sd_sense->es_add_code == 0x24)) { 16061 /* 16062 * Drive says invalid field in cdb. 16063 * Doesn't like space multiple. Position isn't lost. 16064 */ 16065 un->un_err_resid = cnt; 16066 un->un_status = 0; 16067 rval = ENOTTY; 16068 } else { 16069 un->un_err_resid = cnt; 16070 un->un_pos.pmode = invalid; 16071 } 16072 return (rval); 16073 } 16074 16075 #ifdef __x86 16076 16077 /* 16078 * release contig_mem and wake up waiting thread, if any 16079 */ 16080 static void 16081 st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp) 16082 { 16083 mutex_enter(ST_MUTEX); 16084 16085 ST_FUNC(ST_DEVINFO, st_release_contig_mem); 16086 16087 cp->cm_next = un->un_contig_mem; 16088 un->un_contig_mem = cp; 16089 un->un_contig_mem_available_num++; 16090 cv_broadcast(&un->un_contig_mem_cv); 16091 16092 mutex_exit(ST_MUTEX); 16093 } 16094 16095 /* 16096 * St_get_contig_mem will return a contig_mem if there is one available 16097 * in current system. Otherwise, it will try to alloc one, if the total 16098 * number of contig_mem is within st_max_contig_mem_num. 16099 * It will sleep, if allowed by caller or return NULL, if no contig_mem 16100 * is available for now. 16101 */ 16102 static struct contig_mem * 16103 st_get_contig_mem(struct scsi_tape *un, size_t len, int alloc_flags) 16104 { 16105 size_t rlen; 16106 struct contig_mem *cp = NULL; 16107 ddi_acc_handle_t acc_hdl; 16108 caddr_t addr; 16109 int big_enough = 0; 16110 int (*dma_alloc_cb)() = (alloc_flags == KM_SLEEP) ? 16111 DDI_DMA_SLEEP : DDI_DMA_DONTWAIT; 16112 16113 /* Try to get one available contig_mem */ 16114 mutex_enter(ST_MUTEX); 16115 16116 ST_FUNC(ST_DEVINFO, st_get_contig_mem); 16117 16118 if (un->un_contig_mem_available_num > 0) { 16119 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 16120 } else if (un->un_contig_mem_total_num < st_max_contig_mem_num) { 16121 /* 16122 * we failed to get one. we're going to 16123 * alloc one more contig_mem for this I/O 16124 */ 16125 mutex_exit(ST_MUTEX); 16126 cp = (struct contig_mem *)kmem_zalloc( 16127 sizeof (struct contig_mem) + biosize(), 16128 alloc_flags); 16129 if (cp == NULL) { 16130 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16131 "alloc contig_mem failure\n"); 16132 return (NULL); /* cannot get one */ 16133 } 16134 cp->cm_bp = (struct buf *) 16135 (((caddr_t)cp) + sizeof (struct contig_mem)); 16136 bioinit(cp->cm_bp); 16137 mutex_enter(ST_MUTEX); 16138 un->un_contig_mem_total_num++; /* one more available */ 16139 } else { 16140 /* 16141 * we failed to get one and we're NOT allowed to 16142 * alloc more contig_mem 16143 */ 16144 if (alloc_flags == KM_SLEEP) { 16145 while (un->un_contig_mem_available_num <= 0) { 16146 cv_wait(&un->un_contig_mem_cv, ST_MUTEX); 16147 } 16148 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 16149 } else { 16150 mutex_exit(ST_MUTEX); 16151 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16152 "alloc contig_mem failure\n"); 16153 return (NULL); /* cannot get one */ 16154 } 16155 } 16156 mutex_exit(ST_MUTEX); 16157 16158 /* We need to check if this block of mem is big enough for this I/O */ 16159 if (cp->cm_len < len) { 16160 /* not big enough, need to alloc a new one */ 16161 if (ddi_dma_mem_alloc(un->un_contig_mem_hdl, len, &st_acc_attr, 16162 DDI_DMA_STREAMING, dma_alloc_cb, NULL, 16163 &addr, &rlen, &acc_hdl) != DDI_SUCCESS) { 16164 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 16165 "alloc contig_mem failure: not enough mem\n"); 16166 st_release_contig_mem(un, cp); 16167 cp = NULL; 16168 } else { 16169 if (cp->cm_addr) { 16170 /* release previous one before attach new one */ 16171 ddi_dma_mem_free(&cp->cm_acc_hdl); 16172 } 16173 mutex_enter(ST_MUTEX); 16174 un->un_max_contig_mem_len = 16175 un->un_max_contig_mem_len >= len ? 16176 un->un_max_contig_mem_len : len; 16177 mutex_exit(ST_MUTEX); 16178 16179 /* attach new mem to this cp */ 16180 cp->cm_addr = addr; 16181 cp->cm_acc_hdl = acc_hdl; 16182 cp->cm_len = len; 16183 16184 goto alloc_ok; /* get one usable cp */ 16185 } 16186 } else { 16187 goto alloc_ok; /* get one usable cp */ 16188 } 16189 16190 /* cannot find/alloc a usable cp, when we get here */ 16191 16192 mutex_enter(ST_MUTEX); 16193 if ((un->un_max_contig_mem_len < len) || 16194 (alloc_flags != KM_SLEEP)) { 16195 mutex_exit(ST_MUTEX); 16196 return (NULL); 16197 } 16198 16199 /* 16200 * we're allowed to sleep, and there is one big enough 16201 * contig mem in the system, which is currently in use, 16202 * wait for it... 16203 */ 16204 big_enough = 1; 16205 do { 16206 cv_wait(&un->un_contig_mem_cv, ST_MUTEX); 16207 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 16208 } while (cp == NULL); 16209 mutex_exit(ST_MUTEX); 16210 16211 /* we get the big enough contig mem, finally */ 16212 16213 alloc_ok: 16214 /* init bp attached to this cp */ 16215 bioreset(cp->cm_bp); 16216 cp->cm_bp->b_un.b_addr = cp->cm_addr; 16217 cp->cm_bp->b_private = (void *)cp; 16218 16219 return (cp); 16220 } 16221 16222 /* 16223 * this is the biodone func for the bp used in big block I/O 16224 */ 16225 static int 16226 st_bigblk_xfer_done(struct buf *bp) 16227 { 16228 struct contig_mem *cp; 16229 struct buf *orig_bp; 16230 int ioerr; 16231 struct scsi_tape *un; 16232 16233 /* sanity check */ 16234 if (bp == NULL) { 16235 return (DDI_FAILURE); 16236 } 16237 16238 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 16239 if (un == NULL) { 16240 return (DDI_FAILURE); 16241 } 16242 16243 ST_FUNC(ST_DEVINFO, st_bigblk_xfer_done); 16244 16245 cp = (struct contig_mem *)bp->b_private; 16246 orig_bp = cp->cm_bp; /* get back the bp we have replaced */ 16247 cp->cm_bp = bp; 16248 16249 /* special handling for special I/O */ 16250 if (cp->cm_use_sbuf) { 16251 #ifndef __lock_lint 16252 ASSERT(un->un_sbuf_busy); 16253 #endif 16254 un->un_sbufp = orig_bp; 16255 cp->cm_use_sbuf = 0; 16256 } 16257 16258 orig_bp->b_resid = bp->b_resid; 16259 ioerr = geterror(bp); 16260 if (ioerr != 0) { 16261 bioerror(orig_bp, ioerr); 16262 } else if (orig_bp->b_flags & B_READ) { 16263 /* copy data back to original bp */ 16264 (void) bp_copyout(bp->b_un.b_addr, orig_bp, 0, 16265 bp->b_bcount - bp->b_resid); 16266 } 16267 16268 st_release_contig_mem(un, cp); 16269 16270 biodone(orig_bp); 16271 16272 return (DDI_SUCCESS); 16273 } 16274 16275 /* 16276 * We use this func to replace original bp that may not be able to do I/O 16277 * in big block size with one that can 16278 */ 16279 static struct buf * 16280 st_get_bigblk_bp(struct buf *bp) 16281 { 16282 struct contig_mem *cp; 16283 struct scsi_tape *un; 16284 struct buf *cont_bp; 16285 16286 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 16287 if (un == NULL) { 16288 return (bp); 16289 } 16290 16291 ST_FUNC(ST_DEVINFO, st_get_bigblk_bp); 16292 16293 /* try to get one contig_mem */ 16294 cp = st_get_contig_mem(un, bp->b_bcount, KM_SLEEP); 16295 if (!cp) { 16296 scsi_log(ST_DEVINFO, st_label, CE_WARN, 16297 "Cannot alloc contig buf for I/O for %lu blk size", 16298 bp->b_bcount); 16299 return (bp); 16300 } 16301 cont_bp = cp->cm_bp; 16302 cp->cm_bp = bp; 16303 16304 /* make sure that we "are" using un_sbufp for special I/O */ 16305 if (bp == un->un_sbufp) { 16306 #ifndef __lock_lint 16307 ASSERT(un->un_sbuf_busy); 16308 #endif 16309 un->un_sbufp = cont_bp; 16310 cp->cm_use_sbuf = 1; 16311 } 16312 16313 /* clone bp */ 16314 cont_bp->b_bcount = bp->b_bcount; 16315 cont_bp->b_resid = bp->b_resid; 16316 cont_bp->b_iodone = st_bigblk_xfer_done; 16317 cont_bp->b_file = bp->b_file; 16318 cont_bp->b_offset = bp->b_offset; 16319 cont_bp->b_dip = bp->b_dip; 16320 cont_bp->b_error = 0; 16321 cont_bp->b_proc = NULL; 16322 cont_bp->b_flags = bp->b_flags & ~(B_PAGEIO | B_PHYS | B_SHADOW); 16323 cont_bp->b_shadow = NULL; 16324 cont_bp->b_pages = NULL; 16325 cont_bp->b_edev = bp->b_edev; 16326 cont_bp->b_dev = bp->b_dev; 16327 cont_bp->b_lblkno = bp->b_lblkno; 16328 cont_bp->b_forw = bp->b_forw; 16329 cont_bp->b_back = bp->b_back; 16330 cont_bp->av_forw = bp->av_forw; 16331 cont_bp->av_back = bp->av_back; 16332 cont_bp->b_bufsize = bp->b_bufsize; 16333 16334 /* get data in original bp */ 16335 if (bp->b_flags & B_WRITE) { 16336 (void) bp_copyin(bp, cont_bp->b_un.b_addr, 0, bp->b_bcount); 16337 } 16338 16339 return (cont_bp); 16340 } 16341 #else 16342 #ifdef __lock_lint 16343 static int 16344 st_bigblk_xfer_done(struct buf *bp) 16345 { 16346 return (0); 16347 } 16348 #endif 16349 #endif 16350 16351 static const char *eof_status[] = 16352 { 16353 "NO_EOF", 16354 "EOF_PENDING", 16355 "EOF", 16356 "EOT_PENDING", 16357 "EOT", 16358 "EOM", 16359 "AFTER_EOM" 16360 }; 16361 static const char *mode[] = { 16362 "invalid", 16363 "legacy", 16364 "logical" 16365 }; 16366 16367 static void 16368 st_print_position(dev_info_t *dev, char *label, uint_t level, 16369 const char *comment, tapepos_t *pos) 16370 { 16371 ST_FUNC(dev, st_print_position); 16372 16373 scsi_log(dev, label, level, 16374 "%s Position data:\n", comment); 16375 scsi_log(dev, label, CE_CONT, 16376 "Positioning mode = %s", mode[pos->pmode]); 16377 scsi_log(dev, label, CE_CONT, 16378 "End Of File/Tape = %s", eof_status[pos->eof]); 16379 scsi_log(dev, label, CE_CONT, 16380 "File Number = 0x%x", pos->fileno); 16381 scsi_log(dev, label, CE_CONT, 16382 "Block Number = 0x%x", pos->blkno); 16383 scsi_log(dev, label, CE_CONT, 16384 "Logical Block = 0x%"PRIx64, pos->lgclblkno); 16385 scsi_log(dev, label, CE_CONT, 16386 "Partition Number = 0x%x", pos->partition); 16387 } 16388 static int 16389 st_check_if_media_changed(struct scsi_tape *un, caddr_t data, int size) 16390 { 16391 16392 int result = 0; 16393 int i; 16394 ST_FUNC(ST_DEVINFO, st_check_if_media_changed); 16395 16396 /* 16397 * find non alpha numeric working from the end. 16398 */ 16399 for (i = size - 1; i >= 0; i--) { 16400 if (ISALNUM(data[i]) == 0 || data[i] == ' ') { 16401 data[i] = 0; 16402 size = i; 16403 } 16404 } 16405 16406 if (size == 1) { 16407 /* 16408 * Drive seems to think its returning useful data 16409 * but it looks like all junk 16410 */ 16411 return (result); 16412 } 16413 16414 size++; 16415 16416 /* 16417 * Actually got a valid serial number. 16418 * If never stored one before alloc space for it. 16419 */ 16420 if (un->un_media_id_len == 0) { 16421 un->un_media_id = kmem_zalloc(size, KM_SLEEP); 16422 un->un_media_id_len = size; 16423 (void) strncpy(un->un_media_id, data, min(size, strlen(data))); 16424 un->un_media_id[min(size, strlen(data))] = 0; 16425 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 16426 "Found Media Id %s length = %d\n", un->un_media_id, size); 16427 } else if (size > un->un_media_id_len) { 16428 if (strncmp(un->un_media_id, data, size) != 0) { 16429 result = ESPIPE; 16430 } 16431 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 16432 "Longer Media Id old ID:%s new ID:%s\n", 16433 un->un_media_id, data); 16434 kmem_free(un->un_media_id, un->un_media_id_len); 16435 un->un_media_id = kmem_zalloc(size, KM_SLEEP); 16436 un->un_media_id_len = size; 16437 (void) strncpy(un->un_media_id, data, size); 16438 un->un_media_id[size] = 0; 16439 } else if (strncmp(data, un->un_media_id, 16440 min(size, un->un_media_id_len)) != 0) { 16441 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 16442 "Old Media Id %s length = %d New %s length = %d\n", 16443 un->un_media_id, un->un_media_id_len, data, size); 16444 bzero(un->un_media_id, un->un_media_id_len); 16445 (void) strncpy(un->un_media_id, data, min(size, strlen(data))); 16446 un->un_media_id[min(size, strlen(data))] = 0; 16447 result = ESPIPE; 16448 } else { 16449 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 16450 "Media Id still %s\n", un->un_media_id); 16451 } 16452 16453 ASSERT(strlen(un->un_media_id) <= size); 16454 16455 return (result); 16456 } 16457 #define ID_SIZE 32 16458 typedef struct 16459 { 16460 uchar_t avilable_data0; 16461 uchar_t avilable_data1; 16462 uchar_t avilable_data2; 16463 uchar_t avilable_data3; 16464 uchar_t attribute_msb; 16465 uchar_t attribute_lsb; 16466 #ifdef _BIT_FIELDS_LTOH 16467 uchar_t format : 2, 16468 : 5, 16469 read_only : 1; 16470 #else 16471 uchar_t read_only : 1, 16472 : 5, 16473 format : 2; 16474 #endif 16475 uchar_t attribute_len_msb; 16476 uchar_t attribute_len_lsb; 16477 }attribute_header; 16478 16479 typedef struct { 16480 attribute_header header; 16481 char data[1]; 16482 }mam_attribute; 16483 16484 static int 16485 st_handle_hex_media_id(struct scsi_tape *un, void *pnt, int size) 16486 { 16487 int result; 16488 int newsize = (size << 1) + 3; /* extra for leading 0x and null term */ 16489 int i; 16490 uchar_t byte; 16491 char *format; 16492 uchar_t *data = (uchar_t *)pnt; 16493 char *buf = kmem_alloc(newsize, KM_SLEEP); 16494 16495 ST_FUNC(ST_DEVINFO, st_handle_hex_media_id); 16496 16497 (void) sprintf(buf, "0x"); 16498 for (i = 0; i < size; i++) { 16499 byte = data[i]; 16500 if (byte < 0x10) 16501 format = "0%x"; 16502 else 16503 format = "%x"; 16504 (void) sprintf(&buf[(int)strlen(buf)], format, byte); 16505 } 16506 result = st_check_if_media_changed(un, buf, newsize); 16507 16508 kmem_free(buf, newsize); 16509 16510 return (result); 16511 } 16512 16513 16514 static int 16515 st_get_media_id_via_read_attribute(struct scsi_tape *un, ubufunc_t bufunc) 16516 { 16517 int result; 16518 mam_attribute *buffer; 16519 int size; 16520 int newsize; 16521 16522 ST_FUNC(ST_DEVINFO, st_get_media_id_via_read_attribute); 16523 size = sizeof (attribute_header) + max(un->un_media_id_len, ID_SIZE); 16524 again: 16525 buffer = kmem_zalloc(size, KM_SLEEP); 16526 result = st_read_attributes(un, 0x0401, buffer, size, bufunc); 16527 if (result == 0) { 16528 16529 newsize = (buffer->header.attribute_len_msb << 8) | 16530 buffer->header.attribute_len_lsb; 16531 16532 if (newsize + sizeof (attribute_header) > size) { 16533 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 16534 "resizing read attribute data from %d to %d format" 16535 " %d\n", size, (int)sizeof (attribute_header) + 16536 newsize, buffer->header.format); 16537 kmem_free(buffer, size); 16538 size = newsize + sizeof (attribute_header); 16539 goto again; 16540 } 16541 16542 un->un_media_id_method = st_get_media_id_via_read_attribute; 16543 if (buffer->header.format == 0) { 16544 result = 16545 st_handle_hex_media_id(un, buffer->data, newsize); 16546 } else { 16547 result = st_check_if_media_changed(un, buffer->data, 16548 newsize); 16549 } 16550 } else if (result == EINVAL && un->un_max_cdb_sz < CDB_GROUP4) { 16551 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 16552 "Read Attribute Command for Media Identification is not " 16553 "supported on the HBA that this drive is attached to."); 16554 result = ENOTTY; 16555 } 16556 16557 kmem_free(buffer, size); 16558 un->un_status = 0; 16559 16560 return (result); 16561 } 16562 16563 16564 static int 16565 st_get_media_id_via_media_serial_cmd(struct scsi_tape *un, ubufunc_t bufunc) 16566 { 16567 char cdb[CDB_GROUP5]; 16568 struct uscsi_cmd *ucmd; 16569 struct scsi_extended_sense sense; 16570 int rval; 16571 int size = max(un->un_media_id_len, ID_SIZE); 16572 caddr_t buf; 16573 16574 ST_FUNC(ST_DEVINFO, st_get_media_id_via_media_serial_cmd); 16575 16576 if (un->un_sd->sd_inq->inq_ansi < 3) { 16577 return (ENOTTY); 16578 } 16579 16580 ucmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 16581 upsize: 16582 buf = kmem_alloc(size, KM_SLEEP); 16583 16584 cdb[0] = (char)SCMD_SVC_ACTION_IN_G5; 16585 cdb[1] = SSVC_ACTION_READ_MEDIA_SERIAL; 16586 cdb[2] = 0; 16587 cdb[3] = 0; 16588 cdb[4] = 0; 16589 cdb[5] = 0; 16590 cdb[6] = (char)(size >> 24); 16591 cdb[7] = (char)(size >> 16); 16592 cdb[8] = (char)(size >> 8); 16593 cdb[9] = (char)(size); 16594 cdb[10] = 0; 16595 cdb[11] = 0; 16596 16597 ucmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE; 16598 ucmd->uscsi_timeout = un->un_dp->non_motion_timeout; 16599 ucmd->uscsi_cdb = &cdb[0]; 16600 ucmd->uscsi_cdblen = sizeof (cdb); 16601 ucmd->uscsi_bufaddr = buf; 16602 ucmd->uscsi_buflen = size; 16603 ucmd->uscsi_rqbuf = (caddr_t)&sense; 16604 ucmd->uscsi_rqlen = sizeof (sense); 16605 16606 rval = bufunc(un, ucmd, FKIOCTL); 16607 16608 if (rval || ucmd->uscsi_status != 0) { 16609 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 16610 "media serial command returned %d scsi_status %d" 16611 " rqstatus %d", rval, ucmd->uscsi_status, 16612 ucmd->uscsi_rqstatus); 16613 /* 16614 * If this returns invalid operation code don't try again. 16615 */ 16616 if (sense.es_key == KEY_ILLEGAL_REQUEST && 16617 sense.es_add_code == 0x20) { 16618 rval = ENOTTY; 16619 } else if (rval == 0) { 16620 rval = EIO; 16621 } 16622 un->un_status = 0; 16623 } else { 16624 int act_size; 16625 16626 /* 16627 * get reported size. 16628 */ 16629 act_size = (int)buf[3] | (int)(buf[2] << 8) | 16630 (int)(buf[1] << 16) | (int)(buf[0] << 24); 16631 16632 /* documentation says mod 4. */ 16633 while (act_size & 3) { 16634 act_size++; 16635 } 16636 16637 /* 16638 * If reported size is larger that we our buffer. 16639 * Free the old one and allocate one that is larger 16640 * enough and re-issuse the command. 16641 */ 16642 if (act_size + 4 > size) { 16643 kmem_free(buf, size); 16644 size = act_size + 4; 16645 goto upsize; 16646 } 16647 16648 if (act_size == 0) { 16649 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 16650 "media serial number is not available"); 16651 un->un_status = 0; 16652 rval = 0; 16653 } else { 16654 /* 16655 * set data pointer to point to the start 16656 * of that serial number. 16657 */ 16658 un->un_media_id_method = 16659 st_get_media_id_via_media_serial_cmd; 16660 rval = 16661 st_check_if_media_changed(un, &buf[4], act_size); 16662 } 16663 } 16664 16665 kmem_free(ucmd, sizeof (struct uscsi_cmd)); 16666 kmem_free(buf, size); 16667 16668 return (rval); 16669 } 16670 16671 16672 /* ARGSUSED */ 16673 static int 16674 st_bogus_media_id(struct scsi_tape *un, ubufunc_t bufunc) 16675 { 16676 ST_FUNC(ST_DEVINFO, st_bogus_media_id); 16677 16678 ASSERT(un->un_media_id == NULL || un->un_media_id == bogusID); 16679 ASSERT(un->un_media_id_len == 0); 16680 un->un_media_id = (char *)bogusID; 16681 un->un_media_id_len = 0; 16682 return (0); 16683 } 16684 16685 typedef int (*media_chk_function)(struct scsi_tape *, ubufunc_t bufunc); 16686 16687 media_chk_function media_chk_functions[] = { 16688 st_get_media_id_via_media_serial_cmd, 16689 st_get_media_id_via_read_attribute, 16690 st_bogus_media_id 16691 }; 16692 16693 static int 16694 st_get_media_identification(struct scsi_tape *un, ubufunc_t bufunc) 16695 { 16696 int result = 0; 16697 int i; 16698 16699 ST_FUNC(ST_DEVINFO, st_get_media_identification); 16700 16701 for (i = 0; i < ST_NUM_MEMBERS(media_chk_functions); i++) { 16702 if (result == ENOTTY) { 16703 /* 16704 * Last operation type not supported by this device. 16705 * Make so next time it doesn`t do that again. 16706 */ 16707 un->un_media_id_method = media_chk_functions[i]; 16708 } else if (un->un_media_id_method != media_chk_functions[i] && 16709 un->un_media_id_method != st_get_media_identification) { 16710 continue; 16711 } 16712 result = media_chk_functions[i](un, bufunc); 16713 /* 16714 * If result indicates the function was successful or 16715 * that the media is not the same as last known, break. 16716 */ 16717 if (result == 0 || result == ESPIPE) { 16718 break; 16719 } 16720 } 16721 16722 return (result); 16723 } 16724 16725 static errstate 16726 st_command_recovery(struct scsi_tape *un, struct scsi_pkt *pkt, 16727 errstate onentry) 16728 { 16729 16730 int ret; 16731 st_err_info *errinfo; 16732 recov_info *ri = (recov_info *)pkt->pkt_private; 16733 16734 ST_FUNC(ST_DEVINFO, st_command_recovery); 16735 16736 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 16737 16738 ASSERT(un->un_recov_buf_busy == 0); 16739 16740 /* 16741 * Don't try and recover a reset that this device sent. 16742 */ 16743 if (un->un_rsvd_status & ST_INITIATED_RESET && 16744 onentry == DEVICE_RESET) { 16745 return (COMMAND_DONE_ERROR); 16746 } 16747 16748 /* 16749 * See if expected position was passed with scsi_pkt. 16750 */ 16751 if (ri->privatelen == sizeof (recov_info)) { 16752 16753 /* 16754 * Not for this command. 16755 */ 16756 if (ri->cmd_attrib->do_not_recover) { 16757 return (COMMAND_DONE_ERROR); 16758 } 16759 16760 /* 16761 * Create structure to hold all error state info. 16762 */ 16763 errinfo = kmem_zalloc(ST_ERR_INFO_SIZE, KM_SLEEP); 16764 errinfo->ei_error_type = onentry; 16765 errinfo->ei_failing_bp = ri->cmd_bp; 16766 COPY_POS(&errinfo->ei_expected_pos, &ri->pos); 16767 } else { 16768 /* disabled */ 16769 return (COMMAND_DONE_ERROR); 16770 } 16771 16772 bcopy(pkt, &errinfo->ei_failed_pkt, scsi_pkt_size()); 16773 bcopy(pkt->pkt_scbp, &errinfo->ei_failing_status, SECMDS_STATUS_SIZE); 16774 ret = ddi_taskq_dispatch(un->un_recov_taskq, st_recover, errinfo, 16775 DDI_NOSLEEP); 16776 ASSERT(ret == DDI_SUCCESS); 16777 if (ret != DDI_SUCCESS) { 16778 kmem_free(errinfo, ST_ERR_INFO_SIZE); 16779 return (COMMAND_DONE_ERROR); 16780 } 16781 return (JUST_RETURN); /* release calling thread */ 16782 } 16783 16784 16785 static void 16786 st_recov_ret(struct scsi_tape *un, st_err_info *errinfo, errstate err) 16787 { 16788 int error_number; 16789 buf_t *bp; 16790 16791 16792 ST_FUNC(ST_DEVINFO, st_recov_ret); 16793 16794 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 16795 #if !defined(lint) 16796 _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex)) 16797 #endif 16798 16799 bp = errinfo->ei_failing_bp; 16800 kmem_free(errinfo, ST_ERR_INFO_SIZE); 16801 16802 switch (err) { 16803 case JUST_RETURN: 16804 mutex_exit(&un->un_sd->sd_mutex); 16805 return; 16806 16807 case COMMAND_DONE: 16808 case COMMAND_DONE_ERROR_RECOVERED: 16809 ST_DO_KSTATS(bp, kstat_runq_exit); 16810 error_number = 0; 16811 break; 16812 16813 default: 16814 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 16815 "st_recov_ret with unhandled errstat %d\n", err); 16816 /* FALLTHROUGH */ 16817 case COMMAND_DONE_ERROR: 16818 un->un_pos.pmode = invalid; 16819 un->un_running.pmode = invalid; 16820 /* FALLTHROUGH */ 16821 case COMMAND_DONE_EACCES: 16822 ST_DO_KSTATS(bp, kstat_waitq_exit); 16823 ST_DO_ERRSTATS(un, st_transerrs); 16824 error_number = EIO; 16825 st_set_pe_flag(un); 16826 break; 16827 16828 } 16829 16830 st_bioerror(bp, error_number); 16831 st_done_and_mutex_exit(un, bp); 16832 } 16833 16834 16835 static void 16836 st_recover(void *arg) 16837 { 16838 st_err_info *const errinfo = (st_err_info *)arg; 16839 uchar_t com = errinfo->ei_failed_pkt.pkt_cdbp[0]; 16840 struct scsi_tape *un; 16841 tapepos_t cur_pos; 16842 int rval; 16843 errstate status = COMMAND_DONE_ERROR; 16844 recov_info *rcv; 16845 buf_t *bp; 16846 16847 16848 rcv = errinfo->ei_failed_pkt.pkt_private; 16849 ASSERT(rcv->privatelen == sizeof (recov_info)); 16850 bp = rcv->cmd_bp; 16851 16852 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 16853 16854 ASSERT(un != NULL); 16855 16856 mutex_enter(ST_MUTEX); 16857 16858 ST_FUNC(ST_DEVINFO, st_recover); 16859 16860 ST_CDB(ST_DEVINFO, "Recovering command", 16861 (caddr_t)errinfo->ei_failed_pkt.pkt_cdbp); 16862 ST_SENSE(ST_DEVINFO, "sense status for failed command", 16863 (caddr_t)&errinfo->ei_failing_status, 16864 sizeof (struct scsi_arq_status)); 16865 ST_POS(ST_DEVINFO, rcv->cmd_attrib->recov_pos_type == POS_STARTING ? 16866 "starting position for recovery command" : 16867 "expected position for recovery command", 16868 &errinfo->ei_expected_pos); 16869 16870 rval = st_test_path_to_device(un); 16871 16872 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16873 "st_recover called with %s, TUR returned %d\n", 16874 errstatenames[errinfo->ei_error_type], rval); 16875 /* 16876 * If the drive responed to the TUR lets try and get it to sync 16877 * any data it might have in the buffer. 16878 */ 16879 if (rval == 0 && rcv->cmd_attrib->chg_tape_data) { 16880 rval = st_rcmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD); 16881 if (rval) { 16882 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16883 "st_recover failed to flush, returned %d\n", rval); 16884 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16885 return; 16886 } 16887 } 16888 switch (errinfo->ei_error_type) { 16889 case ATTEMPT_RETRY: 16890 case COMMAND_TIMEOUT: 16891 case DEVICE_RESET: 16892 case PATH_FAILED: 16893 /* 16894 * For now if we can't talk to the device we are done. 16895 * If the drive is reserved we can try to get it back. 16896 */ 16897 if (rval != 0 && rval != EACCES) { 16898 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16899 return; 16900 } 16901 16902 /* 16903 * If reservation conflict and do a preempt, fail it. 16904 */ 16905 if ((un->un_rsvd_status & 16906 (ST_APPLICATION_RESERVATIONS | ST_RESERVE)) != 0) { 16907 if ((errinfo->ei_failed_pkt.pkt_cdbp[0] == 16908 SCMD_PERSISTENT_RESERVE_OUT) && 16909 (errinfo->ei_failed_pkt.pkt_cdbp[1] == 16910 ST_SA_SCSI3_PREEMPT) && 16911 (SCBP_C(&errinfo->ei_failed_pkt) == 16912 STATUS_RESERVATION_CONFLICT)) { 16913 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16914 return; 16915 } 16916 } 16917 16918 /* 16919 * If we have already set a scsi II reserve and get a 16920 * conflict on a scsi III type reserve fail without 16921 * any attempt to recover. 16922 */ 16923 if ((un->un_rsvd_status & ST_RESERVE | ST_PRESERVE_RESERVE) && 16924 (errinfo->ei_failed_pkt.pkt_cdbp[0] == 16925 SCMD_PERSISTENT_RESERVE_OUT) || 16926 (errinfo->ei_failed_pkt.pkt_cdbp[0] == 16927 SCMD_PERSISTENT_RESERVE_IN)) { 16928 st_recov_ret(un, errinfo, COMMAND_DONE_EACCES); 16929 return; 16930 } 16931 16932 /* 16933 * If scsi II lost reserve try and get it back. 16934 */ 16935 if ((((un->un_rsvd_status & 16936 (ST_LOST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 16937 ST_LOST_RESERVE)) && 16938 (errinfo->ei_failed_pkt.pkt_cdbp[0] != SCMD_RELEASE)) { 16939 rval = st_reserve_release(un, ST_RESERVE, 16940 st_uscsi_rcmd); 16941 if (rval != 0) { 16942 if (st_take_ownership(un, st_uscsi_rcmd) != 0) { 16943 st_recov_ret(un, errinfo, 16944 COMMAND_DONE_EACCES); 16945 return; 16946 } 16947 } 16948 un->un_rsvd_status |= ST_RESERVE; 16949 un->un_rsvd_status &= ~(ST_RELEASE | ST_LOST_RESERVE | 16950 ST_RESERVATION_CONFLICT | ST_INITIATED_RESET); 16951 } 16952 rval = st_make_sure_mode_data_is_correct(un, st_uscsi_rcmd); 16953 if (rval) { 16954 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16955 return; 16956 } 16957 break; 16958 case DEVICE_TAMPER: 16959 /* 16960 * Check if the ASC/ASCQ says mode data has changed. 16961 */ 16962 if ((errinfo->ei_failing_status.sts_sensedata.es_add_code == 16963 0x2a) && 16964 (errinfo->ei_failing_status.sts_sensedata.es_qual_code == 16965 0x01)) { 16966 /* 16967 * See if mode sense changed. 16968 */ 16969 rval = st_make_sure_mode_data_is_correct(un, 16970 st_uscsi_rcmd); 16971 if (rval) { 16972 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16973 return; 16974 } 16975 } 16976 /* 16977 * if we have a media id and its not bogus. 16978 * Check to see if it the same. 16979 */ 16980 if (un->un_media_id != NULL && un->un_media_id != bogusID) { 16981 rval = st_get_media_identification(un, st_uscsi_rcmd); 16982 if (rval == ESPIPE) { 16983 st_recov_ret(un, errinfo, COMMAND_DONE_EACCES); 16984 return; 16985 } 16986 } 16987 break; 16988 default: 16989 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 16990 "Unhandled error type %s in st_recover() 0x%x\n", 16991 errstatenames[errinfo->ei_error_type], com); 16992 } 16993 16994 /* 16995 * if command is retriable retry it. 16996 * Special case here. The command attribute for SCMD_REQUEST_SENSE 16997 * does not say that it is retriable. That because if you reissue a 16998 * request sense and the target responds the sense data will have 16999 * been consumed and no long be valid. If we get a busy status on 17000 * request sense while the state is ST_STATE_SENSING this will 17001 * reissue that pkt. 17002 * 17003 * XXX If this request sense gets sent to a different port then 17004 * the original command that failed was sent on it will not get 17005 * valid sense data for that command. 17006 */ 17007 if (rcv->cmd_attrib->retriable || un->un_rqs_bp == bp) { 17008 status = st_recover_reissue_pkt(un, &errinfo->ei_failed_pkt); 17009 17010 /* 17011 * if drive doesn't support read position we are done 17012 */ 17013 } else if (un->un_read_pos_type == NO_POS) { 17014 status = COMMAND_DONE_ERROR; 17015 /* 17016 * If this command results in a changed tape position, 17017 * lets see where we are. 17018 */ 17019 } else if (rcv->cmd_attrib->chg_tape_pos) { 17020 /* 17021 * XXX May be a reason to choose a different type here. 17022 * Long format has file position information. 17023 * Short and Extended have information about whats 17024 * in the buffer. St's positioning assumes in the buffer 17025 * to be the same as on tape. 17026 */ 17027 rval = st_compare_expected_position(un, errinfo, 17028 rcv->cmd_attrib, &cur_pos); 17029 if (rval == 0) { 17030 status = COMMAND_DONE; 17031 } else if (rval == EAGAIN) { 17032 status = st_recover_reissue_pkt(un, 17033 &errinfo->ei_failed_pkt); 17034 } else { 17035 status = COMMAND_DONE_ERROR; 17036 } 17037 } else { 17038 ASSERT(0); 17039 } 17040 17041 st_recov_ret(un, errinfo, status); 17042 } 17043 17044 static void 17045 st_recov_cb(struct scsi_pkt *pkt) 17046 { 17047 struct scsi_tape *un; 17048 struct buf *bp; 17049 recov_info *rcv; 17050 errstate action = COMMAND_DONE_ERROR; 17051 int timout = ST_TRAN_BUSY_TIMEOUT; /* short (default) timeout */ 17052 17053 /* 17054 * Get the buf from the packet. 17055 */ 17056 rcv = pkt->pkt_private; 17057 ASSERT(rcv->privatelen == sizeof (recov_info)); 17058 bp = rcv->cmd_bp; 17059 17060 /* 17061 * get the unit from the buf. 17062 */ 17063 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 17064 ASSERT(un != NULL); 17065 17066 ST_FUNC(ST_DEVINFO, st_recov_cb); 17067 17068 mutex_enter(ST_MUTEX); 17069 17070 ASSERT(bp == un->un_recov_buf); 17071 17072 17073 switch (pkt->pkt_reason) { 17074 case CMD_CMPLT: 17075 if (un->un_arq_enabled && pkt->pkt_state & STATE_ARQ_DONE) { 17076 action = st_handle_autosense(un, bp, &rcv->pos); 17077 } else if ((SCBP(pkt)->sts_busy) || 17078 (SCBP(pkt)->sts_chk) || 17079 (SCBP(pkt)->sts_vu7)) { 17080 action = st_check_error(un, pkt); 17081 } else { 17082 action = COMMAND_DONE; 17083 } 17084 break; 17085 case CMD_TIMEOUT: 17086 action = COMMAND_TIMEOUT; 17087 break; 17088 case CMD_TRAN_ERR: 17089 action = QUE_COMMAND; 17090 break; 17091 case CMD_DEV_GONE: 17092 if (un->un_multipath) 17093 action = PATH_FAILED; 17094 else 17095 action = COMMAND_DONE_ERROR; 17096 break; 17097 default: 17098 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 17099 "pkt_reason not handled yet %s", 17100 scsi_rname(pkt->pkt_reason)); 17101 action = COMMAND_DONE_ERROR; 17102 } 17103 17104 /* 17105 * check for undetected path failover. 17106 */ 17107 if (un->un_multipath) { 17108 if (scsi_pkt_allocated_correctly(pkt) && 17109 (un->un_last_path_instance != pkt->pkt_path_instance)) { 17110 if (un->un_state > ST_STATE_OPENING) { 17111 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17112 "Failover detected in recovery, action is " 17113 "%s\n", errstatenames[action]); 17114 } 17115 un->un_last_path_instance = pkt->pkt_path_instance; 17116 } 17117 } 17118 17119 ST_RECOV(ST_DEVINFO, st_label, CE_WARN, 17120 "Recovery call back got %s status on %s\n", 17121 errstatenames[action], st_print_scsi_cmd(pkt->pkt_cdbp[0])); 17122 17123 switch (action) { 17124 case COMMAND_DONE: 17125 break; 17126 17127 case COMMAND_DONE_EACCES: 17128 bioerror(bp, EACCES); 17129 break; 17130 17131 case COMMAND_DONE_ERROR_RECOVERED: /* XXX maybe wrong */ 17132 ASSERT(0); 17133 break; 17134 17135 case COMMAND_TIMEOUT: 17136 case COMMAND_DONE_ERROR: 17137 bioerror(bp, EIO); 17138 break; 17139 17140 case DEVICE_RESET: 17141 case QUE_BUSY_COMMAND: 17142 case PATH_FAILED: 17143 /* longish timeout */ 17144 timout = ST_STATUS_BUSY_TIMEOUT; 17145 /* FALLTHRU */ 17146 case QUE_COMMAND: 17147 case DEVICE_TAMPER: 17148 case ATTEMPT_RETRY: 17149 /* 17150 * let st_handle_intr_busy put this bp back on waitq and make 17151 * checks to see if it is ok to requeue the command. 17152 */ 17153 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 17154 17155 /* 17156 * Save the throttle before setting up the timeout 17157 */ 17158 if (un->un_throttle) { 17159 un->un_last_throttle = un->un_throttle; 17160 } 17161 mutex_exit(ST_MUTEX); 17162 if (st_handle_intr_busy(un, bp, timout) == 0) { 17163 return; /* timeout is setup again */ 17164 } 17165 mutex_enter(ST_MUTEX); 17166 un->un_pos.pmode = invalid; 17167 un->un_err_resid = bp->b_resid = bp->b_bcount; 17168 st_bioerror(bp, EIO); 17169 st_set_pe_flag(un); 17170 break; 17171 17172 default: 17173 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 17174 "Unhandled recovery state 0x%x\n", action); 17175 un->un_pos.pmode = invalid; 17176 un->un_err_resid = bp->b_resid = bp->b_bcount; 17177 st_bioerror(bp, EIO); 17178 st_set_pe_flag(un); 17179 break; 17180 } 17181 17182 st_done_and_mutex_exit(un, bp); 17183 } 17184 17185 static int 17186 st_rcmd(struct scsi_tape *un, int com, int64_t count, int wait) 17187 { 17188 struct buf *bp; 17189 int err; 17190 17191 ST_FUNC(ST_DEVINFO, st_rcmd); 17192 17193 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 17194 "st_rcmd(un = 0x%p, com = 0x%x, count = %"PRIx64", wait = %d)\n", 17195 (void *)un, com, count, wait); 17196 17197 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 17198 ASSERT(mutex_owned(ST_MUTEX)); 17199 17200 #ifdef STDEBUG 17201 if ((st_debug & 0x7)) { 17202 st_debug_cmds(un, com, count, wait); 17203 } 17204 #endif 17205 17206 while (un->un_recov_buf_busy) 17207 cv_wait(&un->un_recov_buf_cv, ST_MUTEX); 17208 un->un_recov_buf_busy = 1; 17209 17210 bp = un->un_recov_buf; 17211 bzero(bp, sizeof (buf_t)); 17212 17213 bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC; 17214 17215 err = st_setup_cmd(un, bp, com, count); 17216 17217 un->un_recov_buf_busy = 0; 17218 17219 cv_signal(&un->un_recov_buf_cv); 17220 17221 return (err); 17222 } 17223 17224 /* args used */ 17225 static int 17226 st_uscsi_rcmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, int flag) 17227 { 17228 int rval; 17229 buf_t *bp; 17230 17231 ST_FUNC(ST_DEVINFO, st_uscsi_rcmd); 17232 ASSERT(flag == FKIOCTL); 17233 17234 /* 17235 * Get buffer resources... 17236 */ 17237 while (un->un_recov_buf_busy) 17238 cv_wait(&un->un_recov_buf_cv, ST_MUTEX); 17239 un->un_recov_buf_busy = 1; 17240 17241 bp = un->un_recov_buf; 17242 bzero(bp, sizeof (buf_t)); 17243 17244 bp->b_forw = (struct buf *)(uintptr_t)ucmd->uscsi_cdb[0]; 17245 bp->b_back = (struct buf *)ucmd; 17246 17247 mutex_exit(ST_MUTEX); 17248 rval = scsi_uscsi_handle_cmd(un->un_dev, UIO_SYSSPACE, ucmd, 17249 st_strategy, bp, NULL); 17250 mutex_enter(ST_MUTEX); 17251 17252 ucmd->uscsi_resid = bp->b_resid; 17253 17254 /* 17255 * Free resources 17256 */ 17257 un->un_recov_buf_busy = 0; 17258 cv_signal(&un->un_recov_buf_cv); 17259 17260 return (rval); 17261 } 17262 17263 /* 17264 * Add data to scsi_pkt to help know what to do if the command fails. 17265 */ 17266 static void 17267 st_add_recovery_info_to_pkt(struct scsi_tape *un, buf_t *bp, 17268 struct scsi_pkt *pkt) 17269 { 17270 uint64_t count; 17271 recov_info *rinfo = (recov_info *)pkt->pkt_private; 17272 17273 ST_FUNC(ST_DEVINFO, st_add_recovery_info_to_pkt); 17274 17275 ASSERT(rinfo->privatelen == sizeof (pkt_info) || 17276 rinfo->privatelen == sizeof (recov_info)); 17277 17278 SET_BP_PKT(bp, pkt); 17279 rinfo->cmd_bp = bp; 17280 17281 if (rinfo->privatelen != sizeof (recov_info)) { 17282 return; 17283 } 17284 17285 rinfo->cmd_bp = bp; 17286 17287 rinfo->cmd_attrib = NULL; 17288 17289 /* 17290 * lookup the command attributes and add them to the recovery info. 17291 */ 17292 rinfo->cmd_attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 17293 17294 ASSERT(rinfo->cmd_attrib); 17295 17296 /* 17297 * For commands that there is no way to figure the expected position 17298 * once completed, we save the position the command was started from 17299 * so that if they fail we can position back and try again. 17300 * This has already been done in st_cmd() or st_iscsi_cmd(). 17301 */ 17302 if (rinfo->cmd_attrib->recov_pos_type == POS_STARTING) { 17303 /* save current position as the starting position. */ 17304 COPY_POS(&rinfo->pos, &un->un_pos); 17305 un->un_running.pmode = invalid; 17306 return; 17307 } 17308 17309 /* 17310 * Don't want to update the running position for recovery. 17311 */ 17312 if (bp == un->un_recov_buf) { 17313 rinfo->pos.pmode = un->un_running.pmode; 17314 return; 17315 } 17316 /* 17317 * If running position is invalid copy the current position. 17318 * Running being set invalid means we are not in a read, write 17319 * or write filemark sequence. 17320 * We'll copy the current position and start from there. 17321 */ 17322 if (un->un_running.pmode == invalid) { 17323 COPY_POS(&un->un_running, &un->un_pos); 17324 COPY_POS(&rinfo->pos, &un->un_running); 17325 } else { 17326 COPY_POS(&rinfo->pos, &un->un_running); 17327 if (rinfo->pos.pmode == legacy) { 17328 /* 17329 * Always should be more logical blocks then 17330 * data blocks and files marks. 17331 */ 17332 ASSERT((rinfo->pos.blkno >= 0) ? 17333 rinfo->pos.lgclblkno >= 17334 (rinfo->pos.blkno + rinfo->pos.fileno) : 1); 17335 } 17336 } 17337 17338 /* 17339 * If the command is not expected to change the drive position 17340 * then the running position should be the expected position. 17341 */ 17342 if (rinfo->cmd_attrib->chg_tape_pos == 0) { 17343 ASSERT(rinfo->cmd_attrib->chg_tape_direction == DIR_NONE); 17344 return; 17345 } 17346 17347 if (rinfo->cmd_attrib->explicit_cmd_set) { 17348 ASSERT(rinfo->pos.pmode != invalid); 17349 ASSERT(rinfo->cmd_attrib->get_cnt); 17350 count = rinfo->cmd_attrib->get_cnt(pkt->pkt_cdbp); 17351 /* 17352 * This is a user generated CDB. 17353 */ 17354 if (bp == un->un_sbufp) { 17355 uint64_t lbn; 17356 17357 lbn = rinfo->cmd_attrib->get_lba(pkt->pkt_cdbp); 17358 17359 /* 17360 * See if this CDB will generate a locate or change 17361 * partition. 17362 */ 17363 if ((lbn != un->un_running.lgclblkno) || 17364 (pkt->pkt_cdbp[3] != un->un_running.partition)) { 17365 rinfo->pos.partition = pkt->pkt_cdbp[3]; 17366 rinfo->pos.pmode = logical; 17367 rinfo->pos.lgclblkno = lbn; 17368 un->un_running.partition = pkt->pkt_cdbp[3]; 17369 un->un_running.pmode = logical; 17370 un->un_running.lgclblkno = lbn; 17371 } 17372 } else { 17373 uint64_t lbn = un->un_running.lgclblkno; 17374 17375 pkt->pkt_cdbp[3] = (uchar_t)un->un_running.partition; 17376 17377 pkt->pkt_cdbp[4] = (uchar_t)(lbn >> 56); 17378 pkt->pkt_cdbp[5] = (uchar_t)(lbn >> 48); 17379 pkt->pkt_cdbp[6] = (uchar_t)(lbn >> 40); 17380 pkt->pkt_cdbp[7] = (uchar_t)(lbn >> 32); 17381 pkt->pkt_cdbp[8] = (uchar_t)(lbn >> 24); 17382 pkt->pkt_cdbp[9] = (uchar_t)(lbn >> 16); 17383 pkt->pkt_cdbp[10] = (uchar_t)(lbn >> 8); 17384 pkt->pkt_cdbp[11] = (uchar_t)(lbn); 17385 } 17386 rinfo->pos.lgclblkno += count; 17387 rinfo->pos.blkno += count; 17388 un->un_running.lgclblkno += count; 17389 return; 17390 } 17391 17392 if (rinfo->cmd_attrib->chg_tape_pos) { 17393 17394 /* should not have got an invalid position from running. */ 17395 if (un->un_mediastate == MTIO_INSERTED) { 17396 ASSERT(rinfo->pos.pmode != invalid); 17397 } 17398 17399 /* should have either a get count or or get lba function */ 17400 ASSERT(rinfo->cmd_attrib->get_cnt != NULL || 17401 rinfo->cmd_attrib->get_lba != NULL); 17402 17403 /* only explicit commands have both and they're handled above */ 17404 ASSERT(!(rinfo->cmd_attrib->get_cnt != NULL && 17405 rinfo->cmd_attrib->get_lba != NULL)); 17406 17407 /* if it has a get count function */ 17408 if (rinfo->cmd_attrib->get_cnt != NULL) { 17409 count = rinfo->cmd_attrib->get_cnt(pkt->pkt_cdbp); 17410 if (count == 0) { 17411 return; 17412 } 17413 /* 17414 * Changes position but doesn't transfer data. 17415 * i.e. rewind, write_file_mark and load. 17416 */ 17417 if (rinfo->cmd_attrib->transfers_data == TRAN_NONE) { 17418 switch (rinfo->cmd_attrib->chg_tape_direction) { 17419 case DIR_NONE: /* Erase */ 17420 ASSERT(rinfo->cmd_attrib->cmd == 17421 SCMD_ERASE); 17422 break; 17423 case DIR_FORW: /* write_file_mark */ 17424 rinfo->pos.fileno += count; 17425 rinfo->pos.lgclblkno += count; 17426 rinfo->pos.blkno = 0; 17427 un->un_running.fileno += count; 17428 un->un_running.lgclblkno += count; 17429 un->un_running.blkno = 0; 17430 break; 17431 case DIR_REVC: /* rewind */ 17432 rinfo->pos.fileno = 0; 17433 rinfo->pos.lgclblkno = 0; 17434 rinfo->pos.blkno = 0; 17435 rinfo->pos.eof = ST_NO_EOF; 17436 rinfo->pos.pmode = legacy; 17437 un->un_running.fileno = 0; 17438 un->un_running.lgclblkno = 0; 17439 un->un_running.blkno = 0; 17440 un->un_running.eof = ST_NO_EOF; 17441 if (un->un_running.pmode != legacy) 17442 un->un_running.pmode = legacy; 17443 break; 17444 case DIR_EITH: /* Load unload */ 17445 ASSERT(rinfo->cmd_attrib->cmd == 17446 SCMD_LOAD); 17447 switch (count & (LD_LOAD | LD_RETEN | 17448 LD_RETEN | LD_HOLD)) { 17449 case LD_UNLOAD: 17450 case LD_RETEN: 17451 case LD_HOLD: 17452 case LD_LOAD | LD_HOLD: 17453 case LD_EOT | LD_HOLD: 17454 case LD_RETEN | LD_HOLD: 17455 rinfo->pos.pmode = invalid; 17456 un->un_running.pmode = invalid; 17457 break; 17458 case LD_EOT: 17459 case LD_LOAD | LD_EOT: 17460 rinfo->pos.eof = ST_EOT; 17461 rinfo->pos.pmode = invalid; 17462 un->un_running.eof = ST_EOT; 17463 un->un_running.pmode = invalid; 17464 break; 17465 case LD_LOAD: 17466 case LD_RETEN | LD_LOAD: 17467 rinfo->pos.fileno = 0; 17468 rinfo->pos.lgclblkno = 0; 17469 rinfo->pos.blkno = 0; 17470 rinfo->pos.eof = ST_NO_EOF; 17471 rinfo->pos.pmode = legacy; 17472 un->un_running.fileno = 0; 17473 un->un_running.lgclblkno = 0; 17474 un->un_running.blkno = 0; 17475 un->un_running.eof = ST_NO_EOF; 17476 break; 17477 default: 17478 ASSERT(0); 17479 } 17480 break; 17481 default: 17482 ASSERT(0); 17483 break; 17484 } 17485 } else { 17486 /* 17487 * Changes position and does transfer data. 17488 * i.e. read or write. 17489 */ 17490 switch (rinfo->cmd_attrib->chg_tape_direction) { 17491 case DIR_FORW: 17492 rinfo->pos.lgclblkno += count; 17493 rinfo->pos.blkno += count; 17494 un->un_running.lgclblkno += count; 17495 un->un_running.blkno += count; 17496 break; 17497 case DIR_REVC: 17498 rinfo->pos.lgclblkno -= count; 17499 rinfo->pos.blkno -= count; 17500 un->un_running.lgclblkno -= count; 17501 un->un_running.blkno -= count; 17502 break; 17503 default: 17504 ASSERT(0); 17505 break; 17506 } 17507 } 17508 } else if (rinfo->cmd_attrib->get_lba != NULL) { 17509 /* Have a get LBA fuction. i.e. Locate */ 17510 ASSERT(rinfo->cmd_attrib->chg_tape_direction == 17511 DIR_EITH); 17512 count = rinfo->cmd_attrib->get_lba(pkt->pkt_cdbp); 17513 un->un_running.lgclblkno = count; 17514 un->un_running.blkno = 0; 17515 un->un_running.fileno = 0; 17516 un->un_running.pmode = logical; 17517 rinfo->pos.lgclblkno = count; 17518 rinfo->pos.pmode = invalid; 17519 } else { 17520 ASSERT(0); 17521 } 17522 return; 17523 } 17524 17525 ST_CDB(ST_DEVINFO, "Unhanded CDB for position prediction", 17526 (char *)pkt->pkt_cdbp); 17527 17528 } 17529 17530 static int 17531 st_make_sure_mode_data_is_correct(struct scsi_tape *un, ubufunc_t ubf) 17532 { 17533 int rval; 17534 17535 ST_FUNC(ST_DEVINFO, st_make_sure_mode_data_is_correct); 17536 17537 /* 17538 * check to see if mode data has changed. 17539 */ 17540 rval = st_check_mode_for_change(un, ubf); 17541 if (rval) { 17542 rval = st_gen_mode_select(un, ubf, un->un_mspl, 17543 sizeof (struct seq_mode)); 17544 } 17545 if (un->un_tlr_flag != TLR_NOT_SUPPORTED) { 17546 rval |= st_set_target_TLR_mode(un, ubf); 17547 } 17548 return (rval); 17549 } 17550 17551 static int 17552 st_check_mode_for_change(struct scsi_tape *un, ubufunc_t ubf) 17553 { 17554 struct seq_mode *current; 17555 int rval; 17556 int i; 17557 caddr_t this; 17558 caddr_t that; 17559 17560 ST_FUNC(ST_DEVINFO, st_check_mode_for_change); 17561 17562 /* recovery called with mode tamper before mode selection */ 17563 if (un->un_comp_page == (ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE)) { 17564 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17565 "Mode Select not done yet"); 17566 return (0); 17567 } 17568 17569 current = kmem_zalloc(sizeof (struct seq_mode), KM_SLEEP); 17570 17571 rval = st_gen_mode_sense(un, ubf, un->un_comp_page, current, 17572 sizeof (struct seq_mode)); 17573 if (rval != 0) { 17574 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17575 "Mode Sense for mode verification failed"); 17576 kmem_free(current, sizeof (struct seq_mode)); 17577 return (rval); 17578 } 17579 17580 this = (caddr_t)current; 17581 that = (caddr_t)un->un_mspl; 17582 17583 rval = bcmp(this, that, sizeof (struct seq_mode)); 17584 if (rval == 0) { 17585 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17586 "Found no changes in mode data"); 17587 } 17588 #ifdef STDEBUG 17589 else { 17590 for (i = 1; i < sizeof (struct seq_mode); i++) { 17591 if (this[i] != that[i]) { 17592 ST_RECOV(ST_DEVINFO, st_label, CE_CONT, 17593 "sense data changed at byte %d was " 17594 "0x%x now 0x%x", i, 17595 (uchar_t)that[i], (uchar_t)this[i]); 17596 } 17597 } 17598 } 17599 #endif 17600 kmem_free(current, sizeof (struct seq_mode)); 17601 17602 return (rval); 17603 } 17604 17605 static int 17606 st_test_path_to_device(struct scsi_tape *un) 17607 { 17608 int rval = 0; 17609 int limit = st_retry_count; 17610 17611 ST_FUNC(ST_DEVINFO, st_test_path_to_device); 17612 17613 /* 17614 * XXX Newer drives may not RESEVATION CONFLICT a TUR. 17615 */ 17616 do { 17617 if (rval != 0) { 17618 mutex_exit(ST_MUTEX); 17619 delay(drv_usectohz(1000000)); 17620 mutex_enter(ST_MUTEX); 17621 } 17622 rval = st_rcmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 17623 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17624 "ping TUR returned 0x%x", rval); 17625 limit--; 17626 } while (((rval == EACCES) || (rval == EBUSY)) && limit); 17627 17628 if (un->un_status == KEY_NOT_READY || un->un_mediastate == MTIO_EJECTED) 17629 rval = 0; 17630 17631 return (rval); 17632 } 17633 17634 /* 17635 * Does read position using recov_buf and doesn't update un_pos. 17636 * Does what ever kind of read position you want. 17637 */ 17638 static int 17639 st_recovery_read_pos(struct scsi_tape *un, read_p_types type, 17640 read_pos_data_t *raw) 17641 { 17642 int rval; 17643 struct uscsi_cmd cmd; 17644 struct scsi_arq_status status; 17645 char cdb[CDB_GROUP1]; 17646 17647 ST_FUNC(ST_DEVINFO, st_recovery_read_pos); 17648 bzero(&cmd, sizeof (cmd)); 17649 17650 cdb[0] = SCMD_READ_POSITION; 17651 cdb[1] = type; 17652 cdb[2] = 0; 17653 cdb[3] = 0; 17654 cdb[4] = 0; 17655 cdb[5] = 0; 17656 cdb[6] = 0; 17657 cdb[7] = 0; 17658 cdb[8] = (type == EXT_POS) ? 28 : 0; 17659 cdb[9] = 0; 17660 17661 cmd.uscsi_flags = USCSI_READ | USCSI_RQENABLE; 17662 cmd.uscsi_timeout = un->un_dp->non_motion_timeout; 17663 cmd.uscsi_cdb = cdb; 17664 cmd.uscsi_cdblen = sizeof (cdb); 17665 cmd.uscsi_rqlen = sizeof (status); 17666 cmd.uscsi_rqbuf = (caddr_t)&status; 17667 cmd.uscsi_bufaddr = (caddr_t)raw; 17668 switch (type) { 17669 case SHORT_POS: 17670 cmd.uscsi_buflen = sizeof (tape_position_t); 17671 break; 17672 case LONG_POS: 17673 cmd.uscsi_buflen = sizeof (tape_position_long_t); 17674 break; 17675 case EXT_POS: 17676 cmd.uscsi_buflen = sizeof (tape_position_ext_t); 17677 break; 17678 default: 17679 ASSERT(0); 17680 } 17681 17682 rval = st_uscsi_rcmd(un, &cmd, FKIOCTL); 17683 if (cmd.uscsi_status) { 17684 rval = EIO; 17685 } 17686 return (rval); 17687 } 17688 17689 static int 17690 st_recovery_get_position(struct scsi_tape *un, tapepos_t *read, 17691 read_pos_data_t *raw) 17692 { 17693 int rval; 17694 read_p_types type = un->un_read_pos_type; 17695 17696 ST_FUNC(ST_DEVINFO, st_recovery_get_position); 17697 17698 do { 17699 rval = st_recovery_read_pos(un, type, raw); 17700 if (rval != 0) { 17701 switch (type) { 17702 case SHORT_POS: 17703 type = NO_POS; 17704 break; 17705 17706 case LONG_POS: 17707 type = EXT_POS; 17708 break; 17709 17710 case EXT_POS: 17711 type = SHORT_POS; 17712 break; 17713 17714 default: 17715 type = LONG_POS; 17716 break; 17717 17718 } 17719 } else { 17720 if (type != un->un_read_pos_type) { 17721 un->un_read_pos_type = type; 17722 } 17723 break; 17724 } 17725 } while (type != NO_POS); 17726 17727 if (rval == 0) { 17728 rval = st_interpret_read_pos(un, read, type, 17729 sizeof (read_pos_data_t), (caddr_t)raw, 1); 17730 } 17731 return (rval); 17732 } 17733 17734 /* 17735 * based on the command do we retry, continue or give up? 17736 * possable return values? 17737 * zero do nothing looks fine. 17738 * EAGAIN retry. 17739 * EIO failed makes no sense. 17740 */ 17741 static int 17742 st_compare_expected_position(struct scsi_tape *un, st_err_info *ei, 17743 cmd_attribute const * cmd_att, tapepos_t *read) 17744 { 17745 int rval; 17746 read_pos_data_t *readp_datap; 17747 17748 ST_FUNC(ST_DEVINFO, st_compare_expected_position); 17749 17750 ASSERT(un != NULL); 17751 ASSERT(ei != NULL); 17752 ASSERT(read != NULL); 17753 ASSERT(cmd_att->chg_tape_pos); 17754 17755 COPY_POS(read, &ei->ei_expected_pos); 17756 17757 readp_datap = kmem_zalloc(sizeof (read_pos_data_t), KM_SLEEP); 17758 17759 rval = st_recovery_get_position(un, read, readp_datap); 17760 17761 kmem_free(readp_datap, sizeof (read_pos_data_t)); 17762 17763 if (rval != 0) { 17764 return (EIO); 17765 } 17766 17767 ST_POS(ST_DEVINFO, "st_compare_expected_position", read); 17768 17769 if ((read->pmode == invalid) || 17770 (ei->ei_expected_pos.pmode == invalid)) { 17771 return (EIO); 17772 } 17773 17774 /* 17775 * Command that changes tape position and have an expected position 17776 * if it were to chave completed sucessfully. 17777 */ 17778 if (cmd_att->recov_pos_type == POS_EXPECTED) { 17779 uint32_t count; 17780 int64_t difference; 17781 uchar_t reposition = 0; 17782 17783 ASSERT(cmd_att->get_cnt); 17784 count = cmd_att->get_cnt(ei->ei_failed_pkt.pkt_cdbp); 17785 17786 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17787 "Got count from CDB and it was %d\n", count); 17788 17789 /* 17790 * At expected? 17791 */ 17792 if (read->lgclblkno == ei->ei_expected_pos.lgclblkno) { 17793 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17794 "Found drive to be at expected position\n"); 17795 17796 /* 17797 * If the command should move tape and it got a busy 17798 * it shouldn't be in the expected position. 17799 */ 17800 if (ei->ei_failing_status.sts_status.sts_busy != 0) { 17801 reposition = 1; 17802 17803 /* 17804 * If the command doesn't transfer data should be good. 17805 */ 17806 } else if (cmd_att->transfers_data == TRAN_NONE) { 17807 return (0); /* Good */ 17808 17809 /* 17810 * Command transfers data, should have done so. 17811 */ 17812 } else if (ei->ei_failed_pkt.pkt_state & 17813 STATE_XFERRED_DATA) { 17814 return (0); /* Good */ 17815 } else { 17816 reposition = 1; 17817 } 17818 } 17819 17820 if (cmd_att->chg_tape_direction == DIR_FORW) { 17821 difference = 17822 ei->ei_expected_pos.lgclblkno - read->lgclblkno; 17823 17824 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17825 "difference between expected and actual is %" 17826 PRId64"\n", difference); 17827 if (count == difference && reposition == 0) { 17828 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17829 "Found failed FORW command, retrying\n"); 17830 return (EAGAIN); 17831 } 17832 17833 /* 17834 * If rewound or somewhere between the starting position 17835 * and the expected position (partial read or write). 17836 * Locate to the starting position and try the whole 17837 * thing over again. 17838 */ 17839 if ((read->lgclblkno == 0) || 17840 ((difference > 0) && (difference < count))) { 17841 rval = st_logical_block_locate(un, 17842 st_uscsi_rcmd, read, 17843 ei->ei_expected_pos.lgclblkno - count, 17844 ei->ei_expected_pos.partition); 17845 if (rval == 0) { 17846 ST_RECOV(ST_DEVINFO, st_label, 17847 CE_NOTE, "reestablished FORW" 17848 " command retrying\n"); 17849 return (EAGAIN); 17850 } 17851 /* 17852 * This handles flushed read ahead on the drive or 17853 * an aborted read that presents as a busy and advanced 17854 * the tape position. 17855 */ 17856 } else if ((cmd_att->transfers_data == TRAN_READ) && 17857 ((difference < 0) || (reposition == 1))) { 17858 rval = st_logical_block_locate(un, 17859 st_uscsi_rcmd, read, 17860 ei->ei_expected_pos.lgclblkno - count, 17861 ei->ei_expected_pos.partition); 17862 if (rval == 0) { 17863 ST_RECOV(ST_DEVINFO, st_label, 17864 CE_NOTE, "reestablished FORW" 17865 " read command retrying\n"); 17866 return (EAGAIN); 17867 } 17868 /* 17869 * XXX swag seeing difference of 2 on write filemark. 17870 * If the space to the starting position works on a 17871 * write that means the previous write made it to tape. 17872 * If not we lost data and have to give up. 17873 * 17874 * The plot thickens. Now I am attempting to cover a 17875 * count of 1 and a differance of 2 on a write. 17876 */ 17877 } else if ((difference > count) || (reposition == 1)) { 17878 rval = st_logical_block_locate(un, 17879 st_uscsi_rcmd, read, 17880 ei->ei_expected_pos.lgclblkno - count, 17881 ei->ei_expected_pos.partition); 17882 if (rval == 0) { 17883 ST_RECOV(ST_DEVINFO, st_label, 17884 CE_NOTE, "reestablished FORW" 17885 " write command retrying\n"); 17886 return (EAGAIN); 17887 } 17888 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17889 "Seek to block %"PRId64" returned %d\n", 17890 ei->ei_expected_pos.lgclblkno - count, 17891 rval); 17892 } else { 17893 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17894 "Not expected transfers_data = %d " 17895 "difference = %"PRId64, 17896 cmd_att->transfers_data, difference); 17897 } 17898 17899 return (EIO); 17900 17901 } else if (cmd_att->chg_tape_direction == DIR_REVC) { 17902 /* Don't think we can write backwards */ 17903 ASSERT(cmd_att->transfers_data != TRAN_WRTE); 17904 difference = 17905 read->lgclblkno - ei->ei_expected_pos.lgclblkno; 17906 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17907 "difference between expected and actual is %" 17908 PRId64"\n", difference); 17909 if (count == difference && reposition == 0) { 17910 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17911 "Found failed REVC command, retrying\n"); 17912 return (EAGAIN); 17913 } 17914 if ((read->lgclblkno == 0) || 17915 ((difference > 0) && (difference < count))) { 17916 rval = st_logical_block_locate(un, 17917 st_uscsi_rcmd, read, 17918 ei->ei_expected_pos.lgclblkno + count, 17919 ei->ei_expected_pos.partition); 17920 if (rval == 0) { 17921 ST_RECOV(ST_DEVINFO, st_label, 17922 CE_NOTE, "reestablished REVC" 17923 " command retrying\n"); 17924 return (EAGAIN); 17925 } 17926 /* This handles read ahead in reverse direction */ 17927 } else if ((cmd_att->transfers_data == TRAN_READ) && 17928 (difference < 0) || (reposition == 1)) { 17929 rval = st_logical_block_locate(un, 17930 st_uscsi_rcmd, read, 17931 ei->ei_expected_pos.lgclblkno - count, 17932 ei->ei_expected_pos.partition); 17933 if (rval == 0) { 17934 ST_RECOV(ST_DEVINFO, st_label, 17935 CE_NOTE, "reestablished REVC" 17936 " read command retrying\n"); 17937 return (EAGAIN); 17938 } 17939 } else { 17940 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17941 "Not expected transfers_data = %d " 17942 "difference = %"PRId64, 17943 cmd_att->transfers_data, difference); 17944 } 17945 return (EIO); 17946 17947 } else { 17948 /* 17949 * Commands that change tape position either 17950 * direction or don't change position should not 17951 * get here. 17952 */ 17953 ASSERT(0); 17954 } 17955 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17956 "Didn't find a recoverable position, Failing\n"); 17957 17958 /* 17959 * Command that changes tape position and can only be recovered 17960 * by going back to the point of origin and retrying. 17961 * 17962 * Example SCMD_SPACE. 17963 */ 17964 } else if (cmd_att->recov_pos_type == POS_STARTING) { 17965 /* 17966 * This type of command stores the starting position. 17967 * If the read position is the starting position, 17968 * reissue the command. 17969 */ 17970 if (ei->ei_expected_pos.lgclblkno == read->lgclblkno) { 17971 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17972 "Found Space command at starting position, " 17973 "Reissuing\n"); 17974 return (EAGAIN); 17975 } 17976 /* 17977 * Not in the position that the command was originally issued, 17978 * Attempt to locate to that position. 17979 */ 17980 rval = st_logical_block_locate(un, st_uscsi_rcmd, read, 17981 ei->ei_expected_pos.lgclblkno, 17982 ei->ei_expected_pos.partition); 17983 if (rval) { 17984 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17985 "Found Space at an unexpected position and locate " 17986 "back to starting position failed\n"); 17987 return (EIO); 17988 } 17989 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17990 "Found Space at an unexpected position and locate " 17991 "back to starting position worked, Reissuing\n"); 17992 return (EAGAIN); 17993 } 17994 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 17995 "Unhandled attribute/expected position", &ei->ei_expected_pos); 17996 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 17997 "Read position above did not make sense", read); 17998 ASSERT(0); 17999 return (EIO); 18000 } 18001 18002 static errstate 18003 st_recover_reissue_pkt(struct scsi_tape *un, struct scsi_pkt *oldpkt) 18004 { 18005 buf_t *bp; 18006 buf_t *pkt_bp; 18007 struct scsi_pkt *newpkt; 18008 cmd_attribute const *attrib; 18009 recov_info *rcv = oldpkt->pkt_private; 18010 uint_t cdblen; 18011 int queued = 0; 18012 int rval; 18013 int flags = 0; 18014 int stat_size = 18015 (un->un_arq_enabled ? sizeof (struct scsi_arq_status) : 1); 18016 18017 ST_FUNC(ST_DEVINFO, st_recover_reissue_pkt); 18018 18019 bp = rcv->cmd_bp; 18020 18021 if (rcv->privatelen == sizeof (recov_info)) { 18022 attrib = rcv->cmd_attrib; 18023 } else { 18024 attrib = st_lookup_cmd_attribute(oldpkt->pkt_cdbp[0]); 18025 } 18026 18027 /* 18028 * Some non-uscsi commands use the b_bcount for values that 18029 * have nothing to do with how much data is transfered. 18030 * In those cases we need to hide the buf_t from scsi_init_pkt(). 18031 */ 18032 if ((BP_UCMD(bp)) && (bp->b_bcount)) { 18033 pkt_bp = bp; 18034 } else if (attrib->transfers_data == TRAN_NONE) { 18035 pkt_bp = NULL; 18036 } else { 18037 pkt_bp = bp; 18038 } 18039 18040 /* 18041 * if this is a queued command make sure it the only one in the 18042 * run queue. 18043 */ 18044 if (bp != un->un_sbufp && bp != un->un_recov_buf) { 18045 ASSERT(un->un_runqf == un->un_runql); 18046 ASSERT(un->un_runqf == bp); 18047 queued = 1; 18048 } 18049 18050 cdblen = scsi_cdb_size[CDB_GROUPID(oldpkt->pkt_cdbp[0])]; 18051 18052 if (pkt_bp == un->un_rqs_bp) { 18053 flags |= PKT_CONSISTENT; 18054 stat_size = 1; 18055 } 18056 18057 newpkt = scsi_init_pkt(ROUTE, NULL, pkt_bp, cdblen, 18058 stat_size, rcv->privatelen, flags, NULL_FUNC, NULL); 18059 if (newpkt == NULL) { 18060 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 18061 "Reissue pkt scsi_init_pkt() failure\n"); 18062 return (COMMAND_DONE_ERROR); 18063 } 18064 18065 ASSERT(newpkt->pkt_resid == 0); 18066 bp->b_flags &= ~(B_DONE); 18067 bp->b_resid = 0; 18068 st_bioerror(bp, 0); 18069 18070 bcopy(oldpkt->pkt_private, newpkt->pkt_private, rcv->privatelen); 18071 18072 newpkt->pkt_comp = oldpkt->pkt_comp; 18073 newpkt->pkt_time = oldpkt->pkt_time; 18074 18075 bzero(newpkt->pkt_scbp, stat_size); 18076 bcopy(oldpkt->pkt_cdbp, newpkt->pkt_cdbp, cdblen); 18077 18078 newpkt->pkt_state = 0; 18079 newpkt->pkt_statistics = 0; 18080 18081 /* 18082 * oldpkt passed in was a copy of the original. 18083 * to distroy we need the address of the original. 18084 */ 18085 oldpkt = BP_PKT(bp); 18086 18087 if (oldpkt == un->un_rqs) { 18088 ASSERT(bp == un->un_rqs_bp); 18089 un->un_rqs = newpkt; 18090 } 18091 18092 SET_BP_PKT(bp, newpkt); 18093 18094 scsi_destroy_pkt(oldpkt); 18095 18096 rval = st_transport(un, newpkt); 18097 if (rval == TRAN_ACCEPT) { 18098 return (JUST_RETURN); 18099 } 18100 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 18101 "Reissue pkt st_transport(0x%x) failure\n", rval); 18102 if (rval != TRAN_BUSY) { 18103 return (COMMAND_DONE_ERROR); 18104 } 18105 mutex_exit(ST_MUTEX); 18106 rval = st_handle_start_busy(un, bp, ST_TRAN_BUSY_TIMEOUT, queued); 18107 mutex_enter(ST_MUTEX); 18108 if (rval) { 18109 return (COMMAND_DONE_ERROR); 18110 } 18111 18112 return (JUST_RETURN); 18113 } 18114 18115 static int 18116 st_transport(struct scsi_tape *un, struct scsi_pkt *pkt) 18117 { 18118 int status; 18119 18120 ST_FUNC(ST_DEVINFO, st_transport); 18121 18122 ST_CDB(ST_DEVINFO, "transport CDB", (caddr_t)pkt->pkt_cdbp); 18123 18124 mutex_exit(ST_MUTEX); 18125 18126 status = scsi_transport(pkt); 18127 18128 mutex_enter(ST_MUTEX); 18129 18130 return (status); 18131 } 18132 18133 /* 18134 * Removed the buf_t bp from the queue referenced to by head and tail. 18135 * Returns the buf_t pointer if it is found in the queue. 18136 * Returns NULL if it is not found. 18137 */ 18138 static buf_t * 18139 st_remove_from_queue(buf_t **head, buf_t **tail, buf_t *bp) 18140 { 18141 buf_t *runqbp; 18142 buf_t *prevbp = NULL; 18143 18144 for (runqbp = *head; runqbp != 0; runqbp = runqbp->av_forw) { 18145 if (runqbp == bp) { 18146 /* found it, is it at the head? */ 18147 if (runqbp == *head) { 18148 *head = bp->av_forw; 18149 } else { 18150 prevbp->av_forw = bp->av_forw; 18151 } 18152 if (*tail == bp) { 18153 *tail = prevbp; 18154 } 18155 bp->av_forw = NULL; 18156 return (bp); /* found and removed */ 18157 } 18158 prevbp = runqbp; 18159 } 18160 return (NULL); 18161 } 18162 18163 /* 18164 * Adds a buf_t to the queue pointed to by head and tail. 18165 * Adds it either to the head end or the tail end based on which 18166 * the passed variable end (head or tail) points at. 18167 */ 18168 static void 18169 st_add_to_queue(buf_t **head, buf_t **tail, buf_t *end, buf_t *bp) 18170 { 18171 18172 bp->av_forw = NULL; 18173 if (*head) { 18174 /* Queue is not empty */ 18175 if (end == *head) { 18176 /* Add at front of queue */ 18177 bp->av_forw = *head; 18178 *head = bp; 18179 } else if (end == *tail) { 18180 /* Add at end of queue */ 18181 (*tail)->av_forw = bp; 18182 *tail = bp; 18183 } else { 18184 ASSERT(0); 18185 } 18186 } else { 18187 /* Queue is empty */ 18188 *head = bp; 18189 *tail = bp; 18190 } 18191 } 18192 18193 18194 static uint64_t 18195 st_get_cdb_g0_rw_count(uchar_t *cdb) 18196 { 18197 uint64_t count; 18198 18199 if ((cdb[1]) & 1) { 18200 /* fixed block mode, the count is the number of blocks */ 18201 count = 18202 cdb[2] << 16 | 18203 cdb[3] << 8 | 18204 cdb[4]; 18205 } else { 18206 /* variable block mode, the count is the block size */ 18207 count = 1; 18208 } 18209 return (count); 18210 } 18211 18212 static uint64_t 18213 st_get_cdb_g0_sign_count(uchar_t *cdb) 18214 { 18215 uint64_t count; 18216 18217 count = 18218 cdb[2] << 16 | 18219 cdb[3] << 8 | 18220 cdb[4]; 18221 /* 18222 * If the sign bit of the 3 byte value is set, extended it. 18223 */ 18224 if (count & 0x800000) { 18225 count |= 0xffffffffff000000; 18226 } 18227 return (count); 18228 } 18229 18230 static uint64_t 18231 st_get_cdb_g0_count(uchar_t *cdb) 18232 { 18233 uint64_t count; 18234 18235 count = 18236 cdb[2] << 16 | 18237 cdb[3] << 8 | 18238 cdb[4]; 18239 return (count); 18240 } 18241 18242 static uint64_t 18243 st_get_cdb_g5_rw_cnt(uchar_t *cdb) 18244 { 18245 uint64_t count; 18246 18247 if ((cdb[1]) & 1) { 18248 /* fixed block mode */ 18249 count = 18250 cdb[12] << 16 | 18251 cdb[13] << 8 | 18252 cdb[14]; 18253 } else { 18254 /* variable block mode */ 18255 count = 1; 18256 } 18257 return (count); 18258 } 18259 18260 static uint64_t 18261 st_get_no_count(uchar_t *cdb) 18262 { 18263 ASSERT(cdb[0] == SCMD_REWIND); 18264 return ((uint64_t)cdb[0]); 18265 } 18266 18267 static uint64_t 18268 st_get_load_options(uchar_t *cdb) 18269 { 18270 return ((uint64_t)(cdb[4] | (LD_HOLD << 1))); 18271 } 18272 18273 static uint64_t 18274 st_get_erase_options(uchar_t *cdb) 18275 { 18276 return (cdb[1] | (cdb[0] << 8)); 18277 } 18278 18279 static uint64_t 18280 st_get_cdb_g1_lba(uchar_t *cdb) 18281 { 18282 uint64_t lba; 18283 18284 lba = 18285 cdb[3] << 24 | 18286 cdb[4] << 16 | 18287 cdb[5] << 8 | 18288 cdb[6]; 18289 return (lba); 18290 } 18291 18292 static uint64_t 18293 st_get_cdb_g5_count(uchar_t *cdb) 18294 { 18295 uint64_t count = 18296 cdb[12] << 16 | 18297 cdb[13] << 8 | 18298 cdb[14]; 18299 18300 return (count); 18301 } 18302 18303 static uint64_t 18304 st_get_cdb_g4g5_cnt(uchar_t *cdb) 18305 { 18306 uint64_t lba; 18307 18308 lba = 18309 (uint64_t)cdb[4] << 56 | 18310 (uint64_t)cdb[5] << 48 | 18311 (uint64_t)cdb[6] << 40 | 18312 (uint64_t)cdb[7] << 32 | 18313 (uint64_t)cdb[8] << 24 | 18314 (uint64_t)cdb[9] << 16 | 18315 (uint64_t)cdb[10] << 8 | 18316 (uint64_t)cdb[11]; 18317 return (lba); 18318 } 18319 18320 static const cmd_attribute cmd_attributes[] = { 18321 { SCMD_READ, 18322 1, 0, 1, 0, 0, DIR_FORW, TRAN_READ, POS_EXPECTED, 18323 0, 0, 0, st_get_cdb_g0_rw_count }, 18324 { SCMD_WRITE, 18325 1, 0, 1, 1, 0, DIR_FORW, TRAN_WRTE, POS_EXPECTED, 18326 0, 0, 0, st_get_cdb_g0_rw_count }, 18327 { SCMD_TEST_UNIT_READY, 18328 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18329 0, 0, 0 }, 18330 { SCMD_REWIND, 18331 1, 1, 1, 0, 0, DIR_REVC, TRAN_NONE, POS_EXPECTED, 18332 0, 0, 0, st_get_no_count }, 18333 { SCMD_REQUEST_SENSE, 18334 0, 0, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18335 0, 0, 0 }, 18336 { SCMD_READ_BLKLIM, 18337 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18338 0, 0, 0 }, 18339 { SCMD_READ_G4, 18340 1, 0, 1, 0, 1, DIR_FORW, TRAN_READ, POS_EXPECTED, 18341 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 18342 { SCMD_WRITE_G4, 18343 1, 0, 1, 1, 1, DIR_FORW, TRAN_WRTE, POS_EXPECTED, 18344 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 18345 { SCMD_READ_REVERSE, 18346 1, 0, 1, 1, 0, DIR_REVC, TRAN_READ, POS_EXPECTED, 18347 0, 0, 0, st_get_cdb_g0_rw_count }, 18348 { SCMD_READ_REVERSE_G4, 18349 1, 0, 1, 1, 1, DIR_REVC, TRAN_READ, POS_EXPECTED, 18350 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 18351 { SCMD_WRITE_FILE_MARK, 18352 1, 0, 1, 1, 0, DIR_FORW, TRAN_NONE, POS_EXPECTED, 18353 0, 0, 0, st_get_cdb_g0_count }, 18354 { SCMD_WRITE_FILE_MARK_G4, 18355 1, 0, 1, 1, 1, DIR_FORW, TRAN_NONE, POS_EXPECTED, 18356 0, 0, 0, st_get_cdb_g5_count, st_get_cdb_g4g5_cnt }, 18357 { SCMD_SPACE, 18358 1, 0, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_STARTING, 18359 0, 0, 0, st_get_cdb_g0_sign_count }, 18360 { SCMD_SPACE_G4, 18361 1, 0, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_STARTING, 18362 0, 0, 0, st_get_cdb_g4g5_cnt }, 18363 { SCMD_INQUIRY, 18364 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18365 0, 0, 0 }, 18366 { SCMD_VERIFY_G0, 18367 1, 0, 1, 0, 0, DIR_FORW, TRAN_NONE, POS_EXPECTED, 18368 0, 0, 0, st_get_cdb_g0_rw_count }, 18369 { SCMD_VERIFY_G4, 18370 1, 0, 1, 0, 1, DIR_FORW, TRAN_NONE, POS_EXPECTED, 18371 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 18372 { SCMD_RECOVER_BUF, 18373 1, 0, 1, 1, 0, DIR_REVC, TRAN_READ, POS_EXPECTED, 18374 0, 0, 0 }, 18375 { SCMD_MODE_SELECT, 18376 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18377 0, 0, 0 }, 18378 { SCMD_RESERVE, 18379 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18380 0, 0, 0 }, 18381 { SCMD_RELEASE, 18382 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18383 0, 0, 0 }, 18384 { SCMD_ERASE, 18385 1, 0, 1, 1, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18386 0, 0, 0, st_get_erase_options }, 18387 { SCMD_MODE_SENSE, 18388 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18389 0, 0, 0 }, 18390 { SCMD_LOAD, 18391 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 18392 0, 0, 0, st_get_load_options }, 18393 { SCMD_GDIAG, 18394 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18395 1, 0, 0 }, 18396 { SCMD_SDIAG, 18397 1, 0, 1, 1, 0, DIR_EITH, TRAN_WRTE, POS_EXPECTED, 18398 1, 0, 0 }, 18399 { SCMD_DOORLOCK, 18400 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 18401 0, 4, 3 }, 18402 { SCMD_LOCATE, 18403 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 18404 0, 0, 0, NULL, st_get_cdb_g1_lba }, 18405 { SCMD_READ_POSITION, 18406 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18407 0, 0, 0 }, 18408 { SCMD_WRITE_BUFFER, 18409 1, 0, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18410 1, 0, 0 }, 18411 { SCMD_READ_BUFFER, 18412 1, 0, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18413 1, 0, 0 }, 18414 { SCMD_REPORT_DENSITIES, 18415 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18416 0, 0, 0 }, 18417 { SCMD_LOG_SELECT_G1, 18418 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18419 0, 0, 0 }, 18420 { SCMD_LOG_SENSE_G1, 18421 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18422 0, 0, 0 }, 18423 { SCMD_PRIN, 18424 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18425 0, 0, 0 }, 18426 { SCMD_PROUT, 18427 0, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18428 0, 0, 0 }, 18429 { SCMD_READ_ATTRIBUTE, 18430 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18431 0, 0, 0 }, 18432 { SCMD_WRITE_ATTRIBUTE, 18433 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18434 0, 0, 0 }, 18435 { SCMD_LOCATE_G4, 18436 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 18437 0, 0, 0, NULL, st_get_cdb_g4g5_cnt }, 18438 { SCMD_REPORT_LUNS, 18439 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18440 0, 0, 0 }, 18441 { SCMD_SVC_ACTION_IN_G5, 18442 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18443 0, 0, 0 }, 18444 { SCMD_MAINTENANCE_IN, 18445 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 18446 0, 0, 0 }, 18447 { SCMD_MAINTENANCE_OUT, 18448 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 18449 0, 0, 0 }, 18450 { 0xff, /* Default attribute for unsupported commands */ 18451 1, 0, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_STARTING, 18452 1, 0, 0, NULL, NULL } 18453 }; 18454 18455 static const cmd_attribute * 18456 st_lookup_cmd_attribute(unsigned char cmd) 18457 { 18458 int i; 18459 cmd_attribute const *attribute; 18460 18461 for (i = 0; i < ST_NUM_MEMBERS(cmd_attributes); i++) { 18462 attribute = &cmd_attributes[i]; 18463 if (attribute->cmd == cmd) { 18464 return (attribute); 18465 } 18466 } 18467 ASSERT(attribute); 18468 return (attribute); 18469 } 18470 18471 static int 18472 st_reset(struct scsi_tape *un, int reset_type) 18473 { 18474 int rval; 18475 18476 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 18477 18478 ST_FUNC(ST_DEVINFO, st_reset); 18479 un->un_rsvd_status |= ST_INITIATED_RESET; 18480 mutex_exit(ST_MUTEX); 18481 do { 18482 rval = scsi_reset(&un->un_sd->sd_address, reset_type); 18483 if (rval == 0) { 18484 switch (reset_type) { 18485 case RESET_LUN: 18486 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 18487 "LUN reset failed trying target reset"); 18488 reset_type = RESET_TARGET; 18489 break; 18490 case RESET_TARGET: 18491 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 18492 "target reset failed trying bus reset"); 18493 reset_type = RESET_BUS; 18494 break; 18495 case RESET_BUS: 18496 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 18497 "bus reset failed trying all reset"); 18498 reset_type = RESET_ALL; 18499 default: 18500 mutex_enter(ST_MUTEX); 18501 return (rval); 18502 } 18503 } 18504 } while (rval == 0); 18505 mutex_enter(ST_MUTEX); 18506 return (rval); 18507 } 18508 18509 #define SAS_TLR_MOD_LEN sizeof (struct seq_mode) 18510 static int 18511 st_set_target_TLR_mode(struct scsi_tape *un, ubufunc_t ubf) 18512 { 18513 int ret; 18514 int amount = SAS_TLR_MOD_LEN; 18515 struct seq_mode *mode_data; 18516 18517 ST_FUNC(ST_DEVINFO, st_set_target_TLR_mode); 18518 18519 mode_data = kmem_zalloc(SAS_TLR_MOD_LEN, KM_SLEEP); 18520 ret = st_gen_mode_sense(un, ubf, 0x18, mode_data, amount); 18521 if (ret != DDI_SUCCESS) { 18522 if (ret != EACCES) 18523 un->un_tlr_flag = TLR_NOT_SUPPORTED; 18524 goto out; 18525 } 18526 if (mode_data->data_len != amount + 1) { 18527 amount = mode_data->data_len + 1; 18528 } 18529 /* Must be SAS protocol */ 18530 if (mode_data->page.saslun.protocol_id != 6) { 18531 un->un_tlr_flag = TLR_NOT_SUPPORTED; 18532 ret = ENOTSUP; 18533 goto out; 18534 } 18535 if (un->un_tlr_flag == TLR_SAS_ONE_DEVICE) { 18536 if (mode_data->page.saslun.tran_layer_ret == 1) 18537 goto out; 18538 mode_data->page.saslun.tran_layer_ret = 1; 18539 } else { 18540 if (mode_data->page.saslun.tran_layer_ret == 0) 18541 goto out; 18542 mode_data->page.saslun.tran_layer_ret = 0; 18543 } 18544 ret = st_gen_mode_select(un, ubf, mode_data, amount); 18545 if (ret != DDI_SUCCESS) { 18546 if (ret != EACCES) 18547 un->un_tlr_flag = TLR_NOT_SUPPORTED; 18548 } else { 18549 if (mode_data->page.saslun.tran_layer_ret == 0) 18550 un->un_tlr_flag = TLR_NOT_KNOWN; 18551 else 18552 un->un_tlr_flag = TLR_SAS_ONE_DEVICE; 18553 } 18554 #ifdef STDEBUG 18555 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, "TLR data sent", 18556 (char *)mode_data, amount); 18557 #endif 18558 out: 18559 kmem_free(mode_data, SAS_TLR_MOD_LEN); 18560 return (ret); 18561 } 18562 18563 18564 static void 18565 st_reset_notification(caddr_t arg) 18566 { 18567 struct scsi_tape *un = (struct scsi_tape *)arg; 18568 18569 ST_FUNC(ST_DEVINFO, st_reset_notification); 18570 mutex_enter(ST_MUTEX); 18571 18572 un->un_unit_attention_flags |= 2; 18573 if ((un->un_rsvd_status & (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 18574 ST_RESERVE) { 18575 un->un_rsvd_status |= ST_LOST_RESERVE; 18576 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 18577 "Lost Reservation notification"); 18578 } else { 18579 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 18580 "reset notification"); 18581 } 18582 18583 if ((un->un_restore_pos == 0) && 18584 (un->un_state == ST_STATE_CLOSED) || 18585 (un->un_state == ST_STATE_OPEN_PENDING_IO) || 18586 (un->un_state == ST_STATE_CLOSING)) { 18587 un->un_restore_pos = 1; 18588 } 18589 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 18590 "reset and state was %d\n", un->un_state); 18591 mutex_exit(ST_MUTEX); 18592 }