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 2007 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 /* 30 * SCSI SCSA-compliant and not-so-DDI-compliant Tape Driver 31 */ 32 33 #if defined(lint) && !defined(DEBUG) 34 #define DEBUG 1 35 #endif 36 37 #include <sys/modctl.h> 38 #include <sys/scsi/scsi.h> 39 #include <sys/mtio.h> 40 #include <sys/scsi/targets/stdef.h> 41 #include <sys/file.h> 42 #include <sys/kstat.h> 43 #include <sys/ddidmareq.h> 44 #include <sys/ddi.h> 45 #include <sys/sunddi.h> 46 #include <sys/byteorder.h> 47 48 #define IOSP KSTAT_IO_PTR(un->un_stats) 49 /* 50 * stats maintained only for reads/writes as commands 51 * like rewind etc skew the wait/busy times 52 */ 53 #define IS_RW(bp) ((bp)->b_bcount > 0) 54 #define ST_DO_KSTATS(bp, kstat_function) \ 55 if ((bp != un->un_sbufp) && un->un_stats && IS_RW(bp)) { \ 56 kstat_function(IOSP); \ 57 } 58 59 #define ST_DO_ERRSTATS(un, x) \ 60 if (un->un_errstats) { \ 61 struct st_errstats *stp; \ 62 stp = (struct st_errstats *)un->un_errstats->ks_data; \ 63 stp->x.value.ul++; \ 64 } 65 66 #define FILL_SCSI1_LUN(devp, pkt) \ 67 if ((devp)->sd_inq->inq_ansi == 0x1) { \ 68 int _lun; \ 69 _lun = ddi_prop_get_int(DDI_DEV_T_ANY, (devp)->sd_dev, \ 70 DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0); \ 71 if (_lun > 0) { \ 72 ((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun = \ 73 _lun; \ 74 } \ 75 } 76 77 /* 78 * get an available contig mem header, cp. 79 * when big_enough is true, we will return NULL, if no big enough 80 * contig mem is found. 81 * when big_enough is false, we will try to find cp containing big 82 * enough contig mem. if not found, we will ruturn the last cp available. 83 * 84 * used by st_get_contig_mem() 85 */ 86 #define ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough) { \ 87 struct contig_mem *tmp_cp = NULL; \ 88 for ((cp) = (un)->un_contig_mem; \ 89 (cp) != NULL; \ 90 tmp_cp = (cp), (cp) = (cp)->cm_next) { \ 91 if (((cp)->cm_len >= (len)) || \ 92 (!(big_enough) && ((cp)->cm_next == NULL))) { \ 93 if (tmp_cp == NULL) { \ 94 (un)->un_contig_mem = (cp)->cm_next; \ 95 } else { \ 96 tmp_cp->cm_next = (cp)->cm_next; \ 97 } \ 98 (cp)->cm_next = NULL; \ 99 (un)->un_contig_mem_available_num--; \ 100 break; \ 101 } \ 102 } \ 103 } 104 105 #define ST_NUM_MEMBERS(array) (sizeof (array) / sizeof (array[0])) 106 #define COPY_POS(dest, source) bcopy(source, dest, sizeof (tapepos_t)) 107 #define ISALNUM(byte) \ 108 (((byte) >= 'a' && (byte) <= 'z') || \ 109 ((byte) >= 'A' && (byte) <= 'Z') || \ 110 ((byte) >= '0' && (byte) <= '9')) 111 112 #define ONE_K 1024 113 114 /* 115 * Global External Data Definitions 116 */ 117 extern struct scsi_key_strings scsi_cmds[]; 118 extern uchar_t scsi_cdb_size[]; 119 120 /* 121 * Local Static Data 122 */ 123 static void *st_state; 124 static char *const st_label = "st"; 125 static volatile dev_info_t *st_lastdev; 126 static volatile int st_recov_sz = sizeof (recov_info); 127 128 #ifdef __x86 129 /* 130 * We need to use below DMA attr to alloc physically contiguous 131 * memory to do I/O in big block size 132 */ 133 static ddi_dma_attr_t st_contig_mem_dma_attr = { 134 DMA_ATTR_V0, /* version number */ 135 0x0, /* lowest usable address */ 136 0xFFFFFFFFull, /* high DMA address range */ 137 0xFFFFFFFFull, /* DMA counter register */ 138 1, /* DMA address alignment */ 139 1, /* DMA burstsizes */ 140 1, /* min effective DMA size */ 141 0xFFFFFFFFull, /* max DMA xfer size */ 142 0xFFFFFFFFull, /* segment boundary */ 143 1, /* s/g list length */ 144 1, /* granularity of device */ 145 0 /* DMA transfer flags */ 146 }; 147 148 static ddi_device_acc_attr_t st_acc_attr = { 149 DDI_DEVICE_ATTR_V0, 150 DDI_NEVERSWAP_ACC, 151 DDI_STRICTORDER_ACC 152 }; 153 154 /* set limitation for the number of contig_mem */ 155 static int st_max_contig_mem_num = ST_MAX_CONTIG_MEM_NUM; 156 #endif 157 158 /* 159 * Tunable parameters 160 * 161 * DISCLAIMER 162 * ---------- 163 * These parameters are intended for use only in system testing; if you use 164 * them in production systems, you do so at your own risk. Altering any 165 * variable not listed below may cause unpredictable system behavior. 166 * 167 * st_check_media_time 168 * 169 * Three second state check 170 * 171 * st_allow_large_xfer 172 * 173 * Gated with ST_NO_RECSIZE_LIMIT 174 * 175 * 0 - Transfers larger than 64KB will not be allowed 176 * regardless of the setting of ST_NO_RECSIZE_LIMIT 177 * 1 - Transfers larger than 64KB will be allowed 178 * if ST_NO_RECSIZE_LIMIT is TRUE for the drive 179 * 180 * st_report_soft_errors_on_close 181 * 182 * Gated with ST_SOFT_ERROR_REPORTING 183 * 184 * 0 - Errors will not be reported on close regardless 185 * of the setting of ST_SOFT_ERROR_REPORTING 186 * 187 * 1 - Errors will be reported on close if 188 * ST_SOFT_ERROR_REPORTING is TRUE for the drive 189 */ 190 static int st_selection_retry_count = ST_SEL_RETRY_COUNT; 191 static int st_retry_count = ST_RETRY_COUNT; 192 193 static int st_io_time = ST_IO_TIME; 194 static int st_long_timeout_x = ST_LONG_TIMEOUT_X; 195 196 static int st_space_time = ST_SPACE_TIME; 197 static int st_long_space_time_x = ST_LONG_SPACE_TIME_X; 198 199 static int st_error_level = SCSI_ERR_RETRYABLE; 200 static int st_check_media_time = 3000000; /* 3 Second State Check */ 201 202 static int st_max_throttle = ST_MAX_THROTTLE; 203 204 static clock_t st_wait_cmds_complete = ST_WAIT_CMDS_COMPLETE; 205 206 static int st_allow_large_xfer = 1; 207 static int st_report_soft_errors_on_close = 1; 208 209 /* 210 * End of tunable parameters list 211 */ 212 213 214 215 /* 216 * Asynchronous I/O and persistent errors, refer to PSARC/1995/228 217 * 218 * Asynchronous I/O's main offering is that it is a non-blocking way to do 219 * reads and writes. The driver will queue up all the requests it gets and 220 * have them ready to transport to the HBA. Unfortunately, we cannot always 221 * just ship the I/O requests to the HBA, as there errors and exceptions 222 * that may happen when we don't want the HBA to continue. Therein comes 223 * the flush-on-errors capability. If the HBA supports it, then st will 224 * send in st_max_throttle I/O requests at the same time. 225 * 226 * Persistent errors : This was also reasonably simple. In the interrupt 227 * routines, if there was an error or exception (FM, LEOT, media error, 228 * transport error), the persistent error bits are set and shuts everything 229 * down, but setting the throttle to zero. If we hit and exception in the 230 * HBA, and flush-on-errors were set, we wait for all outstanding I/O's to 231 * come back (with CMD_ABORTED), then flush all bp's in the wait queue with 232 * the appropriate error, and this will preserve order. Of course, depending 233 * on the exception we have to show a zero read or write before we show 234 * errors back to the application. 235 */ 236 237 extern const int st_ndrivetypes; /* defined in st_conf.c */ 238 extern const struct st_drivetype st_drivetypes[]; 239 extern const char st_conf_version[]; 240 241 #ifdef STDEBUG 242 static int st_soft_error_report_debug = 0; 243 volatile int st_debug = 0; 244 #endif 245 246 #define ST_MT02_NAME "Emulex MT02 QIC-11/24 " 247 248 static const struct vid_drivetype { 249 char *vid; 250 char type; 251 } st_vid_dt[] = { 252 {"LTO-CVE ", MT_LTO}, 253 {"QUANTUM ", MT_ISDLT}, 254 {"SONY ", MT_ISAIT}, 255 {"STK ", MT_ISSTK9840} 256 }; 257 258 static const struct driver_minor_data { 259 char *name; 260 int minor; 261 } st_minor_data[] = { 262 /* 263 * The top 4 entries are for the default densities, 264 * don't alter their position. 265 */ 266 {"", 0}, 267 {"n", MT_NOREWIND}, 268 {"b", MT_BSD}, 269 {"bn", MT_NOREWIND | MT_BSD}, 270 {"l", MT_DENSITY1}, 271 {"m", MT_DENSITY2}, 272 {"h", MT_DENSITY3}, 273 {"c", MT_DENSITY4}, 274 {"u", MT_DENSITY4}, 275 {"ln", MT_DENSITY1 | MT_NOREWIND}, 276 {"mn", MT_DENSITY2 | MT_NOREWIND}, 277 {"hn", MT_DENSITY3 | MT_NOREWIND}, 278 {"cn", MT_DENSITY4 | MT_NOREWIND}, 279 {"un", MT_DENSITY4 | MT_NOREWIND}, 280 {"lb", MT_DENSITY1 | MT_BSD}, 281 {"mb", MT_DENSITY2 | MT_BSD}, 282 {"hb", MT_DENSITY3 | MT_BSD}, 283 {"cb", MT_DENSITY4 | MT_BSD}, 284 {"ub", MT_DENSITY4 | MT_BSD}, 285 {"lbn", MT_DENSITY1 | MT_NOREWIND | MT_BSD}, 286 {"mbn", MT_DENSITY2 | MT_NOREWIND | MT_BSD}, 287 {"hbn", MT_DENSITY3 | MT_NOREWIND | MT_BSD}, 288 {"cbn", MT_DENSITY4 | MT_NOREWIND | MT_BSD}, 289 {"ubn", MT_DENSITY4 | MT_NOREWIND | MT_BSD} 290 }; 291 292 /* strings used in many debug and warning messages */ 293 static const char wr_str[] = "write"; 294 static const char rd_str[] = "read"; 295 static const char wrg_str[] = "writing"; 296 static const char rdg_str[] = "reading"; 297 static const char *space_strs[] = { 298 "records", 299 "filemarks", 300 "sequential filemarks", 301 "eod", 302 "setmarks", 303 "sequential setmarks", 304 "Reserved", 305 "Reserved" 306 }; 307 static const char *load_strs[] = { 308 "unload", /* LD_UNLOAD 0 */ 309 "load", /* LD_LOAD 1 */ 310 "retension", /* LD_RETEN 2 */ 311 "load reten", /* LD_LOAD | LD_RETEN 3 */ 312 "eod", /* LD_EOT 4 */ 313 "load EOD", /* LD_LOAD | LD_EOT 5 */ 314 "reten EOD", /* LD_RETEN | LD_EOT 6 */ 315 "load reten EOD" /* LD_LOAD|LD_RETEN|LD_EOT 7 */ 316 "hold", /* LD_HOLD 8 */ 317 "load and hold" /* LD_LOAD | LD_HOLD 9 */ 318 }; 319 320 const char *bogusID = "Unknown Media ID"; 321 322 /* default density offsets in the table above */ 323 #define DEF_BLANK 0 324 #define DEF_NOREWIND 1 325 #define DEF_BSD 2 326 #define DEF_BSD_NR 3 327 328 /* Sense Key, ASC/ASCQ for which tape ejection is needed */ 329 330 static struct tape_failure_code { 331 uchar_t key; 332 uchar_t add_code; 333 uchar_t qual_code; 334 } st_tape_failure_code[] = { 335 { KEY_HARDWARE_ERROR, 0x15, 0x01}, 336 { KEY_HARDWARE_ERROR, 0x44, 0x00}, 337 { KEY_HARDWARE_ERROR, 0x53, 0x00}, 338 { KEY_HARDWARE_ERROR, 0x53, 0x01}, 339 { KEY_NOT_READY, 0x53, 0x00}, 340 { 0xff} 341 }; 342 343 /* clean bit position and mask */ 344 345 static struct cln_bit_position { 346 ushort_t cln_bit_byte; 347 uchar_t cln_bit_mask; 348 } st_cln_bit_position[] = { 349 { 21, 0x08}, 350 { 70, 0xc0}, 351 { 18, 0x81} /* 80 bit indicates in bit mode, 1 bit clean light is on */ 352 }; 353 354 /* 355 * architecture dependent allocation restrictions. For x86, we'll set 356 * dma_attr_addr_hi to st_max_phys_addr and dma_attr_sgllen to 357 * st_sgl_size during _init(). 358 */ 359 #if defined(__sparc) 360 static ddi_dma_attr_t st_alloc_attr = { 361 DMA_ATTR_V0, /* version number */ 362 0x0, /* lowest usable address */ 363 0xFFFFFFFFull, /* high DMA address range */ 364 0xFFFFFFFFull, /* DMA counter register */ 365 1, /* DMA address alignment */ 366 1, /* DMA burstsizes */ 367 1, /* min effective DMA size */ 368 0xFFFFFFFFull, /* max DMA xfer size */ 369 0xFFFFFFFFull, /* segment boundary */ 370 1, /* s/g list length */ 371 512, /* granularity of device */ 372 0 /* DMA transfer flags */ 373 }; 374 #elif defined(__x86) 375 static ddi_dma_attr_t st_alloc_attr = { 376 DMA_ATTR_V0, /* version number */ 377 0x0, /* lowest usable address */ 378 0x0, /* high DMA address range [set in _init()] */ 379 0xFFFFull, /* DMA counter register */ 380 512, /* DMA address alignment */ 381 1, /* DMA burstsizes */ 382 1, /* min effective DMA size */ 383 0xFFFFFFFFull, /* max DMA xfer size */ 384 0xFFFFFFFFull, /* segment boundary */ 385 0, /* s/g list length */ 386 512, /* granularity of device [set in _init()] */ 387 0 /* DMA transfer flags */ 388 }; 389 uint64_t st_max_phys_addr = 0xFFFFFFFFull; 390 int st_sgl_size = 0xF; 391 392 #endif 393 394 /* 395 * Configuration Data: 396 * 397 * Device driver ops vector 398 */ 399 static int st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p); 400 static int st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p); 401 static int st_read(dev_t dev, struct uio *uio_p, cred_t *cred_p); 402 static int st_write(dev_t dev, struct uio *uio_p, cred_t *cred_p); 403 static int st_open(dev_t *devp, int flag, int otyp, cred_t *cred_p); 404 static int st_close(dev_t dev, int flag, int otyp, cred_t *cred_p); 405 static int st_strategy(struct buf *bp); 406 static int st_queued_strategy(buf_t *bp); 407 static int st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, 408 cred_t *cred_p, int *rval_p); 409 extern int nulldev(), nodev(); 410 411 static struct cb_ops st_cb_ops = { 412 st_open, /* open */ 413 st_close, /* close */ 414 st_queued_strategy, /* strategy Not Block device but async checks */ 415 nodev, /* print */ 416 nodev, /* dump */ 417 st_read, /* read */ 418 st_write, /* write */ 419 st_ioctl, /* ioctl */ 420 nodev, /* devmap */ 421 nodev, /* mmap */ 422 nodev, /* segmap */ 423 nochpoll, /* poll */ 424 ddi_prop_op, /* cb_prop_op */ 425 0, /* streamtab */ 426 D_64BIT | D_MP | D_NEW | D_HOTPLUG | 427 D_OPEN_RETURNS_EINTR, /* cb_flag */ 428 CB_REV, /* cb_rev */ 429 st_aread, /* async I/O read entry point */ 430 st_awrite /* async I/O write entry point */ 431 432 }; 433 434 static int st_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 435 void **result); 436 static int st_probe(dev_info_t *dev); 437 static int st_attach(dev_info_t *dev, ddi_attach_cmd_t cmd); 438 static int st_detach(dev_info_t *dev, ddi_detach_cmd_t cmd); 439 440 static struct dev_ops st_ops = { 441 DEVO_REV, /* devo_rev, */ 442 0, /* refcnt */ 443 st_info, /* info */ 444 nulldev, /* identify */ 445 st_probe, /* probe */ 446 st_attach, /* attach */ 447 st_detach, /* detach */ 448 nodev, /* reset */ 449 &st_cb_ops, /* driver operations */ 450 (struct bus_ops *)0, /* bus operations */ 451 nulldev /* power */ 452 }; 453 454 /* 455 * Local Function Declarations 456 */ 457 static char *st_print_scsi_cmd(char cmd); 458 static void st_print_cdb(dev_info_t *dip, char *label, uint_t level, 459 char *title, char *cdb); 460 static void st_clean_print(dev_info_t *dev, char *label, uint_t level, 461 char *title, char *data, int len); 462 static int st_doattach(struct scsi_device *devp, int (*canwait)()); 463 static void st_known_tape_type(struct scsi_tape *un); 464 static int st_get_conf_from_st_dot_conf(struct scsi_tape *, char *, 465 struct st_drivetype *); 466 static int st_get_conf_from_st_conf_dot_c(struct scsi_tape *, char *, 467 struct st_drivetype *); 468 static int st_get_conf_from_tape_drive(struct scsi_tape *, char *, 469 struct st_drivetype *); 470 static int st_get_densities_from_tape_drive(struct scsi_tape *, 471 struct st_drivetype *); 472 static int st_get_timeout_values_from_tape_drive(struct scsi_tape *, 473 struct st_drivetype *); 474 static int st_get_timeouts_value(struct scsi_tape *, uchar_t, ushort_t *, 475 ushort_t); 476 static int st_get_default_conf(struct scsi_tape *, char *, 477 struct st_drivetype *); 478 static int st_rw(dev_t dev, struct uio *uio, int flag); 479 static int st_arw(dev_t dev, struct aio_req *aio, int flag); 480 static int st_find_eod(struct scsi_tape *un); 481 static int st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag); 482 static int st_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *, int flag); 483 static int st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag); 484 static int st_mtiocltop(struct scsi_tape *un, intptr_t arg, int flag); 485 static int st_do_mtioctop(struct scsi_tape *un, struct mtlop *mtop); 486 static void st_start(struct scsi_tape *un); 487 static int st_handle_start_busy(struct scsi_tape *un, struct buf *bp, 488 clock_t timeout_interval, int queued); 489 static int st_handle_intr_busy(struct scsi_tape *un, struct buf *bp, 490 clock_t timeout_interval); 491 static int st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp); 492 static void st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp); 493 static void st_init(struct scsi_tape *un); 494 static void st_make_cmd(struct scsi_tape *un, struct buf *bp, 495 int (*func)(caddr_t)); 496 static void st_make_uscsi_cmd(struct scsi_tape *, struct uscsi_cmd *, 497 struct buf *bp, int (*func)(caddr_t)); 498 static void st_intr(struct scsi_pkt *pkt); 499 static void st_set_state(struct scsi_tape *un, buf_t *bp); 500 static void st_test_append(struct buf *bp); 501 static int st_runout(caddr_t); 502 static int st_cmd(struct scsi_tape *un, int com, int64_t count, int wait); 503 static int st_setup_cmd(struct scsi_tape *un, buf_t *bp, int com, 504 int64_t count); 505 static int st_set_compression(struct scsi_tape *un); 506 static int st_write_fm(dev_t dev, int wfm); 507 static int st_determine_generic(struct scsi_tape *un); 508 static int st_determine_density(struct scsi_tape *un, int rw); 509 static int st_get_density(struct scsi_tape *un); 510 static int st_set_density(struct scsi_tape *un); 511 static int st_loadtape(struct scsi_tape *un); 512 static int st_modesense(struct scsi_tape *un); 513 static int st_modeselect(struct scsi_tape *un); 514 static errstate st_handle_incomplete(struct scsi_tape *un, struct buf *bp); 515 static int st_wrongtapetype(struct scsi_tape *un); 516 static errstate st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt); 517 static errstate st_handle_sense(struct scsi_tape *un, struct buf *bp, 518 tapepos_t *); 519 static errstate st_handle_autosense(struct scsi_tape *un, struct buf *bp, 520 tapepos_t *); 521 static int st_get_error_entry(struct scsi_tape *un, intptr_t arg, int flag); 522 static void st_update_error_stack(struct scsi_tape *un, struct scsi_pkt *pkt, 523 struct scsi_arq_status *cmd); 524 static void st_empty_error_stack(struct scsi_tape *un); 525 static errstate st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt, 526 struct scsi_status *, tapepos_t *); 527 static int st_report_soft_errors(dev_t dev, int flag); 528 static void st_delayed_cv_broadcast(void *arg); 529 static int st_check_media(dev_t dev, enum mtio_state state); 530 static int st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp); 531 static void st_intr_restart(void *arg); 532 static void st_start_restart(void *arg); 533 static int st_gen_mode_sense(struct scsi_tape *un, ubufunc_t ubf, int page, 534 struct seq_mode *page_data, int page_size); 535 static int st_change_block_size(struct scsi_tape *un, uint32_t nblksz); 536 static int st_gen_mode_select(struct scsi_tape *un, ubufunc_t ubf, 537 struct seq_mode *page_data, int page_size); 538 static int st_read_block_limits(struct scsi_tape *un, 539 struct read_blklim *read_blk); 540 static int st_report_density_support(struct scsi_tape *un, 541 uchar_t *density_data, size_t buflen); 542 static int st_report_supported_operation(struct scsi_tape *un, 543 uchar_t *oper_data, uchar_t option_code, ushort_t service_action); 544 static int st_tape_init(struct scsi_tape *un); 545 static void st_flush(struct scsi_tape *un); 546 static void st_set_pe_errno(struct scsi_tape *un); 547 static void st_hba_unflush(struct scsi_tape *un); 548 static void st_turn_pe_on(struct scsi_tape *un); 549 static void st_turn_pe_off(struct scsi_tape *un); 550 static void st_set_pe_flag(struct scsi_tape *un); 551 static void st_clear_pe(struct scsi_tape *un); 552 static void st_wait_for_io(struct scsi_tape *un); 553 static int st_set_devconfig_page(struct scsi_tape *un, int compression_on); 554 static int st_set_datacomp_page(struct scsi_tape *un, int compression_on); 555 static int st_reserve_release(struct scsi_tape *un, int command, ubufunc_t ubf); 556 static int st_check_cdb_for_need_to_reserve(struct scsi_tape *un, uchar_t *cdb); 557 static int st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd, 558 int count); 559 static int st_take_ownership(struct scsi_tape *un); 560 static int st_check_asc_ascq(struct scsi_tape *un); 561 static int st_check_clean_bit(struct scsi_tape *un); 562 static int st_check_alert_flags(struct scsi_tape *un); 563 static int st_check_sequential_clean_bit(struct scsi_tape *un); 564 static int st_check_sense_clean_bit(struct scsi_tape *un); 565 static int st_clear_unit_attentions(dev_t dev_instance, int max_trys); 566 static void st_calculate_timeouts(struct scsi_tape *un); 567 static writablity st_is_drive_worm(struct scsi_tape *un); 568 static int st_read_attributes(struct scsi_tape *un, uint16_t attribute, 569 void *buf, size_t size, ubufunc_t bufunc); 570 static int st_get_special_inquiry(struct scsi_tape *un, uchar_t size, 571 caddr_t dest, uchar_t page); 572 static int st_update_block_pos(struct scsi_tape *un, bufunc_t bf, 573 int post_space); 574 static int st_interpret_read_pos(struct scsi_tape const *un, tapepos_t *dest, 575 read_p_types type, size_t data_sz, const caddr_t responce, int post_space); 576 static int st_get_read_pos(struct scsi_tape *un, buf_t *bp); 577 static int st_logical_block_locate(struct scsi_tape *un, ubufunc_t ubf, 578 tapepos_t *pos, uint64_t lblk, uchar_t partition); 579 static int st_mtfsf_ioctl(struct scsi_tape *un, int files); 580 static int st_mtfsr_ioctl(struct scsi_tape *un, int count); 581 static int st_mtbsf_ioctl(struct scsi_tape *un, int files); 582 static int st_mtnbsf_ioctl(struct scsi_tape *un, int count); 583 static int st_mtbsr_ioctl(struct scsi_tape *un, int num); 584 static int st_mtfsfm_ioctl(struct scsi_tape *un, int cnt); 585 static int st_mtbsfm_ioctl(struct scsi_tape *un, int cnt); 586 static int st_backward_space_files(struct scsi_tape *un, int count, 587 int infront); 588 static int st_forward_space_files(struct scsi_tape *un, int files); 589 static int st_scenic_route_to_begining_of_file(struct scsi_tape *un, 590 int32_t fileno); 591 static int st_space_to_begining_of_file(struct scsi_tape *un); 592 static int st_space_records(struct scsi_tape *un, int records); 593 static int st_get_media_identification(struct scsi_tape *un, ubufunc_t bufunc); 594 static errstate st_command_recovery(struct scsi_tape *un, struct scsi_pkt *pkt, 595 errstate onentry); 596 static void st_recover(void *arg); 597 static void st_recov_cb(struct scsi_pkt *pkt); 598 static int st_rcmd(struct scsi_tape *un, int com, int64_t count, int wait); 599 static int st_uscsi_rcmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, 600 int flag); 601 static void st_add_recovery_info_to_pkt(struct scsi_tape *un, buf_t *bp, 602 struct scsi_pkt *cmd); 603 static int st_check_mode_for_change(struct scsi_tape *un, ubufunc_t ubf); 604 static int st_test_path_to_device(struct scsi_tape *un); 605 static int st_recovery_read_pos(struct scsi_tape *un, read_p_types type, 606 read_pos_data_t *raw); 607 static int st_recovery_get_position(struct scsi_tape *un, tapepos_t *read, 608 read_pos_data_t *raw); 609 static int st_compare_expected_position(struct scsi_tape *un, st_err_info *ei, 610 cmd_attribute const * cmd_att, tapepos_t *read); 611 static errstate st_recover_reissue_pkt(struct scsi_tape *us, 612 struct scsi_pkt *pkt); 613 static int st_transport(struct scsi_tape *un, struct scsi_pkt *pkt); 614 static buf_t *st_remove_from_queue(buf_t **head, buf_t **tail, buf_t *bp); 615 static void st_add_to_queue(buf_t **head, buf_t **tail, buf_t *end, buf_t *bp); 616 static int st_reset(struct scsi_tape *un, int reset_type); 617 static void st_reset_notification(caddr_t arg); 618 static const cmd_attribute *st_lookup_cmd_attribute(unsigned char cmd); 619 620 #ifdef __x86 621 /* 622 * routines for I/O in big block size 623 */ 624 static void st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp); 625 static struct contig_mem *st_get_contig_mem(struct scsi_tape *un, size_t len, 626 int alloc_flags); 627 static int st_bigblk_xfer_done(struct buf *bp); 628 static struct buf *st_get_bigblk_bp(struct buf *bp); 629 #endif 630 static void st_print_position(dev_info_t *dev, char *label, uint_t level, 631 const char *comment, tapepos_t *pos); 632 633 /* 634 * error statistics create/update functions 635 */ 636 static int st_create_errstats(struct scsi_tape *, int); 637 static int st_validate_tapemarks(struct scsi_tape *un, ubufunc_t ubf, 638 tapepos_t *pos); 639 640 #ifdef STDEBUG 641 static void st_debug_cmds(struct scsi_tape *un, int com, int count, int wait); 642 static char *st_dev_name(dev_t dev); 643 #endif /* STDEBUG */ 644 645 #if !defined(lint) 646 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", 647 scsi_pkt buf uio scsi_cdb uscsi_cmd)) 648 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_extended_sense scsi_status)) 649 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device)) 650 _NOTE(DATA_READABLE_WITHOUT_LOCK(st_drivetype scsi_address)) 651 #endif 652 653 /* 654 * autoconfiguration routines. 655 */ 656 char _depends_on[] = "misc/scsi"; 657 658 static struct modldrv modldrv = { 659 &mod_driverops, /* Type of module. This one is a driver */ 660 "SCSI tape Driver %I%", /* Name of the module. */ 661 &st_ops /* driver ops */ 662 }; 663 664 static struct modlinkage modlinkage = { 665 MODREV_1, &modldrv, NULL 666 }; 667 668 /* 669 * Notes on Post Reset Behavior in the tape driver: 670 * 671 * When the tape drive is opened, the driver attempts to make sure that 672 * the tape head is positioned exactly where it was left when it was last 673 * closed provided the medium is not changed. If the tape drive is 674 * opened in O_NDELAY mode, the repositioning (if necessary for any loss 675 * of position due to reset) will happen when the first tape operation or 676 * I/O occurs. The repositioning (if required) may not be possible under 677 * certain situations such as when the device firmware not able to report 678 * the medium change in the REQUEST SENSE data because of a reset or a 679 * misbehaving bus not allowing the reposition to happen. In such 680 * extraordinary situations, where the driver fails to position the head 681 * at its original position, it will fail the open the first time, to 682 * save the applications from overwriting the data. All further attempts 683 * to open the tape device will result in the driver attempting to load 684 * the tape at BOT (beginning of tape). Also a warning message to 685 * indicate that further attempts to open the tape device may result in 686 * the tape being loaded at BOT will be printed on the console. If the 687 * tape device is opened in O_NDELAY mode, failure to restore the 688 * original tape head position, will result in the failure of the first 689 * tape operation or I/O, Further, the driver will invalidate its 690 * internal tape position which will necessitate the applications to 691 * validate the position by using either a tape positioning ioctl (such 692 * as MTREW) or closing and reopening the tape device. 693 * 694 */ 695 696 int 697 _init(void) 698 { 699 int e; 700 701 if (((e = ddi_soft_state_init(&st_state, 702 sizeof (struct scsi_tape), ST_MAXUNIT)) != 0)) { 703 return (e); 704 } 705 706 if ((e = mod_install(&modlinkage)) != 0) { 707 ddi_soft_state_fini(&st_state); 708 } 709 710 #if defined(__x86) 711 /* set the max physical address for iob allocs on x86 */ 712 st_alloc_attr.dma_attr_addr_hi = st_max_phys_addr; 713 714 /* 715 * set the sgllen for iob allocs on x86. If this is set less than 716 * the number of pages the buffer will take (taking into account 717 * alignment), it would force the allocator to try and allocate 718 * contiguous pages. 719 */ 720 st_alloc_attr.dma_attr_sgllen = st_sgl_size; 721 #endif 722 723 return (e); 724 } 725 726 int 727 _fini(void) 728 { 729 int e; 730 731 if ((e = mod_remove(&modlinkage)) != 0) { 732 return (e); 733 } 734 735 ddi_soft_state_fini(&st_state); 736 737 return (e); 738 } 739 740 int 741 _info(struct modinfo *modinfop) 742 { 743 return (mod_info(&modlinkage, modinfop)); 744 } 745 746 747 static int 748 st_probe(dev_info_t *devi) 749 { 750 int instance; 751 struct scsi_device *devp; 752 int rval; 753 754 #if !defined(__sparc) 755 char *tape_prop; 756 int tape_prop_len; 757 #endif 758 759 ST_ENTR(devi, st_probe); 760 761 /* If self identifying device */ 762 if (ddi_dev_is_sid(devi) == DDI_SUCCESS) { 763 return (DDI_PROBE_DONTCARE); 764 } 765 766 #if !defined(__sparc) 767 /* 768 * Since some x86 HBAs have devnodes that look like SCSI as 769 * far as we can tell but aren't really SCSI (DADK, like mlx) 770 * we check for the presence of the "tape" property. 771 */ 772 if (ddi_prop_op(DDI_DEV_T_NONE, devi, PROP_LEN_AND_VAL_ALLOC, 773 DDI_PROP_CANSLEEP, "tape", 774 (caddr_t)&tape_prop, &tape_prop_len) != DDI_PROP_SUCCESS) { 775 return (DDI_PROBE_FAILURE); 776 } 777 if (strncmp(tape_prop, "sctp", tape_prop_len) != 0) { 778 kmem_free(tape_prop, tape_prop_len); 779 return (DDI_PROBE_FAILURE); 780 } 781 kmem_free(tape_prop, tape_prop_len); 782 #endif 783 784 devp = ddi_get_driver_private(devi); 785 instance = ddi_get_instance(devi); 786 787 if (ddi_get_soft_state(st_state, instance) != NULL) { 788 return (DDI_PROBE_PARTIAL); 789 } 790 791 792 /* 793 * Turn around and call probe routine to see whether 794 * we actually have a tape at this SCSI nexus. 795 */ 796 if (scsi_probe(devp, NULL_FUNC) == SCSIPROBE_EXISTS) { 797 798 /* 799 * In checking the whole inq_dtype byte we are looking at both 800 * the Peripheral Qualifier and the Peripheral Device Type. 801 * For this driver we are only interested in sequential devices 802 * that are connected or capable if connecting to this logical 803 * unit. 804 */ 805 if (devp->sd_inq->inq_dtype == 806 (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) { 807 ST_DEBUG6(devi, st_label, SCSI_DEBUG, 808 "probe exists\n"); 809 rval = DDI_PROBE_SUCCESS; 810 } else { 811 rval = DDI_PROBE_FAILURE; 812 } 813 } else { 814 ST_DEBUG6(devi, st_label, SCSI_DEBUG, 815 "probe failure: nothing there\n"); 816 rval = DDI_PROBE_FAILURE; 817 } 818 scsi_unprobe(devp); 819 return (rval); 820 } 821 822 static int 823 st_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 824 { 825 int instance; 826 int wide; 827 int dev_instance; 828 int ret_status; 829 struct scsi_device *devp; 830 int node_ix; 831 struct scsi_tape *un; 832 833 ST_ENTR(devi, st_attach); 834 835 devp = ddi_get_driver_private(devi); 836 instance = ddi_get_instance(devi); 837 838 switch (cmd) { 839 case DDI_ATTACH: 840 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 841 "tape-command-recovery-disable", 0) != 0) { 842 st_recov_sz = sizeof (pkt_info); 843 } 844 if (st_doattach(devp, SLEEP_FUNC) == DDI_FAILURE) { 845 return (DDI_FAILURE); 846 } 847 break; 848 case DDI_RESUME: 849 /* 850 * Suspend/Resume 851 * 852 * When the driver suspended, there might be 853 * outstanding cmds and therefore we need to 854 * reset the suspended flag and resume the scsi 855 * watch thread and restart commands and timeouts 856 */ 857 858 if (!(un = ddi_get_soft_state(st_state, instance))) { 859 return (DDI_FAILURE); 860 } 861 dev_instance = ((un->un_dev == 0) ? MTMINOR(instance) : 862 un->un_dev); 863 864 mutex_enter(ST_MUTEX); 865 866 un->un_throttle = un->un_max_throttle; 867 un->un_tids_at_suspend = 0; 868 un->un_pwr_mgmt = ST_PWR_NORMAL; 869 870 if (un->un_swr_token) { 871 scsi_watch_resume(un->un_swr_token); 872 } 873 874 /* 875 * Restart timeouts 876 */ 877 if ((un->un_tids_at_suspend & ST_DELAY_TID) != 0) { 878 mutex_exit(ST_MUTEX); 879 un->un_delay_tid = timeout( 880 st_delayed_cv_broadcast, un, 881 drv_usectohz((clock_t) 882 MEDIA_ACCESS_DELAY)); 883 mutex_enter(ST_MUTEX); 884 } 885 886 if (un->un_tids_at_suspend & ST_HIB_TID) { 887 mutex_exit(ST_MUTEX); 888 un->un_hib_tid = timeout(st_intr_restart, un, 889 ST_STATUS_BUSY_TIMEOUT); 890 mutex_enter(ST_MUTEX); 891 } 892 893 ret_status = st_clear_unit_attentions(dev_instance, 5); 894 895 /* 896 * now check if we need to restore the tape position 897 */ 898 if ((un->un_suspend_pos.pmode != invalid) && 899 ((un->un_suspend_pos.fileno > 0) || 900 (un->un_suspend_pos.blkno > 0)) || 901 (un->un_suspend_pos.lgclblkno > 0)) { 902 if (ret_status != 0) { 903 /* 904 * tape didn't get good TUR 905 * just print out error messages 906 */ 907 scsi_log(ST_DEVINFO, st_label, CE_WARN, 908 "st_attach-RESUME: tape failure " 909 " tape position will be lost"); 910 } else { 911 /* this prints errors */ 912 (void) st_validate_tapemarks(un, 913 st_uscsi_cmd, &un->un_suspend_pos); 914 } 915 /* 916 * there are no retries, if there is an error 917 * we don't know if the tape has changed 918 */ 919 un->un_suspend_pos.pmode = invalid; 920 } 921 922 /* now we are ready to start up any queued I/Os */ 923 if (un->un_ncmds || un->un_quef) { 924 st_start(un); 925 } 926 927 cv_broadcast(&un->un_suspend_cv); 928 mutex_exit(ST_MUTEX); 929 return (DDI_SUCCESS); 930 931 default: 932 return (DDI_FAILURE); 933 } 934 935 un = ddi_get_soft_state(st_state, instance); 936 937 ST_DEBUG(devi, st_label, SCSI_DEBUG, 938 "st_attach: instance=%x\n", instance); 939 940 /* 941 * Add a zero-length attribute to tell the world we support 942 * kernel ioctls (for layered drivers) 943 */ 944 (void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP, 945 DDI_KERNEL_IOCTL, NULL, 0); 946 947 ddi_report_dev((dev_info_t *)devi); 948 949 /* 950 * If it's a SCSI-2 tape drive which supports wide, 951 * tell the host adapter to use wide. 952 */ 953 wide = ((devp->sd_inq->inq_rdf == RDF_SCSI2) && 954 (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) ? 1 : 0; 955 956 if (scsi_ifsetcap(ROUTE, "wide-xfer", wide, 1) == 1) { 957 ST_DEBUG(devi, st_label, SCSI_DEBUG, 958 "Wide Transfer %s\n", wide ? "enabled" : "disabled"); 959 } 960 961 /* 962 * enable autorequest sense; keep the rq packet around in case 963 * the autorequest sense fails because of a busy condition 964 * do a getcap first in case the capability is not variable 965 */ 966 if (scsi_ifgetcap(ROUTE, "auto-rqsense", 1) == 1) { 967 un->un_arq_enabled = 1; 968 } else { 969 un->un_arq_enabled = 970 ((scsi_ifsetcap(ROUTE, "auto-rqsense", 1, 1) == 1) ? 1 : 0); 971 } 972 973 ST_DEBUG(devi, st_label, SCSI_DEBUG, "auto request sense %s\n", 974 (un->un_arq_enabled ? "enabled" : "disabled")); 975 976 un->un_untagged_qing = 977 (scsi_ifgetcap(ROUTE, "untagged-qing", 0) == 1); 978 979 /* 980 * XXX - This is just for 2.6. to tell users that write buffering 981 * has gone away. 982 */ 983 if (un->un_arq_enabled && un->un_untagged_qing) { 984 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 985 "tape-driver-buffering", 0) != 0) { 986 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 987 "Write Data Buffering has been depricated. Your " 988 "applications should continue to work normally.\n" 989 " But, they should ported to use Asynchronous " 990 " I/O\n" 991 " For more information, read about " 992 " tape-driver-buffering " 993 "property in the st(7d) man page\n"); 994 } 995 } 996 997 un->un_max_throttle = un->un_throttle = un->un_last_throttle = 1; 998 un->un_flush_on_errors = 0; 999 un->un_mkr_pkt = (struct scsi_pkt *)NULL; 1000 1001 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1002 "throttle=%x, max_throttle = %x\n", 1003 un->un_throttle, un->un_max_throttle); 1004 1005 /* initialize persistent errors to nil */ 1006 un->un_persistence = 0; 1007 un->un_persist_errors = 0; 1008 1009 /* 1010 * Get dma-max from HBA driver. If it is not defined, use 64k 1011 */ 1012 un->un_maxdma = scsi_ifgetcap(&devp->sd_address, "dma-max", 1); 1013 if (un->un_maxdma == -1) { 1014 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1015 "Received a value that looked like -1. Using 64k maxdma"); 1016 un->un_maxdma = (64 * ONE_K); 1017 } 1018 1019 #ifdef __x86 1020 /* 1021 * for x86, the device may be able to DMA more than the system will 1022 * allow under some circumstances. We need account for both the HBA's 1023 * and system's contraints. 1024 * 1025 * Get the maximum DMA under worse case conditions. e.g. looking at the 1026 * device constraints, the max copy buffer size, and the worse case 1027 * fragmentation. NOTE: this may differ from dma-max since dma-max 1028 * doesn't take the worse case framentation into account. 1029 * 1030 * e.g. a device may be able to DMA 16MBytes, but can only DMA 1MByte 1031 * if none of the pages are contiguous. Keeping track of both of these 1032 * values allows us to support larger tape block sizes on some devices. 1033 */ 1034 un->un_maxdma_arch = scsi_ifgetcap(&devp->sd_address, "dma-max-arch", 1035 1); 1036 1037 /* 1038 * If the dma-max-arch capability is not implemented, or the value 1039 * comes back higher than what was reported in dma-max, use dma-max. 1040 */ 1041 if ((un->un_maxdma_arch == -1) || 1042 ((uint_t)un->un_maxdma < (uint_t)un->un_maxdma_arch)) { 1043 un->un_maxdma_arch = un->un_maxdma; 1044 } 1045 #endif 1046 1047 /* 1048 * Get the max allowable cdb size 1049 */ 1050 un->un_max_cdb_sz = 1051 scsi_ifgetcap(&devp->sd_address, "max-cdb-length", 1); 1052 if (un->un_max_cdb_sz < CDB_GROUP0) { 1053 ST_DEBUG(devi, st_label, SCSI_DEBUG, 1054 "HBA reported max-cdb-length as %d\n", un->un_max_cdb_sz); 1055 un->un_max_cdb_sz = CDB_GROUP4; /* optimistic default */ 1056 } 1057 1058 un->un_maxbsize = MAXBSIZE_UNKNOWN; 1059 1060 un->un_mediastate = MTIO_NONE; 1061 un->un_HeadClean = TAPE_ALERT_SUPPORT_UNKNOWN; 1062 1063 /* 1064 * initialize kstats 1065 */ 1066 un->un_stats = kstat_create("st", instance, NULL, "tape", 1067 KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT); 1068 if (un->un_stats) { 1069 un->un_stats->ks_lock = ST_MUTEX; 1070 kstat_install(un->un_stats); 1071 } 1072 (void) st_create_errstats(un, instance); 1073 1074 /* 1075 * find the drive type for this target 1076 */ 1077 mutex_enter(ST_MUTEX); 1078 un->un_dev = MT_TEM_DEV(instance); 1079 st_known_tape_type(un); 1080 un->un_dev = 0; 1081 mutex_exit(ST_MUTEX); 1082 1083 for (node_ix = 0; node_ix < ST_NUM_MEMBERS(st_minor_data); node_ix++) { 1084 int minor; 1085 char *name; 1086 1087 name = st_minor_data[node_ix].name; 1088 minor = st_minor_data[node_ix].minor; 1089 1090 /* 1091 * For default devices set the density to the 1092 * preferred default density for this device. 1093 */ 1094 if (node_ix <= DEF_BSD_NR) { 1095 minor |= un->un_dp->default_density; 1096 } 1097 minor |= MTMINOR(instance); 1098 1099 if (ddi_create_minor_node(devi, name, S_IFCHR, minor, 1100 DDI_NT_TAPE, NULL) == DDI_SUCCESS) { 1101 continue; 1102 } 1103 1104 ddi_remove_minor_node(devi, NULL); 1105 1106 (void) scsi_reset_notify(ROUTE, SCSI_RESET_CANCEL, 1107 st_reset_notification, (caddr_t)un); 1108 cv_destroy(&un->un_clscv); 1109 cv_destroy(&un->un_sbuf_cv); 1110 cv_destroy(&un->un_queue_cv); 1111 cv_destroy(&un->un_state_cv); 1112 #ifdef __x86 1113 cv_destroy(&un->un_contig_mem_cv); 1114 #endif 1115 cv_destroy(&un->un_suspend_cv); 1116 cv_destroy(&un->un_tape_busy_cv); 1117 cv_destroy(&un->un_recov_buf_cv); 1118 if (un->un_recov_taskq) { 1119 ddi_taskq_destroy(un->un_recov_taskq); 1120 } 1121 if (un->un_sbufp) { 1122 freerbuf(un->un_sbufp); 1123 } 1124 if (un->un_recov_buf) { 1125 freerbuf(un->un_recov_buf); 1126 } 1127 if (un->un_uscsi_rqs_buf) { 1128 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1129 } 1130 if (un->un_mspl) { 1131 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1132 } 1133 if (un->un_dp_size) { 1134 kmem_free(un->un_dp, un->un_dp_size); 1135 } 1136 if (un->un_state) { 1137 kstat_delete(un->un_stats); 1138 } 1139 if (un->un_errstats) { 1140 kstat_delete(un->un_errstats); 1141 } 1142 1143 scsi_destroy_pkt(un->un_rqs); 1144 scsi_free_consistent_buf(un->un_rqs_bp); 1145 ddi_soft_state_free(st_state, instance); 1146 devp->sd_private = NULL; 1147 devp->sd_sense = NULL; 1148 1149 ddi_prop_remove_all(devi); 1150 return (DDI_FAILURE); 1151 } 1152 1153 return (DDI_SUCCESS); 1154 } 1155 1156 /* 1157 * st_detach: 1158 * 1159 * we allow a detach if and only if: 1160 * - no tape is currently inserted 1161 * - tape position is at BOT or unknown 1162 * (if it is not at BOT then a no rewind 1163 * device was opened and we have to preserve state) 1164 * - it must be in a closed state : no timeouts or scsi_watch requests 1165 * will exist if it is closed, so we don't need to check for 1166 * them here. 1167 */ 1168 /*ARGSUSED*/ 1169 static int 1170 st_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) 1171 { 1172 int instance; 1173 struct scsi_device *devp; 1174 struct scsi_tape *un; 1175 clock_t wait_cmds_complete; 1176 1177 ST_ENTR(devi, st_detach); 1178 1179 instance = ddi_get_instance(devi); 1180 1181 if (!(un = ddi_get_soft_state(st_state, instance))) { 1182 return (DDI_FAILURE); 1183 } 1184 1185 mutex_enter(ST_MUTEX); 1186 1187 /* 1188 * Clear error entry stack 1189 */ 1190 st_empty_error_stack(un); 1191 1192 mutex_exit(ST_MUTEX); 1193 1194 switch (cmd) { 1195 1196 case DDI_DETACH: 1197 /* 1198 * Undo what we did in st_attach & st_doattach, 1199 * freeing resources and removing things we installed. 1200 * The system framework guarantees we are not active 1201 * with this devinfo node in any other entry points at 1202 * this time. 1203 */ 1204 1205 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1206 "st_detach: instance=%x, un=%p\n", instance, 1207 (void *)un); 1208 1209 if (((un->un_dp->options & ST_UNLOADABLE) == 0) || 1210 (un->un_ncmds != 0) || (un->un_quef != NULL) || 1211 (un->un_state != ST_STATE_CLOSED)) { 1212 /* 1213 * we cannot unload some targets because the 1214 * inquiry returns junk unless immediately 1215 * after a reset 1216 */ 1217 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 1218 "cannot unload instance %x\n", instance); 1219 return (DDI_FAILURE); 1220 } 1221 1222 /* 1223 * if the tape has been removed then we may unload; 1224 * do a test unit ready and if it returns NOT READY 1225 * then we assume that it is safe to unload. 1226 * as a side effect, pmode may be set to invalid if the 1227 * the test unit ready fails; 1228 * also un_state may be set to non-closed, so reset it 1229 */ 1230 if ((un->un_dev) && /* Been opened since attach */ 1231 ((un->un_pos.pmode == legacy) && 1232 (un->un_pos.fileno > 0) || /* Known position not rewound */ 1233 (un->un_pos.blkno != 0)) || /* Or within first file */ 1234 ((un->un_pos.pmode == logical) && 1235 (un->un_pos.lgclblkno > 0))) { 1236 mutex_enter(ST_MUTEX); 1237 /* 1238 * Send Test Unit Ready in the hopes that if 1239 * the drive is not in the state we think it is. 1240 * And the state will be changed so it can be detached. 1241 * If the command fails to reach the device and 1242 * the drive was not rewound or unloaded we want 1243 * to fail the detach till a user command fails 1244 * where after the detach will succead. 1245 */ 1246 (void) st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 1247 /* 1248 * After TUR un_state may be set to non-closed, 1249 * so reset it back. 1250 */ 1251 un->un_state = ST_STATE_CLOSED; 1252 mutex_exit(ST_MUTEX); 1253 } 1254 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1255 "un_status=%x, fileno=%x, blkno=%x\n", 1256 un->un_status, un->un_pos.fileno, un->un_pos.blkno); 1257 1258 /* 1259 * check again: 1260 * if we are not at BOT then it is not safe to unload 1261 */ 1262 if ((un->un_dev) && /* Been opened since attach */ 1263 (((un->un_pos.pmode == legacy) && 1264 (un->un_pos.fileno > 0) || /* Known position not rewound */ 1265 (un->un_pos.blkno != 0)) || /* Or within first file */ 1266 ((un->un_pos.pmode == logical) && 1267 (un->un_pos.lgclblkno > 0)))) { 1268 1269 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1270 "cannot detach: pmode=%d fileno=0x%x, blkno=0x%x" 1271 " lgclblkno=0x%"PRIx64"\n", un->un_pos.pmode, 1272 un->un_pos.fileno, un->un_pos.blkno, 1273 un->un_pos.lgclblkno); 1274 return (DDI_FAILURE); 1275 } 1276 1277 /* 1278 * Just To make sure that we have released the 1279 * tape unit . 1280 */ 1281 if (un->un_dev && (un->un_rsvd_status & ST_RESERVE) && 1282 !DEVI_IS_DEVICE_REMOVED(devi)) { 1283 mutex_enter(ST_MUTEX); 1284 (void) st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 1285 mutex_exit(ST_MUTEX); 1286 } 1287 1288 /* 1289 * now remove other data structures allocated in st_doattach() 1290 */ 1291 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 1292 "destroying/freeing\n"); 1293 1294 (void) scsi_reset_notify(ROUTE, SCSI_RESET_CANCEL, 1295 st_reset_notification, (caddr_t)un); 1296 cv_destroy(&un->un_clscv); 1297 cv_destroy(&un->un_sbuf_cv); 1298 cv_destroy(&un->un_queue_cv); 1299 cv_destroy(&un->un_suspend_cv); 1300 cv_destroy(&un->un_tape_busy_cv); 1301 cv_destroy(&un->un_recov_buf_cv); 1302 1303 if (un->un_recov_taskq) { 1304 ddi_taskq_destroy(un->un_recov_taskq); 1305 } 1306 1307 if (un->un_hib_tid) { 1308 (void) untimeout(un->un_hib_tid); 1309 un->un_hib_tid = 0; 1310 } 1311 1312 if (un->un_delay_tid) { 1313 (void) untimeout(un->un_delay_tid); 1314 un->un_delay_tid = 0; 1315 } 1316 cv_destroy(&un->un_state_cv); 1317 1318 #ifdef __x86 1319 cv_destroy(&un->un_contig_mem_cv); 1320 1321 if (un->un_contig_mem_hdl != NULL) { 1322 ddi_dma_free_handle(&un->un_contig_mem_hdl); 1323 } 1324 #endif 1325 if (un->un_sbufp) { 1326 freerbuf(un->un_sbufp); 1327 } 1328 if (un->un_recov_buf) { 1329 freerbuf(un->un_recov_buf); 1330 } 1331 if (un->un_uscsi_rqs_buf) { 1332 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1333 } 1334 if (un->un_mspl) { 1335 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1336 } 1337 if (un->un_rqs) { 1338 scsi_destroy_pkt(un->un_rqs); 1339 scsi_free_consistent_buf(un->un_rqs_bp); 1340 } 1341 if (un->un_mkr_pkt) { 1342 scsi_destroy_pkt(un->un_mkr_pkt); 1343 } 1344 if (un->un_arq_enabled) { 1345 (void) scsi_ifsetcap(ROUTE, "auto-rqsense", 0, 1); 1346 } 1347 if (un->un_dp_size) { 1348 kmem_free(un->un_dp, un->un_dp_size); 1349 } 1350 if (un->un_stats) { 1351 kstat_delete(un->un_stats); 1352 un->un_stats = (kstat_t *)0; 1353 } 1354 if (un->un_errstats) { 1355 kstat_delete(un->un_errstats); 1356 un->un_errstats = (kstat_t *)0; 1357 } 1358 if (un->un_media_id_len) { 1359 kmem_free(un->un_media_id, un->un_media_id_len); 1360 } 1361 devp = ST_SCSI_DEVP; 1362 ddi_soft_state_free(st_state, instance); 1363 devp->sd_private = NULL; 1364 devp->sd_sense = NULL; 1365 scsi_unprobe(devp); 1366 ddi_prop_remove_all(devi); 1367 ddi_remove_minor_node(devi, NULL); 1368 ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach done\n"); 1369 return (DDI_SUCCESS); 1370 1371 case DDI_SUSPEND: 1372 1373 /* 1374 * Suspend/Resume 1375 * 1376 * To process DDI_SUSPEND, we must do the following: 1377 * 1378 * - check ddi_removing_power to see if power will be turned 1379 * off. if so, return DDI_FAILURE 1380 * - check if we are already suspended, 1381 * if so, return DDI_FAILURE 1382 * - check if device state is CLOSED, 1383 * if not, return DDI_FAILURE. 1384 * - wait until outstanding operations complete 1385 * - save tape state 1386 * - block new operations 1387 * - cancel pending timeouts 1388 * 1389 */ 1390 1391 if (ddi_removing_power(devi)) { 1392 return (DDI_FAILURE); 1393 } 1394 mutex_enter(ST_MUTEX); 1395 1396 /* 1397 * Shouldn't already be suspended, if so return failure 1398 */ 1399 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 1400 mutex_exit(ST_MUTEX); 1401 return (DDI_FAILURE); 1402 } 1403 if (un->un_state != ST_STATE_CLOSED) { 1404 mutex_exit(ST_MUTEX); 1405 return (DDI_FAILURE); 1406 } 1407 1408 /* 1409 * Wait for all outstanding I/O's to complete 1410 * 1411 * we wait on both ncmds and the wait queue for times 1412 * when we are flushing after persistent errors are 1413 * flagged, which is when ncmds can be 0, and the 1414 * queue can still have I/O's. This way we preserve 1415 * order of biodone's. 1416 */ 1417 wait_cmds_complete = ddi_get_lbolt(); 1418 wait_cmds_complete += 1419 st_wait_cmds_complete * drv_usectohz(1000000); 1420 while (un->un_ncmds || un->un_quef || 1421 (un->un_state == ST_STATE_RESOURCE_WAIT)) { 1422 1423 if (cv_timedwait(&un->un_tape_busy_cv, ST_MUTEX, 1424 wait_cmds_complete) == -1) { 1425 /* 1426 * Time expired then cancel the command 1427 */ 1428 if (st_reset(un, RESET_LUN) == 0) { 1429 if (un->un_last_throttle) { 1430 un->un_throttle = 1431 un->un_last_throttle; 1432 } 1433 mutex_exit(ST_MUTEX); 1434 return (DDI_FAILURE); 1435 } else { 1436 break; 1437 } 1438 } 1439 } 1440 1441 /* 1442 * DDI_SUSPEND says that the system "may" power down, we 1443 * remember the file and block number before rewinding. 1444 * we also need to save state before issuing 1445 * any WRITE_FILE_MARK command. 1446 */ 1447 (void) st_update_block_pos(un, st_cmd, 0); 1448 COPY_POS(&un->un_suspend_pos, &un->un_pos); 1449 1450 1451 /* 1452 * Issue a zero write file fmk command to tell the drive to 1453 * flush any buffered tape marks 1454 */ 1455 (void) st_cmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD); 1456 1457 /* 1458 * Because not all tape drives correctly implement buffer 1459 * flushing with the zero write file fmk command, issue a 1460 * synchronous rewind command to force data flushing. 1461 * st_validate_tapemarks() will do a rewind during DDI_RESUME 1462 * anyway. 1463 */ 1464 (void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 1465 1466 /* stop any new operations */ 1467 un->un_pwr_mgmt = ST_PWR_SUSPENDED; 1468 un->un_throttle = 0; 1469 1470 /* 1471 * cancel any outstanding timeouts 1472 */ 1473 if (un->un_delay_tid) { 1474 timeout_id_t temp_id = un->un_delay_tid; 1475 un->un_delay_tid = 0; 1476 un->un_tids_at_suspend |= ST_DELAY_TID; 1477 mutex_exit(ST_MUTEX); 1478 (void) untimeout(temp_id); 1479 mutex_enter(ST_MUTEX); 1480 } 1481 1482 if (un->un_hib_tid) { 1483 timeout_id_t temp_id = un->un_hib_tid; 1484 un->un_hib_tid = 0; 1485 un->un_tids_at_suspend |= ST_HIB_TID; 1486 mutex_exit(ST_MUTEX); 1487 (void) untimeout(temp_id); 1488 mutex_enter(ST_MUTEX); 1489 } 1490 1491 /* 1492 * Suspend the scsi_watch_thread 1493 */ 1494 if (un->un_swr_token) { 1495 opaque_t temp_token = un->un_swr_token; 1496 mutex_exit(ST_MUTEX); 1497 scsi_watch_suspend(temp_token); 1498 } else { 1499 mutex_exit(ST_MUTEX); 1500 } 1501 1502 return (DDI_SUCCESS); 1503 1504 default: 1505 ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach failed\n"); 1506 return (DDI_FAILURE); 1507 } 1508 } 1509 1510 1511 /* ARGSUSED */ 1512 static int 1513 st_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 1514 { 1515 dev_t dev; 1516 struct scsi_tape *un; 1517 int instance, error; 1518 1519 ST_ENTR(dip, st_info); 1520 1521 switch (infocmd) { 1522 case DDI_INFO_DEVT2DEVINFO: 1523 dev = (dev_t)arg; 1524 instance = MTUNIT(dev); 1525 if ((un = ddi_get_soft_state(st_state, instance)) == NULL) 1526 return (DDI_FAILURE); 1527 *result = (void *) ST_DEVINFO; 1528 error = DDI_SUCCESS; 1529 break; 1530 case DDI_INFO_DEVT2INSTANCE: 1531 dev = (dev_t)arg; 1532 instance = MTUNIT(dev); 1533 *result = (void *)(uintptr_t)instance; 1534 error = DDI_SUCCESS; 1535 break; 1536 default: 1537 error = DDI_FAILURE; 1538 } 1539 return (error); 1540 } 1541 1542 static int 1543 st_doattach(struct scsi_device *devp, int (*canwait)()) 1544 { 1545 struct scsi_tape *un = NULL; 1546 recov_info *ri; 1547 int km_flags = (canwait != NULL_FUNC) ? KM_SLEEP : KM_NOSLEEP; 1548 int instance; 1549 size_t rlen; 1550 1551 ST_FUNC(devp->sd_dev, st_doattach); 1552 /* 1553 * Call the routine scsi_probe to do some of the dirty work. 1554 * If the INQUIRY command succeeds, the field sd_inq in the 1555 * device structure will be filled in. 1556 */ 1557 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1558 "st_doattach(): probing\n"); 1559 1560 if (scsi_probe(devp, canwait) == SCSIPROBE_EXISTS) { 1561 1562 /* 1563 * In checking the whole inq_dtype byte we are looking at both 1564 * the Peripheral Qualifier and the Peripheral Device Type. 1565 * For this driver we are only interested in sequential devices 1566 * that are connected or capable if connecting to this logical 1567 * unit. 1568 */ 1569 if (devp->sd_inq->inq_dtype == 1570 (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) { 1571 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1572 "probe exists\n"); 1573 } else { 1574 /* Something there but not a tape device */ 1575 scsi_unprobe(devp); 1576 return (DDI_FAILURE); 1577 } 1578 } else { 1579 /* Nothing there */ 1580 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1581 "probe failure: nothing there\n"); 1582 scsi_unprobe(devp); 1583 return (DDI_FAILURE); 1584 } 1585 1586 1587 /* 1588 * The actual unit is present. 1589 * Now is the time to fill in the rest of our info.. 1590 */ 1591 instance = ddi_get_instance(devp->sd_dev); 1592 1593 if (ddi_soft_state_zalloc(st_state, instance) != DDI_SUCCESS) { 1594 goto error; 1595 } 1596 un = ddi_get_soft_state(st_state, instance); 1597 1598 ASSERT(un != NULL); 1599 1600 un->un_rqs_bp = scsi_alloc_consistent_buf(&devp->sd_address, NULL, 1601 MAX_SENSE_LENGTH, B_READ, canwait, NULL); 1602 if (un->un_rqs_bp == NULL) { 1603 goto error; 1604 } 1605 un->un_rqs = scsi_init_pkt(&devp->sd_address, NULL, un->un_rqs_bp, 1606 CDB_GROUP0, 1, st_recov_sz, PKT_CONSISTENT, canwait, NULL); 1607 if (!un->un_rqs) { 1608 goto error; 1609 } 1610 ASSERT(un->un_rqs->pkt_resid == 0); 1611 devp->sd_sense = 1612 (struct scsi_extended_sense *)un->un_rqs_bp->b_un.b_addr; 1613 ASSERT(geterror(un->un_rqs_bp) == NULL); 1614 1615 (void) scsi_setup_cdb((union scsi_cdb *)un->un_rqs->pkt_cdbp, 1616 SCMD_REQUEST_SENSE, 0, MAX_SENSE_LENGTH, 0); 1617 FILL_SCSI1_LUN(devp, un->un_rqs); 1618 un->un_rqs->pkt_flags |= (FLAG_SENSING | FLAG_HEAD | FLAG_NODISCON); 1619 un->un_rqs->pkt_time = st_io_time; 1620 un->un_rqs->pkt_comp = st_intr; 1621 ri = (recov_info *)un->un_rqs->pkt_private; 1622 if (st_recov_sz == sizeof (recov_info)) { 1623 ri->privatelen = sizeof (recov_info); 1624 } else { 1625 ri->privatelen = sizeof (pkt_info); 1626 } 1627 1628 un->un_sbufp = getrbuf(km_flags); 1629 un->un_recov_buf = getrbuf(km_flags); 1630 1631 un->un_uscsi_rqs_buf = kmem_alloc(SENSE_LENGTH, KM_SLEEP); 1632 1633 /* 1634 * use i_ddi_mem_alloc() for now until we have an interface to allocate 1635 * memory for DMA which doesn't require a DMA handle. ddi_iopb_alloc() 1636 * is obsolete and we want more flexibility in controlling the DMA 1637 * address constraints. 1638 */ 1639 (void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr, 1640 sizeof (struct seq_mode), ((km_flags == KM_SLEEP) ? 1 : 0), 0, 1641 NULL, (caddr_t *)&un->un_mspl, &rlen, NULL); 1642 1643 (void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr, 1644 sizeof (read_pos_data_t), ((km_flags == KM_SLEEP) ? 1 : 0), 0, 1645 NULL, (caddr_t *)&un->un_read_pos_data, &rlen, NULL); 1646 1647 if (!un->un_sbufp || !un->un_mspl || !un->un_read_pos_data) { 1648 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, 1649 "probe partial failure: no space\n"); 1650 goto error; 1651 } 1652 1653 bzero(un->un_mspl, sizeof (struct seq_mode)); 1654 1655 cv_init(&un->un_sbuf_cv, NULL, CV_DRIVER, NULL); 1656 cv_init(&un->un_queue_cv, NULL, CV_DRIVER, NULL); 1657 cv_init(&un->un_clscv, NULL, CV_DRIVER, NULL); 1658 cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL); 1659 #ifdef __x86 1660 cv_init(&un->un_contig_mem_cv, NULL, CV_DRIVER, NULL); 1661 #endif 1662 1663 /* Initialize power managemnet condition variable */ 1664 cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL); 1665 cv_init(&un->un_tape_busy_cv, NULL, CV_DRIVER, NULL); 1666 cv_init(&un->un_recov_buf_cv, NULL, CV_DRIVER, NULL); 1667 1668 un->un_recov_taskq = ddi_taskq_create(devp->sd_dev, 1669 "un_recov_taskq", 1, TASKQ_DEFAULTPRI, km_flags); 1670 1671 ASSERT(un->un_recov_taskq != NULL); 1672 1673 un->un_pos.pmode = invalid; 1674 un->un_sd = devp; 1675 un->un_swr_token = (opaque_t)NULL; 1676 un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE; 1677 un->un_wormable = st_is_drive_worm; 1678 un->un_media_id_method = st_get_media_identification; 1679 /* 1680 * setting long a initial as it contains logical file info. 1681 * support for long format is mandatory but many drive don't do it. 1682 */ 1683 un->un_read_pos_type = LONG_POS; 1684 1685 un->un_suspend_pos.pmode = invalid; 1686 1687 #ifdef __x86 1688 if (ddi_dma_alloc_handle(ST_DEVINFO, &st_contig_mem_dma_attr, 1689 DDI_DMA_SLEEP, NULL, &un->un_contig_mem_hdl) != DDI_SUCCESS) { 1690 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, 1691 "allocation of contiguous memory dma handle failed!"); 1692 un->un_contig_mem_hdl = NULL; 1693 goto error; 1694 } 1695 #endif 1696 1697 /* 1698 * Since this driver manages devices with "remote" hardware, 1699 * i.e. the devices themselves have no "reg" properties, 1700 * the SUSPEND/RESUME commands in detach/attach will not be 1701 * called by the power management framework unless we request 1702 * it by creating a "pm-hardware-state" property and setting it 1703 * to value "needs-suspend-resume". 1704 */ 1705 if (ddi_prop_update_string(DDI_DEV_T_NONE, devp->sd_dev, 1706 "pm-hardware-state", "needs-suspend-resume") != 1707 DDI_PROP_SUCCESS) { 1708 1709 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1710 "ddi_prop_update(\"pm-hardware-state\") failed\n"); 1711 goto error; 1712 } 1713 1714 if (ddi_prop_create(DDI_DEV_T_NONE, devp->sd_dev, DDI_PROP_CANSLEEP, 1715 "no-involuntary-power-cycles", NULL, 0) != DDI_PROP_SUCCESS) { 1716 1717 ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG, 1718 "ddi_prop_create(\"no-involuntary-power-cycles\") " 1719 "failed\n"); 1720 goto error; 1721 } 1722 1723 (void) scsi_reset_notify(ROUTE, SCSI_RESET_NOTIFY, 1724 st_reset_notification, (caddr_t)un); 1725 1726 ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, "attach success\n"); 1727 return (DDI_SUCCESS); 1728 1729 error: 1730 devp->sd_sense = NULL; 1731 1732 ddi_remove_minor_node(devp->sd_dev, NULL); 1733 if (un) { 1734 if (un->un_mspl) { 1735 i_ddi_mem_free((caddr_t)un->un_mspl, NULL); 1736 } 1737 if (un->un_read_pos_data) { 1738 i_ddi_mem_free((caddr_t)un->un_read_pos_data, 0); 1739 } 1740 if (un->un_sbufp) { 1741 freerbuf(un->un_sbufp); 1742 } 1743 if (un->un_recov_buf) { 1744 freerbuf(un->un_recov_buf); 1745 } 1746 if (un->un_uscsi_rqs_buf) { 1747 kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH); 1748 } 1749 #ifdef __x86 1750 if (un->un_contig_mem_hdl != NULL) { 1751 ddi_dma_free_handle(&un->un_contig_mem_hdl); 1752 } 1753 #endif 1754 if (un->un_rqs) { 1755 scsi_destroy_pkt(un->un_rqs); 1756 } 1757 1758 if (un->un_rqs_bp) { 1759 scsi_free_consistent_buf(un->un_rqs_bp); 1760 } 1761 1762 ddi_soft_state_free(st_state, instance); 1763 devp->sd_private = NULL; 1764 } 1765 1766 if (devp->sd_inq) { 1767 scsi_unprobe(devp); 1768 } 1769 return (DDI_FAILURE); 1770 } 1771 1772 typedef int 1773 (*cfg_functp)(struct scsi_tape *, char *vidpid, struct st_drivetype *); 1774 1775 static cfg_functp config_functs[] = { 1776 st_get_conf_from_st_dot_conf, 1777 st_get_conf_from_st_conf_dot_c, 1778 st_get_conf_from_tape_drive, 1779 st_get_default_conf 1780 }; 1781 1782 1783 /* 1784 * determine tape type, using tape-config-list or built-in table or 1785 * use a generic tape config entry 1786 */ 1787 static void 1788 st_known_tape_type(struct scsi_tape *un) 1789 { 1790 struct st_drivetype *dp; 1791 cfg_functp *config_funct; 1792 uchar_t reserved; 1793 1794 ST_FUNC(ST_DEVINFO, st_known_tape_type); 1795 1796 reserved = (un->un_rsvd_status & ST_RESERVE) ? ST_RESERVE 1797 : ST_RELEASE; 1798 1799 /* 1800 * XXX: Emulex MT-02 (and emulators) predates SCSI-1 and has 1801 * no vid & pid inquiry data. So, we provide one. 1802 */ 1803 if (ST_INQUIRY->inq_len == 0 || 1804 (bcmp("\0\0\0\0\0\0\0\0", ST_INQUIRY->inq_vid, 8) == 0)) { 1805 (void) strcpy((char *)ST_INQUIRY->inq_vid, ST_MT02_NAME); 1806 } 1807 1808 if (un->un_dp_size == 0) { 1809 un->un_dp_size = sizeof (struct st_drivetype); 1810 dp = kmem_zalloc((size_t)un->un_dp_size, KM_SLEEP); 1811 un->un_dp = dp; 1812 } else { 1813 dp = un->un_dp; 1814 } 1815 1816 un->un_dp->non_motion_timeout = st_io_time; 1817 /* 1818 * Loop through the configuration methods till one works. 1819 */ 1820 for (config_funct = &config_functs[0]; ; config_funct++) { 1821 if ((*config_funct)(un, ST_INQUIRY->inq_vid, dp)) { 1822 break; 1823 } 1824 } 1825 1826 /* 1827 * If we didn't just make up this configuration and 1828 * all the density codes are the same.. 1829 * Set Auto Density over ride. 1830 */ 1831 if (*config_funct != st_get_default_conf) { 1832 /* 1833 * If this device is one that is configured and all 1834 * densities are the same, This saves doing gets and set 1835 * that yield nothing. 1836 */ 1837 if ((dp->densities[0]) == (dp->densities[1]) && 1838 (dp->densities[0]) == (dp->densities[2]) && 1839 (dp->densities[0]) == (dp->densities[3])) { 1840 1841 dp->options |= ST_AUTODEN_OVERRIDE; 1842 } 1843 } 1844 1845 1846 /* 1847 * Store tape drive characteristics. 1848 */ 1849 un->un_status = 0; 1850 un->un_attached = 1; 1851 un->un_init_options = dp->options; 1852 1853 /* setup operation time-outs based on options */ 1854 st_calculate_timeouts(un); 1855 1856 /* make sure if we are supposed to be variable, make it variable */ 1857 if (dp->options & ST_VARIABLE) { 1858 dp->bsize = 0; 1859 } 1860 1861 if (reserved != ((un->un_rsvd_status & ST_RESERVE) ? ST_RESERVE 1862 : ST_RELEASE)) { 1863 (void) st_reserve_release(un, reserved, st_uscsi_cmd); 1864 } 1865 1866 un->un_unit_attention_flags = 1; 1867 1868 scsi_log(ST_DEVINFO, st_label, CE_NOTE, "?<%s>\n", dp->name); 1869 1870 } 1871 1872 1873 typedef struct { 1874 int mask; 1875 int bottom; 1876 int top; 1877 char *name; 1878 } conf_limit; 1879 1880 static const conf_limit conf_limits[] = { 1881 1882 -1, 1, 2, "conf version", 1883 -1, MT_ISTS, ST_LAST_TYPE, "drive type", 1884 -1, 0, 0xffffff, "block size", 1885 ST_VALID_OPTS, 0, ST_VALID_OPTS, "options", 1886 -1, 0, 4, "number of densities", 1887 -1, 0, UINT8_MAX, "density code", 1888 -1, 0, 3, "default density", 1889 -1, 0, UINT16_MAX, "non motion timeout", 1890 -1, 0, UINT16_MAX, "I/O timeout", 1891 -1, 0, UINT16_MAX, "space timeout", 1892 -1, 0, UINT16_MAX, "load timeout", 1893 -1, 0, UINT16_MAX, "unload timeout", 1894 -1, 0, UINT16_MAX, "erase timeout", 1895 0, 0, 0, NULL 1896 }; 1897 1898 static int 1899 st_validate_conf_data(struct scsi_tape *un, int *list, int list_len, 1900 const char *conf_name) 1901 { 1902 int dens; 1903 int ndens; 1904 int value; 1905 int type; 1906 int count; 1907 const conf_limit *limit = &conf_limits[0]; 1908 1909 ST_FUNC(ST_DEVINFO, st_validate_conf_data); 1910 1911 ST_DEBUG3(ST_DEVINFO, st_label, CE_NOTE, 1912 "Checking %d entrys total with %d densities\n", list_len, list[4]); 1913 1914 count = list_len; 1915 type = *list; 1916 for (; count && limit->name; count--, list++, limit++) { 1917 1918 value = *list; 1919 if (value & ~limit->mask) { 1920 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1921 "%s %s value invalid bits set: 0x%X\n", 1922 conf_name, limit->name, value & ~limit->mask); 1923 *list &= limit->mask; 1924 } else if (value < limit->bottom) { 1925 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1926 "%s %s value too low: value = %d limit %d\n", 1927 conf_name, limit->name, value, limit->bottom); 1928 } else if (value > limit->top) { 1929 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1930 "%s %s value too high: value = %d limit %d\n", 1931 conf_name, limit->name, value, limit->top); 1932 } else { 1933 ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT, 1934 "%s %s value = 0x%X\n", 1935 conf_name, limit->name, value); 1936 } 1937 1938 /* If not the number of densities continue */ 1939 if (limit != &conf_limits[4]) { 1940 continue; 1941 } 1942 1943 /* If number of densities is not in range can't use config */ 1944 if (value < limit->bottom || value > limit->top) { 1945 return (-1); 1946 } 1947 1948 ndens = min(value, NDENSITIES); 1949 if ((type == 1) && (list_len - ndens) != 6) { 1950 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1951 "%s conf version 1 with %d densities has %d items" 1952 " should have %d", 1953 conf_name, ndens, list_len, 6 + ndens); 1954 } else if ((type == 2) && (list_len - ndens) != 13) { 1955 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1956 "%s conf version 2 with %d densities has %d items" 1957 " should have %d", 1958 conf_name, ndens, list_len, 13 + ndens); 1959 } 1960 1961 limit++; 1962 for (dens = 0; dens < ndens && count; dens++) { 1963 count--; 1964 list++; 1965 value = *list; 1966 if (value < limit->bottom) { 1967 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1968 "%s density[%d] value too low: value =" 1969 " 0x%X limit 0x%X\n", 1970 conf_name, dens, value, limit->bottom); 1971 } else if (value > limit->top) { 1972 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 1973 "%s density[%d] value too high: value =" 1974 " 0x%X limit 0x%X\n", 1975 conf_name, dens, value, limit->top); 1976 } else { 1977 ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT, 1978 "%s density[%d] value = 0x%X\n", 1979 conf_name, dens, value); 1980 } 1981 } 1982 } 1983 1984 return (0); 1985 } 1986 1987 static int 1988 st_get_conf_from_st_dot_conf(struct scsi_tape *un, char *vidpid, 1989 struct st_drivetype *dp) 1990 { 1991 caddr_t config_list = NULL; 1992 caddr_t data_list = NULL; 1993 int *data_ptr; 1994 caddr_t vidptr, prettyptr, datanameptr; 1995 size_t vidlen, prettylen, datanamelen, tripletlen = 0; 1996 int config_list_len, data_list_len, len, i; 1997 int version; 1998 int found = 0; 1999 2000 ST_FUNC(ST_DEVINFO, st_get_conf_from_st_dot_conf); 2001 2002 /* 2003 * Determine type of tape controller. Type is determined by 2004 * checking the vendor ids of the earlier inquiry command and 2005 * comparing those with vids in tape-config-list defined in st.conf 2006 */ 2007 if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, DDI_PROP_DONTPASS, 2008 "tape-config-list", (caddr_t)&config_list, &config_list_len) 2009 != DDI_PROP_SUCCESS) { 2010 return (found); 2011 } 2012 2013 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 2014 "st_get_conf_from_st_dot_conf(): st.conf has tape-config-list\n"); 2015 2016 /* 2017 * Compare vids in each triplet - if it matches, get value for 2018 * data_name and contruct a st_drivetype struct 2019 * tripletlen is not set yet! 2020 */ 2021 for (len = config_list_len, vidptr = config_list; 2022 len > 0; 2023 vidptr += tripletlen, len -= tripletlen) { 2024 2025 vidlen = strlen(vidptr); 2026 prettyptr = vidptr + vidlen + 1; 2027 prettylen = strlen(prettyptr); 2028 datanameptr = prettyptr + prettylen + 1; 2029 datanamelen = strlen(datanameptr); 2030 tripletlen = vidlen + prettylen + datanamelen + 3; 2031 2032 if (vidlen == 0) { 2033 continue; 2034 } 2035 2036 /* 2037 * If inquiry vid dosen't match this triplets vid, 2038 * try the next. 2039 */ 2040 if (strncasecmp(vidpid, vidptr, vidlen)) { 2041 continue; 2042 } 2043 2044 /* 2045 * if prettylen is zero then use the vid string 2046 */ 2047 if (prettylen == 0) { 2048 prettyptr = vidptr; 2049 prettylen = vidlen; 2050 } 2051 2052 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2053 "vid = %s, pretty=%s, dataname = %s\n", 2054 vidptr, prettyptr, datanameptr); 2055 2056 /* 2057 * get the data list 2058 */ 2059 if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, 0, 2060 datanameptr, (caddr_t)&data_list, 2061 &data_list_len) != DDI_PROP_SUCCESS) { 2062 /* 2063 * Error in getting property value 2064 * print warning! 2065 */ 2066 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2067 "data property (%s) has no value\n", 2068 datanameptr); 2069 continue; 2070 } 2071 2072 /* 2073 * now initialize the st_drivetype struct 2074 */ 2075 (void) strncpy(dp->name, prettyptr, ST_NAMESIZE - 1); 2076 dp->length = (int)min(vidlen, (VIDPIDLEN - 1)); 2077 (void) strncpy(dp->vid, vidptr, dp->length); 2078 data_ptr = (int *)data_list; 2079 /* 2080 * check if data is enough for version, type, 2081 * bsize, options, # of densities, density1, 2082 * density2, ..., default_density 2083 */ 2084 if ((data_list_len < 5 * sizeof (int)) || 2085 (data_list_len < 6 * sizeof (int) + 2086 *(data_ptr + 4) * sizeof (int))) { 2087 /* 2088 * print warning and skip to next triplet. 2089 */ 2090 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2091 "data property (%s) incomplete\n", 2092 datanameptr); 2093 kmem_free(data_list, data_list_len); 2094 continue; 2095 } 2096 2097 if (st_validate_conf_data(un, data_ptr, 2098 data_list_len / sizeof (int), datanameptr)) { 2099 kmem_free(data_list, data_list_len); 2100 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2101 "data property (%s) rejected\n", 2102 datanameptr); 2103 continue; 2104 } 2105 2106 /* 2107 * check version 2108 */ 2109 version = *data_ptr++; 2110 if (version != 1 && version != 2) { 2111 /* print warning but accept it */ 2112 scsi_log(ST_DEVINFO, st_label, CE_WARN, 2113 "Version # for data property (%s) " 2114 "not set to 1 or 2\n", datanameptr); 2115 } 2116 2117 dp->type = *data_ptr++; 2118 dp->bsize = *data_ptr++; 2119 dp->options = *data_ptr++; 2120 dp->options |= ST_DYNAMIC; 2121 len = *data_ptr++; 2122 for (i = 0; i < NDENSITIES; i++) { 2123 if (i < len) { 2124 dp->densities[i] = *data_ptr++; 2125 } 2126 } 2127 dp->default_density = *data_ptr << 3; 2128 if (version == 2 && 2129 data_list_len >= (13 + len) * sizeof (int)) { 2130 data_ptr++; 2131 dp->non_motion_timeout = *data_ptr++; 2132 dp->io_timeout = *data_ptr++; 2133 dp->rewind_timeout = *data_ptr++; 2134 dp->space_timeout = *data_ptr++; 2135 dp->load_timeout = *data_ptr++; 2136 dp->unload_timeout = *data_ptr++; 2137 dp->erase_timeout = *data_ptr++; 2138 } 2139 kmem_free(data_list, data_list_len); 2140 found = 1; 2141 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2142 "found in st.conf: vid = %s, pretty=%s\n", 2143 dp->vid, dp->name); 2144 break; 2145 } 2146 2147 /* 2148 * free up the memory allocated by ddi_getlongprop 2149 */ 2150 if (config_list) { 2151 kmem_free(config_list, config_list_len); 2152 } 2153 return (found); 2154 } 2155 2156 static int 2157 st_get_conf_from_st_conf_dot_c(struct scsi_tape *un, char *vidpid, 2158 struct st_drivetype *dp) 2159 { 2160 int i; 2161 2162 ST_FUNC(ST_DEVINFO, st_get_conf_from_st_conf_dot_c); 2163 /* 2164 * Determine type of tape controller. Type is determined by 2165 * checking the result of the earlier inquiry command and 2166 * comparing vendor ids with strings in a table declared in st_conf.c. 2167 */ 2168 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2169 "st_get_conf_from_st_conf_dot_c(): looking at st_drivetypes\n"); 2170 2171 for (i = 0; i < st_ndrivetypes; i++) { 2172 if (st_drivetypes[i].length == 0) { 2173 continue; 2174 } 2175 if (strncasecmp(vidpid, st_drivetypes[i].vid, 2176 st_drivetypes[i].length)) { 2177 continue; 2178 } 2179 bcopy(&st_drivetypes[i], dp, sizeof (st_drivetypes[i])); 2180 return (1); 2181 } 2182 return (0); 2183 } 2184 2185 static int 2186 st_get_conf_from_tape_drive(struct scsi_tape *un, char *vidpid, 2187 struct st_drivetype *dp) 2188 { 2189 int bsize; 2190 ulong_t maxbsize; 2191 caddr_t buf; 2192 struct st_drivetype *tem_dp; 2193 struct read_blklim *blklim; 2194 int rval; 2195 int i; 2196 2197 ST_FUNC(ST_DEVINFO, st_get_conf_from_tape_drive); 2198 2199 /* 2200 * Determine the type of tape controller. Type is determined by 2201 * sending SCSI commands to tape drive and deriving the type from 2202 * the returned data. 2203 */ 2204 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2205 "st_get_conf_from_tape_drive(): asking tape drive\n"); 2206 2207 tem_dp = kmem_zalloc(sizeof (struct st_drivetype), KM_SLEEP); 2208 2209 /* 2210 * Make up a name 2211 */ 2212 bcopy(vidpid, tem_dp->name, VIDPIDLEN); 2213 tem_dp->name[VIDPIDLEN] = '\0'; 2214 tem_dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1)); 2215 (void) strncpy(tem_dp->vid, ST_INQUIRY->inq_vid, tem_dp->length); 2216 /* 2217 * 'clean' vendor and product strings of non-printing chars 2218 */ 2219 for (i = 0; i < VIDPIDLEN - 1; i ++) { 2220 if (tem_dp->name[i] < ' ' || tem_dp->name[i] > '~') { 2221 tem_dp->name[i] = '.'; 2222 } 2223 } 2224 2225 /* 2226 * MODE SENSE to determine block size. 2227 */ 2228 un->un_dp->options |= ST_MODE_SEL_COMP | ST_UNLOADABLE; 2229 rval = st_modesense(un); 2230 if (rval) { 2231 if (rval == EACCES) { 2232 un->un_dp->type = ST_TYPE_INVALID; 2233 rval = 1; 2234 } else { 2235 un->un_dp->options &= ~ST_MODE_SEL_COMP; 2236 rval = 0; 2237 } 2238 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2239 "st_get_conf_from_tape_drive(): fail to mode sense\n"); 2240 goto exit; 2241 } 2242 2243 /* Can mode sense page 0x10 or 0xf */ 2244 tem_dp->options |= ST_MODE_SEL_COMP; 2245 bsize = (un->un_mspl->high_bl << 16) | 2246 (un->un_mspl->mid_bl << 8) | 2247 (un->un_mspl->low_bl); 2248 2249 if (bsize == 0) { 2250 tem_dp->options |= ST_VARIABLE; 2251 tem_dp->bsize = 0; 2252 } else if (bsize > ST_MAXRECSIZE_FIXED) { 2253 rval = st_change_block_size(un, 0); 2254 if (rval) { 2255 if (rval == EACCES) { 2256 un->un_dp->type = ST_TYPE_INVALID; 2257 rval = 1; 2258 } else { 2259 rval = 0; 2260 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2261 "st_get_conf_from_tape_drive(): " 2262 "Fixed record size is too large and" 2263 "cannot switch to variable record size"); 2264 } 2265 goto exit; 2266 } 2267 tem_dp->options |= ST_VARIABLE; 2268 } else { 2269 rval = st_change_block_size(un, 0); 2270 if (rval == 0) { 2271 tem_dp->options |= ST_VARIABLE; 2272 tem_dp->bsize = 0; 2273 } else if (rval != EACCES) { 2274 tem_dp->bsize = bsize; 2275 } else { 2276 un->un_dp->type = ST_TYPE_INVALID; 2277 rval = 1; 2278 goto exit; 2279 } 2280 } 2281 2282 /* 2283 * If READ BLOCk LIMITS works and upper block size limit is 2284 * more than 64K, ST_NO_RECSIZE_LIMIT is supported. 2285 */ 2286 blklim = kmem_zalloc(sizeof (struct read_blklim), KM_SLEEP); 2287 rval = st_read_block_limits(un, blklim); 2288 if (rval) { 2289 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2290 "st_get_conf_from_tape_drive(): " 2291 "fail to read block limits.\n"); 2292 rval = 0; 2293 kmem_free(blklim, sizeof (struct read_blklim)); 2294 goto exit; 2295 } 2296 maxbsize = (blklim->max_hi << 16) + 2297 (blklim->max_mid << 8) + blklim->max_lo; 2298 if (maxbsize > ST_MAXRECSIZE_VARIABLE) { 2299 tem_dp->options |= ST_NO_RECSIZE_LIMIT; 2300 } 2301 kmem_free(blklim, sizeof (struct read_blklim)); 2302 2303 /* 2304 * Inquiry VPD page 0xb0 to see if the tape drive supports WORM 2305 */ 2306 buf = kmem_zalloc(6, KM_SLEEP); 2307 rval = st_get_special_inquiry(un, 6, buf, 0xb0); 2308 if (rval) { 2309 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2310 "st_get_conf_from_tape_drive(): " 2311 "fail to read vitial inquiry.\n"); 2312 rval = 0; 2313 kmem_free(buf, 6); 2314 goto exit; 2315 } 2316 if (buf[4] & 1) { 2317 tem_dp->options |= ST_WORMABLE; 2318 } 2319 kmem_free(buf, 6); 2320 2321 /* Assume BSD BSR KNOWS_EOD */ 2322 tem_dp->options |= ST_BSF | ST_BSR | ST_KNOWS_EOD | ST_UNLOADABLE; 2323 tem_dp->max_rretries = -1; 2324 tem_dp->max_wretries = -1; 2325 2326 /* 2327 * Decide the densities supported by tape drive by sending 2328 * REPORT DENSITY SUPPORT command. 2329 */ 2330 if (st_get_densities_from_tape_drive(un, tem_dp) == 0) { 2331 goto exit; 2332 } 2333 2334 /* 2335 * Decide the timeout values for several commands by sending 2336 * REPORT SUPPORTED OPERATION CODES command. 2337 */ 2338 rval = st_get_timeout_values_from_tape_drive(un, tem_dp); 2339 if (rval == 0 || ((rval == 1) && (tem_dp->type == ST_TYPE_INVALID))) { 2340 goto exit; 2341 } 2342 2343 bcopy(tem_dp, dp, sizeof (struct st_drivetype)); 2344 rval = 1; 2345 2346 exit: 2347 un->un_status = KEY_NO_SENSE; 2348 kmem_free(tem_dp, sizeof (struct st_drivetype)); 2349 return (rval); 2350 } 2351 2352 static int 2353 st_get_densities_from_tape_drive(struct scsi_tape *un, 2354 struct st_drivetype *dp) 2355 { 2356 int i, p; 2357 size_t buflen; 2358 ushort_t des_len; 2359 uchar_t *den_header; 2360 uchar_t num_den; 2361 uchar_t den[NDENSITIES]; 2362 uchar_t deflt[NDENSITIES]; 2363 struct report_density_desc *den_desc; 2364 2365 ST_FUNC(ST_DEVINFO, st_get_densities_from_type_drive); 2366 2367 /* 2368 * Since we have no idea how many densitiy support entries 2369 * will be returned, we send the command firstly assuming 2370 * there is only one. Then we can decide the number of 2371 * entries by available density support length. If multiple 2372 * entries exist, we will resend the command with enough 2373 * buffer size. 2374 */ 2375 buflen = sizeof (struct report_density_header) + 2376 sizeof (struct report_density_desc); 2377 den_header = kmem_zalloc(buflen, KM_SLEEP); 2378 if (st_report_density_support(un, den_header, buflen) != 0) { 2379 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2380 "st_get_conf_from_tape_drive(): fail to report density.\n"); 2381 kmem_free(den_header, buflen); 2382 return (0); 2383 } 2384 des_len = 2385 BE_16(((struct report_density_header *)den_header)->ava_dens_len); 2386 num_den = (des_len - 2) / sizeof (struct report_density_desc); 2387 2388 if (num_den > 1) { 2389 kmem_free(den_header, buflen); 2390 buflen = sizeof (struct report_density_header) + 2391 sizeof (struct report_density_desc) * num_den; 2392 den_header = kmem_zalloc(buflen, KM_SLEEP); 2393 if (st_report_density_support(un, den_header, buflen) != 0) { 2394 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2395 "st_get_conf_from_tape_drive(): " 2396 "fail to report density.\n"); 2397 kmem_free(den_header, buflen); 2398 return (0); 2399 } 2400 } 2401 2402 den_desc = (struct report_density_desc *)(den_header 2403 + sizeof (struct report_density_header)); 2404 2405 /* 2406 * Decide the drive type by assigning organization 2407 */ 2408 for (i = 0; i < ST_NUM_MEMBERS(st_vid_dt); i ++) { 2409 if (strncmp(st_vid_dt[i].vid, (char *)(den_desc->ass_org), 2410 8) == 0) { 2411 dp->type = st_vid_dt[i].type; 2412 break; 2413 } 2414 } 2415 if (i == ST_NUM_MEMBERS(st_vid_dt)) { 2416 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2417 "st_get_conf_from_tape_drive(): " 2418 "can't find match of assigned ort.\n"); 2419 kmem_free(den_header, buflen); 2420 return (0); 2421 } 2422 2423 /* 2424 * The tape drive may support many tape formats, but the st driver 2425 * supports only the four highest densities. Since density code 2426 * values are returned by ascending sequence, we start from the 2427 * last entry of density support data block descriptor. 2428 */ 2429 p = 0; 2430 den_desc += num_den - 1; 2431 for (i = 0; i < num_den && p < NDENSITIES; i ++, den_desc --) { 2432 if ((den_desc->pri_den != 0) && (den_desc->wrtok)) { 2433 if (p != 0) { 2434 if (den_desc->pri_den >= den[p - 1]) { 2435 continue; 2436 } 2437 } 2438 den[p] = den_desc->pri_den; 2439 deflt[p] = den_desc->deflt; 2440 p ++; 2441 } 2442 } 2443 2444 switch (p) { 2445 case 0: 2446 bzero(dp->densities, NDENSITIES); 2447 dp->options |= ST_AUTODEN_OVERRIDE; 2448 dp->default_density = MT_DENSITY4; 2449 break; 2450 2451 case 1: 2452 (void) memset(dp->densities, den[0], NDENSITIES); 2453 dp->options |= ST_AUTODEN_OVERRIDE; 2454 dp->default_density = MT_DENSITY4; 2455 break; 2456 2457 case 2: 2458 dp->densities[0] = den[1]; 2459 dp->densities[1] = den[1]; 2460 dp->densities[2] = den[0]; 2461 dp->densities[3] = den[0]; 2462 if (deflt[0]) { 2463 dp->default_density = MT_DENSITY4; 2464 } else { 2465 dp->default_density = MT_DENSITY2; 2466 } 2467 break; 2468 2469 case 3: 2470 dp->densities[0] = den[2]; 2471 dp->densities[1] = den[1]; 2472 dp->densities[2] = den[0]; 2473 dp->densities[3] = den[0]; 2474 if (deflt[0]) { 2475 dp->default_density = MT_DENSITY4; 2476 } else if (deflt[1]) { 2477 dp->default_density = MT_DENSITY2; 2478 } else { 2479 dp->default_density = MT_DENSITY1; 2480 } 2481 break; 2482 2483 default: 2484 for (i = p; i > p - NDENSITIES; i --) { 2485 dp->densities[i - 1] = den[p - i]; 2486 } 2487 if (deflt[0]) { 2488 dp->default_density = MT_DENSITY4; 2489 } else if (deflt[1]) { 2490 dp->default_density = MT_DENSITY3; 2491 } else if (deflt[2]) { 2492 dp->default_density = MT_DENSITY2; 2493 } else { 2494 dp->default_density = MT_DENSITY1; 2495 } 2496 break; 2497 } 2498 2499 bzero(dp->mediatype, NDENSITIES); 2500 2501 kmem_free(den_header, buflen); 2502 return (1); 2503 } 2504 2505 static int 2506 st_get_timeout_values_from_tape_drive(struct scsi_tape *un, 2507 struct st_drivetype *dp) 2508 { 2509 ushort_t timeout; 2510 int rval; 2511 2512 ST_FUNC(ST_DEVINFO, st_get_timeout_values_from_type_drive); 2513 2514 rval = st_get_timeouts_value(un, SCMD_ERASE, &timeout, 0); 2515 if (rval) { 2516 if (rval == EACCES) { 2517 un->un_dp->type = ST_TYPE_INVALID; 2518 dp->type = ST_TYPE_INVALID; 2519 return (1); 2520 } 2521 return (0); 2522 } 2523 dp->erase_timeout = timeout; 2524 2525 rval = st_get_timeouts_value(un, SCMD_READ, &timeout, 0); 2526 if (rval) { 2527 if (rval == EACCES) { 2528 un->un_dp->type = ST_TYPE_INVALID; 2529 dp->type = ST_TYPE_INVALID; 2530 return (1); 2531 } 2532 return (0); 2533 } 2534 dp->io_timeout = timeout; 2535 2536 rval = st_get_timeouts_value(un, SCMD_WRITE, &timeout, 0); 2537 if (rval) { 2538 if (rval == EACCES) { 2539 un->un_dp->type = ST_TYPE_INVALID; 2540 dp->type = ST_TYPE_INVALID; 2541 return (1); 2542 } 2543 return (0); 2544 } 2545 dp->io_timeout = max(dp->io_timeout, timeout); 2546 2547 rval = st_get_timeouts_value(un, SCMD_SPACE, &timeout, 0); 2548 if (rval) { 2549 if (rval == EACCES) { 2550 un->un_dp->type = ST_TYPE_INVALID; 2551 dp->type = ST_TYPE_INVALID; 2552 return (1); 2553 } 2554 return (0); 2555 } 2556 dp->space_timeout = timeout; 2557 2558 rval = st_get_timeouts_value(un, SCMD_LOAD, &timeout, 0); 2559 if (rval) { 2560 if (rval == EACCES) { 2561 un->un_dp->type = ST_TYPE_INVALID; 2562 dp->type = ST_TYPE_INVALID; 2563 return (1); 2564 } 2565 return (0); 2566 } 2567 dp->load_timeout = timeout; 2568 dp->unload_timeout = timeout; 2569 2570 rval = st_get_timeouts_value(un, SCMD_REWIND, &timeout, 0); 2571 if (rval) { 2572 if (rval == EACCES) { 2573 un->un_dp->type = ST_TYPE_INVALID; 2574 dp->type = ST_TYPE_INVALID; 2575 return (1); 2576 } 2577 return (0); 2578 } 2579 dp->rewind_timeout = timeout; 2580 2581 rval = st_get_timeouts_value(un, SCMD_INQUIRY, &timeout, 0); 2582 if (rval) { 2583 if (rval == EACCES) { 2584 un->un_dp->type = ST_TYPE_INVALID; 2585 dp->type = ST_TYPE_INVALID; 2586 return (1); 2587 } 2588 return (0); 2589 } 2590 dp->non_motion_timeout = timeout; 2591 2592 return (1); 2593 } 2594 2595 static int 2596 st_get_timeouts_value(struct scsi_tape *un, uchar_t option_code, 2597 ushort_t *timeout_value, ushort_t service_action) 2598 { 2599 uchar_t *timeouts; 2600 uchar_t *oper; 2601 uchar_t support; 2602 uchar_t cdbsize; 2603 uchar_t ctdp; 2604 size_t buflen; 2605 int rval; 2606 2607 ST_FUNC(ST_DEVINFO, st_get_timeouts_value); 2608 2609 buflen = sizeof (struct one_com_des) + 2610 sizeof (struct com_timeout_des); 2611 oper = kmem_zalloc(buflen, KM_SLEEP); 2612 rval = st_report_supported_operation(un, oper, option_code, 2613 service_action); 2614 2615 if (rval) { 2616 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2617 "st_get_timeouts_value(): " 2618 "fail to timeouts value for command %d.\n", option_code); 2619 kmem_free(oper, buflen); 2620 return (rval); 2621 } 2622 2623 support = ((struct one_com_des *)oper)->support; 2624 if ((support != SUPPORT_VALUES_SUPPORT_SCSI) && 2625 (support != SUPPORT_VALUES_SUPPORT_VENDOR)) { 2626 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2627 "st_get_timeouts_value(): " 2628 "command %d is not supported.\n", option_code); 2629 kmem_free(oper, buflen); 2630 return (ENOTSUP); 2631 } 2632 2633 ctdp = ((struct one_com_des *)oper)->ctdp; 2634 if (!ctdp) { 2635 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2636 "st_get_timeouts_value(): " 2637 "command timeout is not included.\n"); 2638 kmem_free(oper, buflen); 2639 return (ENOTSUP); 2640 } 2641 2642 cdbsize = BE_16(((struct one_com_des *)oper)->cdb_size); 2643 timeouts = (uchar_t *)(oper + cdbsize + 4); 2644 2645 /* 2646 * Timeout value in seconds is 4 bytes, but we only support the lower 2 2647 * bytes. If the higher 2 bytes are not zero, the timeout value is set 2648 * to 0xFFFF. 2649 */ 2650 if (*(timeouts + 8) != 0 || *(timeouts + 9) != 0) { 2651 *timeout_value = USHRT_MAX; 2652 } else { 2653 *timeout_value = ((*(timeouts + 10)) << 8) | 2654 (*(timeouts + 11)); 2655 } 2656 2657 kmem_free(oper, buflen); 2658 return (0); 2659 } 2660 2661 static int 2662 st_get_default_conf(struct scsi_tape *un, char *vidpid, struct st_drivetype *dp) 2663 { 2664 int i; 2665 2666 ST_FUNC(ST_DEVINFO, st_get_default_conf); 2667 2668 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 2669 "st_get_default_conf(): making drivetype from INQ cmd\n"); 2670 2671 /* 2672 * Make up a name 2673 */ 2674 bcopy("Vendor '", dp->name, 8); 2675 bcopy(vidpid, &dp->name[8], VIDLEN); 2676 bcopy("' Product '", &dp->name[16], 11); 2677 bcopy(&vidpid[8], &dp->name[27], PIDLEN); 2678 dp->name[ST_NAMESIZE - 2] = '\''; 2679 dp->name[ST_NAMESIZE - 1] = '\0'; 2680 dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1)); 2681 (void) strncpy(dp->vid, ST_INQUIRY->inq_vid, dp->length); 2682 /* 2683 * 'clean' vendor and product strings of non-printing chars 2684 */ 2685 for (i = 0; i < ST_NAMESIZE - 2; i++) { 2686 if (dp->name[i] < ' ' || dp->name[i] > '~') { 2687 dp->name[i] = '.'; 2688 } 2689 } 2690 dp->type = ST_TYPE_INVALID; 2691 dp->options |= (ST_DYNAMIC | ST_UNLOADABLE | ST_MODE_SEL_COMP); 2692 2693 return (1); /* Can Not Fail */ 2694 } 2695 2696 /* 2697 * Regular Unix Entry points 2698 */ 2699 2700 2701 2702 /* ARGSUSED */ 2703 static int 2704 st_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p) 2705 { 2706 dev_t dev = *dev_p; 2707 int rval = 0; 2708 2709 GET_SOFT_STATE(dev); 2710 2711 ST_ENTR(ST_DEVINFO, st_open); 2712 2713 /* 2714 * validate that we are addressing a sensible unit 2715 */ 2716 mutex_enter(ST_MUTEX); 2717 2718 #ifdef STDEBUG 2719 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2720 "st_open(node = %s dev = 0x%lx, flag = %d, otyp = %d)\n", 2721 st_dev_name(dev), *dev_p, flag, otyp); 2722 #endif 2723 2724 /* 2725 * All device accesss go thru st_strategy() where we check 2726 * suspend status 2727 */ 2728 2729 if (!un->un_attached) { 2730 st_known_tape_type(un); 2731 if (!un->un_attached) { 2732 rval = ENXIO; 2733 goto exit; 2734 } 2735 2736 } 2737 2738 /* 2739 * Check for the case of the tape in the middle of closing. 2740 * This isn't simply a check of the current state, because 2741 * we could be in state of sensing with the previous state 2742 * that of closing. 2743 * 2744 * And don't allow multiple opens. 2745 */ 2746 if (!(flag & (FNDELAY | FNONBLOCK)) && IS_CLOSING(un)) { 2747 un->un_laststate = un->un_state; 2748 un->un_state = ST_STATE_CLOSE_PENDING_OPEN; 2749 while (IS_CLOSING(un) || 2750 un->un_state == ST_STATE_CLOSE_PENDING_OPEN) { 2751 if (cv_wait_sig(&un->un_clscv, ST_MUTEX) == 0) { 2752 rval = EINTR; 2753 un->un_state = un->un_laststate; 2754 goto exit; 2755 } 2756 } 2757 } else if (un->un_state != ST_STATE_CLOSED) { 2758 rval = EBUSY; 2759 goto busy; 2760 } 2761 2762 /* 2763 * record current dev 2764 */ 2765 un->un_dev = dev; 2766 un->un_oflags = flag; /* save for use in st_tape_init() */ 2767 un->un_errno = 0; /* no errors yet */ 2768 un->un_restore_pos = 0; 2769 un->un_rqs_state = 0; 2770 2771 /* 2772 * If we are opening O_NDELAY, or O_NONBLOCK, we don't check for 2773 * anything, leave internal states alone, if fileno >= 0 2774 */ 2775 if (flag & (FNDELAY | FNONBLOCK)) { 2776 switch (un->un_pos.pmode) { 2777 2778 case invalid: 2779 un->un_state = ST_STATE_OFFLINE; 2780 break; 2781 2782 case legacy: 2783 /* 2784 * If position is anything other than rewound. 2785 */ 2786 if (un->un_pos.fileno != 0 || un->un_pos.blkno != 0) { 2787 /* 2788 * set un_read_only/write-protect status. 2789 * 2790 * If the tape is not bot we can assume 2791 * that mspl->wp_status is set properly. 2792 * else 2793 * we need to do a mode sense/Tur once 2794 * again to get the actual tape status.(since 2795 * user might have replaced the tape) 2796 * Hence make the st state OFFLINE so that 2797 * we re-intialize the tape once again. 2798 */ 2799 un->un_read_only = 2800 (un->un_oflags & FWRITE) ? RDWR : RDONLY; 2801 un->un_state = ST_STATE_OPEN_PENDING_IO; 2802 } else { 2803 un->un_state = ST_STATE_OFFLINE; 2804 } 2805 break; 2806 case logical: 2807 if (un->un_pos.lgclblkno == 0) { 2808 un->un_state = ST_STATE_OFFLINE; 2809 } else { 2810 un->un_read_only = 2811 (un->un_oflags & FWRITE) ? RDWR : RDONLY; 2812 un->un_state = ST_STATE_OPEN_PENDING_IO; 2813 } 2814 break; 2815 } 2816 rval = 0; 2817 } else { 2818 /* 2819 * Not opening O_NDELAY. 2820 */ 2821 un->un_state = ST_STATE_OPENING; 2822 2823 /* 2824 * Clear error entry stack 2825 */ 2826 st_empty_error_stack(un); 2827 2828 rval = st_tape_init(un); 2829 if ((rval == EACCES) && (un->un_read_only & WORM)) { 2830 un->un_state = ST_STATE_OPEN_PENDING_IO; 2831 rval = 0; /* so open doesn't fail */ 2832 } else if (rval) { 2833 /* 2834 * Release the tape unit, if reserved and not 2835 * preserve reserve. 2836 */ 2837 if ((un->un_rsvd_status & 2838 (ST_RESERVE | ST_PRESERVE_RESERVE)) == ST_RESERVE) { 2839 (void) st_reserve_release(un, ST_RELEASE, 2840 st_uscsi_cmd); 2841 } 2842 } else { 2843 un->un_state = ST_STATE_OPEN_PENDING_IO; 2844 } 2845 } 2846 2847 exit: 2848 /* 2849 * we don't want any uninvited guests scrogging our data when we're 2850 * busy with something, so for successful opens or failed opens 2851 * (except for EBUSY), reset these counters and state appropriately. 2852 */ 2853 if (rval != EBUSY) { 2854 if (rval) { 2855 un->un_state = ST_STATE_CLOSED; 2856 } 2857 un->un_err_resid = 0; 2858 un->un_retry_ct = 0; 2859 un->un_tran_retry_ct = 0; 2860 } 2861 busy: 2862 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2863 "st_open: return val = %x, state = %d\n", rval, un->un_state); 2864 mutex_exit(ST_MUTEX); 2865 return (rval); 2866 2867 } 2868 2869 static int 2870 st_tape_init(struct scsi_tape *un) 2871 { 2872 int err; 2873 int rval = 0; 2874 2875 ST_FUNC(ST_DEVINFO, st_tape_init); 2876 2877 ASSERT(mutex_owned(ST_MUTEX)); 2878 2879 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 2880 "st_tape_init(un = 0x%p, oflags = %d)\n", (void*)un, un->un_oflags); 2881 2882 /* 2883 * Clean up after any errors left by 'last' close. 2884 * This also handles the case of the initial open. 2885 */ 2886 if (un->un_state != ST_STATE_INITIALIZING) { 2887 un->un_laststate = un->un_state; 2888 un->un_state = ST_STATE_OPENING; 2889 } 2890 2891 un->un_kbytes_xferred = 0; 2892 2893 /* 2894 * do a throw away TUR to clear check condition 2895 */ 2896 err = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 2897 2898 /* 2899 * If test unit ready fails because the drive is reserved 2900 * by another host fail the open for no access. 2901 */ 2902 if (err) { 2903 if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) { 2904 un->un_state = ST_STATE_CLOSED; 2905 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 2906 "st_tape_init: RESERVATION CONFLICT\n"); 2907 rval = EACCES; 2908 goto exit; 2909 } 2910 } 2911 2912 /* 2913 * Tape self identification could fail if the tape drive is used by 2914 * another host during attach time. We try to get the tape type 2915 * again. This is also applied to any posponed configuration methods. 2916 */ 2917 if (un->un_dp->type == ST_TYPE_INVALID) { 2918 un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE; 2919 st_known_tape_type(un); 2920 } 2921 2922 /* 2923 * If the tape type is still invalid, try to determine the generic 2924 * configuration. 2925 */ 2926 if (un->un_dp->type == ST_TYPE_INVALID) { 2927 rval = st_determine_generic(un); 2928 if (rval) { 2929 if (rval != EACCES) { 2930 rval = EIO; 2931 } 2932 un->un_state = ST_STATE_CLOSED; 2933 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 2934 "st_tape_init: %s invalid type\n", 2935 rval == EACCES ? "EACCES" : "EIO"); 2936 goto exit; 2937 } 2938 /* 2939 * If this is a Unknown Type drive, 2940 * Use the READ BLOCK LIMITS to determine if 2941 * allow large xfer is approprate if not globally 2942 * disabled with st_allow_large_xfer. 2943 */ 2944 un->un_allow_large_xfer = (uchar_t)st_allow_large_xfer; 2945 } else { 2946 2947 /* 2948 * If we allow_large_xfer (ie >64k) and have not yet found out 2949 * the max block size supported by the drive, 2950 * find it by issueing a READ_BLKLIM command. 2951 * if READ_BLKLIM cmd fails, assume drive doesn't 2952 * allow_large_xfer and min/max block sizes as 1 byte and 63k. 2953 */ 2954 un->un_allow_large_xfer = st_allow_large_xfer && 2955 (un->un_dp->options & ST_NO_RECSIZE_LIMIT); 2956 } 2957 /* 2958 * if maxbsize is unknown, set the maximum block size. 2959 */ 2960 if (un->un_maxbsize == MAXBSIZE_UNKNOWN) { 2961 2962 /* 2963 * Get the Block limits of the tape drive. 2964 * if un->un_allow_large_xfer = 0 , then make sure 2965 * that maxbsize is <= ST_MAXRECSIZE_FIXED. 2966 */ 2967 un->un_rbl = kmem_zalloc(RBLSIZE, KM_SLEEP); 2968 2969 err = st_cmd(un, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD); 2970 if (err) { 2971 /* Retry */ 2972 err = st_cmd(un, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD); 2973 } 2974 if (!err) { 2975 2976 /* 2977 * if cmd successful, use limit returned 2978 */ 2979 un->un_maxbsize = (un->un_rbl->max_hi << 16) + 2980 (un->un_rbl->max_mid << 8) + 2981 un->un_rbl->max_lo; 2982 un->un_minbsize = (un->un_rbl->min_hi << 8) + 2983 un->un_rbl->min_lo; 2984 un->un_data_mod = 1 << un->un_rbl->granularity; 2985 if ((un->un_maxbsize == 0) || 2986 (un->un_allow_large_xfer == 0 && 2987 un->un_maxbsize > ST_MAXRECSIZE_FIXED)) { 2988 un->un_maxbsize = ST_MAXRECSIZE_FIXED; 2989 2990 } else if (un->un_dp->type == ST_TYPE_DEFAULT) { 2991 /* 2992 * Drive is not one that is configured, But the 2993 * READ BLOCK LIMITS tells us it can do large 2994 * xfers. 2995 */ 2996 if (un->un_maxbsize > ST_MAXRECSIZE_FIXED) { 2997 un->un_dp->options |= 2998 ST_NO_RECSIZE_LIMIT; 2999 } 3000 /* 3001 * If max and mimimum block limits are the 3002 * same this is a fixed block size device. 3003 */ 3004 if (un->un_maxbsize == un->un_minbsize) { 3005 un->un_dp->options &= ~ST_VARIABLE; 3006 } 3007 } 3008 3009 if (un->un_minbsize == 0) { 3010 un->un_minbsize = 1; 3011 } 3012 3013 } else { /* error on read block limits */ 3014 3015 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 3016 "!st_tape_init: Error on READ BLOCK LIMITS," 3017 " errno = %d un_rsvd_status = 0x%X\n", 3018 err, un->un_rsvd_status); 3019 3020 /* 3021 * since read block limits cmd failed, 3022 * do not allow large xfers. 3023 * use old values in st_minphys 3024 */ 3025 if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) { 3026 rval = EACCES; 3027 } else { 3028 un->un_allow_large_xfer = 0; 3029 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 3030 "!Disabling large transfers\n"); 3031 3032 /* 3033 * we guess maxbsize and minbsize 3034 */ 3035 if (un->un_bsize) { 3036 un->un_maxbsize = un->un_minbsize = 3037 un->un_bsize; 3038 } else { 3039 un->un_maxbsize = ST_MAXRECSIZE_FIXED; 3040 un->un_minbsize = 1; 3041 } 3042 /* 3043 * Data Mod must be set, 3044 * Even if read block limits fails. 3045 * Prevents Divide By Zero in st_rw(). 3046 */ 3047 un->un_data_mod = 1; 3048 } 3049 } 3050 if (un->un_rbl) { 3051 kmem_free(un->un_rbl, RBLSIZE); 3052 un->un_rbl = NULL; 3053 } 3054 3055 if (rval) { 3056 goto exit; 3057 } 3058 } 3059 3060 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 3061 "maxdma = %d, maxbsize = %d, minbsize = %d, %s large xfer\n", 3062 un->un_maxdma, un->un_maxbsize, un->un_minbsize, 3063 (un->un_allow_large_xfer ? "ALLOW": "DON'T ALLOW")); 3064 3065 err = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 3066 3067 if (err != 0) { 3068 if (err == EINTR) { 3069 un->un_laststate = un->un_state; 3070 un->un_state = ST_STATE_CLOSED; 3071 rval = EINTR; 3072 goto exit; 3073 } 3074 /* 3075 * Make sure the tape is ready 3076 */ 3077 un->un_pos.pmode = invalid; 3078 if (un->un_status != KEY_UNIT_ATTENTION) { 3079 /* 3080 * allow open no media. Subsequent MTIOCSTATE 3081 * with media present will complete the open 3082 * logic. 3083 */ 3084 un->un_laststate = un->un_state; 3085 if (un->un_oflags & (FNONBLOCK|FNDELAY)) { 3086 un->un_mediastate = MTIO_EJECTED; 3087 un->un_state = ST_STATE_OFFLINE; 3088 rval = 0; 3089 goto exit; 3090 } else { 3091 un->un_state = ST_STATE_CLOSED; 3092 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3093 "st_tape_init EIO no media, not opened " 3094 "O_NONBLOCK|O_EXCL\n"); 3095 rval = EIO; 3096 goto exit; 3097 } 3098 } 3099 } 3100 3101 /* 3102 * On each open, initialize block size from drivetype struct, 3103 * as it could have been changed by MTSRSZ ioctl. 3104 * Now, ST_VARIABLE simply means drive is capable of variable 3105 * mode. All drives are assumed to support fixed records. 3106 * Hence, un_bsize tells what mode the drive is in. 3107 * un_bsize = 0 - variable record length 3108 * = x - fixed record length is x 3109 */ 3110 un->un_bsize = un->un_dp->bsize; 3111 3112 /* 3113 * If saved position is valid go there 3114 */ 3115 if (un->un_restore_pos) { 3116 un->un_restore_pos = 0; 3117 un->un_pos.fileno = un->un_save_fileno; 3118 un->un_pos.blkno = un->un_save_blkno; 3119 rval = st_validate_tapemarks(un, st_uscsi_cmd, &un->un_pos); 3120 if (rval != 0) { 3121 if (rval != EACCES) { 3122 rval = EIO; 3123 } 3124 un->un_laststate = un->un_state; 3125 un->un_state = ST_STATE_CLOSED; 3126 goto exit; 3127 } 3128 } 3129 3130 if (un->un_pos.pmode == invalid) { 3131 rval = st_loadtape(un); 3132 if (rval) { 3133 if (rval != EACCES) { 3134 rval = EIO; 3135 } 3136 un->un_laststate = un->un_state; 3137 un->un_state = ST_STATE_CLOSED; 3138 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3139 "st_tape_init: %s can't open tape\n", 3140 rval == EACCES ? "EACCES" : "EIO"); 3141 goto exit; 3142 } 3143 } 3144 3145 /* 3146 * do a mode sense to pick up state of current write-protect, 3147 * Could cause reserve and fail due to conflict. 3148 */ 3149 if (un->un_unit_attention_flags) { 3150 rval = st_modesense(un); 3151 if (rval == EACCES) { 3152 goto exit; 3153 } 3154 } 3155 3156 /* 3157 * If we are opening the tape for writing, check 3158 * to make sure that the tape can be written. 3159 */ 3160 if (un->un_oflags & FWRITE) { 3161 err = 0; 3162 if (un->un_mspl->wp) { 3163 un->un_status = KEY_WRITE_PROTECT; 3164 un->un_laststate = un->un_state; 3165 un->un_state = ST_STATE_CLOSED; 3166 rval = EACCES; 3167 /* 3168 * STK sets the wp bit if volsafe tape is loaded. 3169 */ 3170 if ((un->un_dp->type == MT_ISSTK9840) && 3171 (un->un_dp->options & ST_WORMABLE)) { 3172 un->un_read_only = RDONLY; 3173 } else { 3174 goto exit; 3175 } 3176 } else { 3177 un->un_read_only = RDWR; 3178 } 3179 } else { 3180 un->un_read_only = RDONLY; 3181 } 3182 3183 if (un->un_dp->options & ST_WORMABLE && 3184 un->un_unit_attention_flags) { 3185 un->un_read_only |= un->un_wormable(un); 3186 3187 if (((un->un_read_only == WORM) || 3188 (un->un_read_only == RDWORM)) && 3189 ((un->un_oflags & FWRITE) == FWRITE)) { 3190 un->un_status = KEY_DATA_PROTECT; 3191 rval = EACCES; 3192 ST_DEBUG4(ST_DEVINFO, st_label, CE_NOTE, 3193 "read_only = %d eof = %d oflag = %d\n", 3194 un->un_read_only, un->un_pos.eof, un->un_oflags); 3195 } 3196 } 3197 3198 /* 3199 * If we're opening the tape write-only, we need to 3200 * write 2 filemarks on the HP 1/2 inch drive, to 3201 * create a null file. 3202 */ 3203 if ((un->un_read_only == RDWR) || 3204 (un->un_read_only == WORM) && (un->un_oflags & FWRITE)) { 3205 if (un->un_dp->options & ST_REEL) { 3206 un->un_fmneeded = 2; 3207 } else { 3208 un->un_fmneeded = 1; 3209 } 3210 } else { 3211 un->un_fmneeded = 0; 3212 } 3213 3214 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 3215 "fmneeded = %x\n", un->un_fmneeded); 3216 3217 /* 3218 * Make sure the density can be selected correctly. 3219 * If WORM can only write at the append point which in most cases 3220 * isn't BOP. st_determine_density() with a B_WRITE only attempts 3221 * to set and try densities if a BOP. 3222 */ 3223 if (st_determine_density(un, 3224 un->un_read_only == RDWR ? B_WRITE : B_READ)) { 3225 un->un_status = KEY_ILLEGAL_REQUEST; 3226 un->un_laststate = un->un_state; 3227 un->un_state = ST_STATE_CLOSED; 3228 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 3229 "st_tape_init: EIO can't determine density\n"); 3230 rval = EIO; 3231 goto exit; 3232 } 3233 3234 /* 3235 * Destroy the knowledge that we have 'determined' 3236 * density so that a later read at BOT comes along 3237 * does the right density determination. 3238 */ 3239 3240 un->un_density_known = 0; 3241 3242 3243 /* 3244 * Okay, the tape is loaded and either at BOT or somewhere past. 3245 * Mark the state such that any I/O or tape space operations 3246 * will get/set the right density, etc.. 3247 */ 3248 un->un_laststate = un->un_state; 3249 un->un_lastop = ST_OP_NIL; 3250 un->un_mediastate = MTIO_INSERTED; 3251 cv_broadcast(&un->un_state_cv); 3252 3253 /* 3254 * Set test append flag if writing. 3255 * First write must check that tape is positioned correctly. 3256 */ 3257 un->un_test_append = (un->un_oflags & FWRITE); 3258 3259 /* 3260 * if there are pending unit attention flags. 3261 * Check that the media has not changed. 3262 */ 3263 if (un->un_unit_attention_flags) { 3264 rval = st_get_media_identification(un, st_uscsi_cmd); 3265 if (rval != 0 && rval != EACCES) { 3266 rval = EIO; 3267 } 3268 un->un_unit_attention_flags = 0; 3269 } 3270 3271 exit: 3272 un->un_err_resid = 0; 3273 un->un_last_resid = 0; 3274 un->un_last_count = 0; 3275 3276 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3277 "st_tape_init: return val = %x\n", rval); 3278 return (rval); 3279 3280 } 3281 3282 3283 3284 /* ARGSUSED */ 3285 static int 3286 st_close(dev_t dev, int flag, int otyp, cred_t *cred_p) 3287 { 3288 int err = 0; 3289 int count, last_state; 3290 minor_t minor = getminor(dev); 3291 #ifdef __x86 3292 struct contig_mem *cp, *cp_temp; 3293 #endif 3294 3295 GET_SOFT_STATE(dev); 3296 3297 ST_ENTR(ST_DEVINFO, st_close); 3298 3299 /* 3300 * wait till all cmds in the pipeline have been completed 3301 */ 3302 mutex_enter(ST_MUTEX); 3303 3304 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3305 "st_close(dev = 0x%lx, flag = %d, otyp = %d)\n", dev, flag, otyp); 3306 3307 st_wait_for_io(un); 3308 3309 /* turn off persistent errors on close, as we want close to succeed */ 3310 st_turn_pe_off(un); 3311 3312 /* 3313 * set state to indicate that we are in process of closing 3314 */ 3315 last_state = un->un_laststate = un->un_state; 3316 un->un_state = ST_STATE_CLOSING; 3317 3318 ST_POS(ST_DEVINFO, "st_close1:", &un->un_pos); 3319 3320 /* 3321 * BSD behavior: 3322 * a close always causes a silent span to the next file if we've hit 3323 * an EOF (but not yet read across it). 3324 */ 3325 if ((minor & MT_BSD) && (un->un_pos.eof == ST_EOF)) { 3326 if (un->un_pos.pmode != invalid) { 3327 un->un_pos.fileno++; 3328 un->un_pos.blkno = 0; 3329 } 3330 un->un_pos.eof = ST_NO_EOF; 3331 } 3332 3333 /* 3334 * SVR4 behavior for skipping to next file: 3335 * 3336 * If we have not seen a filemark, space to the next file 3337 * 3338 * If we have already seen the filemark we are physically in the next 3339 * file and we only increment the filenumber 3340 */ 3341 if (((minor & (MT_BSD | MT_NOREWIND)) == MT_NOREWIND) && 3342 (flag & FREAD) && /* reading or at least asked to */ 3343 ((un->un_pos.blkno != 0) && /* inside a file */ 3344 (un->un_lastop != ST_OP_WRITE) && /* Didn't just write */ 3345 (un->un_lastop != ST_OP_WEOF))) { /* or write filemarks */ 3346 switch (un->un_pos.eof) { 3347 case ST_NO_EOF: 3348 /* 3349 * if we were reading and did not read the complete file 3350 * skip to the next file, leaving the tape correctly 3351 * positioned to read the first record of the next file 3352 * Check first for REEL if we are at EOT by trying to 3353 * read a block 3354 */ 3355 if ((un->un_dp->options & ST_REEL) && 3356 (!(un->un_dp->options & ST_READ_IGNORE_EOFS)) && 3357 (un->un_pos.blkno == 0)) { 3358 if (st_cmd(un, SCMD_SPACE, Blk(1), SYNC_CMD)) { 3359 ST_DEBUG2(ST_DEVINFO, st_label, 3360 SCSI_DEBUG, 3361 "st_close : EIO can't space\n"); 3362 err = EIO; 3363 break; 3364 } 3365 if (un->un_pos.eof >= ST_EOF_PENDING) { 3366 un->un_pos.eof = ST_EOT_PENDING; 3367 un->un_pos.fileno += 1; 3368 un->un_pos.blkno = 0; 3369 break; 3370 } 3371 } 3372 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 3373 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3374 "st_close: EIO can't space #2\n"); 3375 err = EIO; 3376 } else { 3377 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3378 "st_close2: fileno=%x,blkno=%x,eof=%x\n", 3379 un->un_pos.fileno, un->un_pos.blkno, 3380 un->un_pos.eof); 3381 un->un_pos.eof = ST_NO_EOF; 3382 } 3383 break; 3384 3385 case ST_EOF_PENDING: 3386 case ST_EOF: 3387 un->un_pos.fileno += 1; 3388 un->un_pos.lgclblkno += 1; 3389 un->un_pos.blkno = 0; 3390 un->un_pos.eof = ST_NO_EOF; 3391 break; 3392 3393 case ST_EOT: 3394 case ST_EOT_PENDING: 3395 /* nothing to do */ 3396 break; 3397 default: 3398 scsi_log(ST_DEVINFO, st_label, CE_PANIC, 3399 "Undefined state 0x%x", un->un_pos.eof); 3400 3401 } 3402 } 3403 3404 3405 /* 3406 * For performance reasons (HP 88780), the driver should 3407 * postpone writing the second tape mark until just before a file 3408 * positioning ioctl is issued (e.g., rewind). This means that 3409 * the user must not manually rewind the tape because the tape will 3410 * be missing the second tape mark which marks EOM. 3411 * However, this small performance improvement is not worth the risk. 3412 */ 3413 3414 /* 3415 * We need to back up over the filemark we inadvertently popped 3416 * over doing a read in between the two filemarks that constitute 3417 * logical eot for 1/2" tapes. Note that ST_EOT_PENDING is only 3418 * set while reading. 3419 * 3420 * If we happen to be at physical eot (ST_EOM) (writing case), 3421 * the writing of filemark(s) will clear the ST_EOM state, which 3422 * we don't want, so we save this state and restore it later. 3423 */ 3424 3425 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3426 "flag=%x, fmneeded=%x, lastop=%x, eof=%x\n", 3427 flag, un->un_fmneeded, un->un_lastop, un->un_pos.eof); 3428 3429 if (un->un_pos.eof == ST_EOT_PENDING) { 3430 if (minor & MT_NOREWIND) { 3431 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 3432 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3433 "st_close: EIO can't space #3\n"); 3434 err = EIO; 3435 } else { 3436 un->un_pos.blkno = 0; 3437 un->un_pos.eof = ST_EOT; 3438 } 3439 } else { 3440 un->un_pos.eof = ST_NO_EOF; 3441 } 3442 3443 /* 3444 * Do we need to write a file mark? 3445 * 3446 * only write filemarks if there are fmks to be written and 3447 * - open for write (possibly read/write) 3448 * - the last operation was a write 3449 * or: 3450 * - opened for wronly 3451 * - no data was written 3452 */ 3453 } else if ((un->un_pos.pmode != invalid) && 3454 (un->un_fmneeded > 0) && 3455 (((flag & FWRITE) && 3456 ((un->un_lastop == ST_OP_WRITE)||(un->un_lastop == ST_OP_WEOF))) || 3457 ((flag == FWRITE) && (un->un_lastop == ST_OP_NIL)))) { 3458 3459 /* save ST_EOM state */ 3460 int was_at_eom = (un->un_pos.eof == ST_EOM) ? 1 : 0; 3461 3462 /* 3463 * Note that we will write a filemark if we had opened 3464 * the tape write only and no data was written, thus 3465 * creating a null file. 3466 * 3467 * If the user already wrote one, we only have to write 1 more. 3468 * If they wrote two, we don't have to write any. 3469 */ 3470 3471 count = un->un_fmneeded; 3472 if (count > 0) { 3473 if (st_cmd(un, SCMD_WRITE_FILE_MARK, count, SYNC_CMD)) { 3474 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3475 "st_close : EIO can't wfm\n"); 3476 err = EIO; 3477 } 3478 if ((un->un_dp->options & ST_REEL) && 3479 (minor & MT_NOREWIND)) { 3480 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 3481 ST_DEBUG2(ST_DEVINFO, st_label, 3482 SCSI_DEBUG, 3483 "st_close : EIO space fmk(-1)\n"); 3484 err = EIO; 3485 } 3486 un->un_pos.eof = ST_NO_EOF; 3487 /* fix up block number */ 3488 un->un_pos.blkno = 0; 3489 } 3490 } 3491 3492 /* 3493 * If we aren't going to be rewinding, and we were at 3494 * physical eot, restore the state that indicates we 3495 * are at physical eot. Once you have reached physical 3496 * eot, and you close the tape, the only thing you can 3497 * do on the next open is to rewind. Access to trailer 3498 * records is only allowed without closing the device. 3499 */ 3500 if ((minor & MT_NOREWIND) == 0 && was_at_eom) { 3501 un->un_pos.eof = ST_EOM; 3502 } 3503 } 3504 3505 /* 3506 * report soft errors if enabled and available, if we never accessed 3507 * the drive, don't get errors. This will prevent some DAT error 3508 * messages upon LOG SENSE. 3509 */ 3510 if (st_report_soft_errors_on_close && 3511 (un->un_dp->options & ST_SOFT_ERROR_REPORTING) && 3512 (last_state != ST_STATE_OFFLINE)) { 3513 (void) st_report_soft_errors(dev, flag); 3514 } 3515 3516 3517 /* 3518 * Do we need to rewind? Can we rewind? 3519 */ 3520 if ((minor & MT_NOREWIND) == 0 && 3521 un->un_pos.pmode != invalid && err == 0) { 3522 /* 3523 * We'd like to rewind with the 3524 * 'immediate' bit set, but this 3525 * causes problems on some drives 3526 * where subsequent opens get a 3527 * 'NOT READY' error condition 3528 * back while the tape is rewinding, 3529 * which is impossible to distinguish 3530 * from the condition of 'no tape loaded'. 3531 * 3532 * Also, for some targets, if you disconnect 3533 * with the 'immediate' bit set, you don't 3534 * actually return right away, i.e., the 3535 * target ignores your request for immediate 3536 * return. 3537 * 3538 * Instead, we'll fire off an async rewind 3539 * command. We'll mark the device as closed, 3540 * and any subsequent open will stall on 3541 * the first TEST_UNIT_READY until the rewind 3542 * completes. 3543 */ 3544 3545 /* 3546 * Used to be if reserve was not supported we'd send an 3547 * asynchronious rewind. Comments above may be slightly invalid 3548 * as the immediate bit was never set. Doing an immedate rewind 3549 * makes sense, I think fixes to not ready status might handle 3550 * the problems described above. 3551 */ 3552 if (un->un_sd->sd_inq->inq_ansi < 2) { 3553 (void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 3554 } else { 3555 /* flush data for older drives per scsi spec. */ 3556 (void) st_cmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD); 3557 (void) st_cmd(un, SCMD_REWIND, 1, ASYNC_CMD); 3558 } 3559 } 3560 3561 /* 3562 * eject tape if necessary 3563 */ 3564 if (un->un_eject_tape_on_failure) { 3565 un->un_eject_tape_on_failure = 0; 3566 if (st_cmd(un, SCMD_LOAD, LD_UNLOAD, SYNC_CMD)) { 3567 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3568 "st_close : can't unload tape\n"); 3569 } else { 3570 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 3571 "st_close : tape unloaded \n"); 3572 un->un_pos.eof = ST_NO_EOF; 3573 un->un_mediastate = MTIO_EJECTED; 3574 } 3575 } 3576 /* 3577 * Release the tape unit, if default reserve/release 3578 * behaviour. 3579 */ 3580 if ((un->un_rsvd_status & 3581 (ST_RESERVE | ST_PRESERVE_RESERVE)) == ST_RESERVE) { 3582 (void) st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 3583 } 3584 3585 /* 3586 * clear up state 3587 */ 3588 un->un_laststate = un->un_state; 3589 un->un_state = ST_STATE_CLOSED; 3590 un->un_lastop = ST_OP_NIL; 3591 un->un_throttle = 1; /* assume one request at time, for now */ 3592 un->un_retry_ct = 0; 3593 un->un_tran_retry_ct = 0; 3594 un->un_errno = 0; 3595 un->un_swr_token = (opaque_t)NULL; 3596 un->un_rsvd_status &= ~(ST_INIT_RESERVE); 3597 3598 /* Restore the options to the init time settings */ 3599 if (un->un_init_options & ST_READ_IGNORE_ILI) { 3600 un->un_dp->options |= ST_READ_IGNORE_ILI; 3601 } else { 3602 un->un_dp->options &= ~ST_READ_IGNORE_ILI; 3603 } 3604 3605 if (un->un_init_options & ST_READ_IGNORE_EOFS) { 3606 un->un_dp->options |= ST_READ_IGNORE_EOFS; 3607 } else { 3608 un->un_dp->options &= ~ST_READ_IGNORE_EOFS; 3609 } 3610 3611 if (un->un_init_options & ST_SHORT_FILEMARKS) { 3612 un->un_dp->options |= ST_SHORT_FILEMARKS; 3613 } else { 3614 un->un_dp->options &= ~ST_SHORT_FILEMARKS; 3615 } 3616 3617 ASSERT(mutex_owned(ST_MUTEX)); 3618 3619 /* 3620 * Signal anyone awaiting a close operation to complete. 3621 */ 3622 cv_signal(&un->un_clscv); 3623 3624 /* 3625 * any kind of error on closing causes all state to be tossed 3626 */ 3627 if (err && un->un_status != KEY_ILLEGAL_REQUEST) { 3628 /* 3629 * note that st_intr has already set 3630 * un_pos.pmode to invalid. 3631 */ 3632 un->un_density_known = 0; 3633 } 3634 3635 #ifdef __x86 3636 /* 3637 * free any contiguous mem alloc'ed for big block I/O 3638 */ 3639 cp = un->un_contig_mem; 3640 while (cp) { 3641 if (cp->cm_addr) { 3642 ddi_dma_mem_free(&cp->cm_acc_hdl); 3643 } 3644 cp_temp = cp; 3645 cp = cp->cm_next; 3646 kmem_free(cp_temp, 3647 sizeof (struct contig_mem) + biosize()); 3648 } 3649 un->un_contig_mem_total_num = 0; 3650 un->un_contig_mem_available_num = 0; 3651 un->un_contig_mem = NULL; 3652 un->un_max_contig_mem_len = 0; 3653 #endif 3654 3655 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 3656 "st_close3: return val = %x, fileno=%x, blkno=%x, eof=%x\n", 3657 err, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 3658 3659 mutex_exit(ST_MUTEX); 3660 return (err); 3661 } 3662 3663 /* 3664 * These routines perform raw i/o operations. 3665 */ 3666 3667 /* ARGSUSED2 */ 3668 static int 3669 st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p) 3670 { 3671 #ifdef STDEBUG 3672 GET_SOFT_STATE(dev); 3673 ST_ENTR(ST_DEVINFO, st_aread); 3674 #endif 3675 return (st_arw(dev, aio, B_READ)); 3676 } 3677 3678 3679 /* ARGSUSED2 */ 3680 static int 3681 st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p) 3682 { 3683 #ifdef STDEBUG 3684 GET_SOFT_STATE(dev); 3685 ST_ENTR(ST_DEVINFO, st_awrite); 3686 #endif 3687 return (st_arw(dev, aio, B_WRITE)); 3688 } 3689 3690 3691 3692 /* ARGSUSED */ 3693 static int 3694 st_read(dev_t dev, struct uio *uiop, cred_t *cred_p) 3695 { 3696 #ifdef STDEBUG 3697 GET_SOFT_STATE(dev); 3698 ST_ENTR(ST_DEVINFO, st_read); 3699 #endif 3700 return (st_rw(dev, uiop, B_READ)); 3701 } 3702 3703 /* ARGSUSED */ 3704 static int 3705 st_write(dev_t dev, struct uio *uiop, cred_t *cred_p) 3706 { 3707 #ifdef STDEBUG 3708 GET_SOFT_STATE(dev); 3709 ST_ENTR(ST_DEVINFO, st_write); 3710 #endif 3711 return (st_rw(dev, uiop, B_WRITE)); 3712 } 3713 3714 /* 3715 * Due to historical reasons, old limits are: For variable-length devices: 3716 * if greater than 64KB - 1 (ST_MAXRECSIZE_VARIABLE), block into 64 KB - 2 3717 * ST_MAXRECSIZE_VARIABLE_LIMIT) requests; otherwise, 3718 * (let it through unmodified. For fixed-length record devices: 3719 * 63K (ST_MAXRECSIZE_FIXED) is max (default minphys). 3720 * 3721 * The new limits used are un_maxdma (retrieved using scsi_ifgetcap() 3722 * from the HBA) and un_maxbsize (retrieved by sending SCMD_READ_BLKLIM 3723 * command to the drive). 3724 * 3725 */ 3726 static void 3727 st_minphys(struct buf *bp) 3728 { 3729 struct scsi_tape *un; 3730 3731 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 3732 3733 ST_FUNC(ST_DEVINFO, st_minphys); 3734 3735 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3736 "st_minphys(bp = 0x%p): b_bcount = 0x%lx\n", (void *)bp, 3737 bp->b_bcount); 3738 3739 if (un->un_allow_large_xfer) { 3740 3741 /* 3742 * check un_maxbsize for variable length devices only 3743 */ 3744 if (un->un_bsize == 0 && bp->b_bcount > un->un_maxbsize) { 3745 bp->b_bcount = un->un_maxbsize; 3746 } 3747 /* 3748 * can't go more that HBA maxdma limit in either fixed-length 3749 * or variable-length tape drives. 3750 */ 3751 if (bp->b_bcount > un->un_maxdma) { 3752 bp->b_bcount = un->un_maxdma; 3753 } 3754 } else { 3755 3756 /* 3757 * use old fixed limits 3758 */ 3759 if (un->un_bsize == 0) { 3760 if (bp->b_bcount > ST_MAXRECSIZE_VARIABLE) { 3761 bp->b_bcount = ST_MAXRECSIZE_VARIABLE_LIMIT; 3762 } 3763 } else { 3764 if (bp->b_bcount > ST_MAXRECSIZE_FIXED) { 3765 bp->b_bcount = ST_MAXRECSIZE_FIXED; 3766 } 3767 } 3768 } 3769 3770 /* 3771 * For regular raw I/O and Fixed Block length devices, make sure 3772 * the adjusted block count is a whole multiple of the device 3773 * block size. 3774 */ 3775 if (bp != un->un_sbufp && un->un_bsize) { 3776 bp->b_bcount -= (bp->b_bcount % un->un_bsize); 3777 } 3778 } 3779 3780 static int 3781 st_rw(dev_t dev, struct uio *uio, int flag) 3782 { 3783 int rval = 0; 3784 long len; 3785 3786 GET_SOFT_STATE(dev); 3787 3788 ST_FUNC(ST_DEVINFO, st_rw); 3789 3790 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3791 "st_rw(dev = 0x%lx, flag = %s)\n", dev, 3792 (flag == B_READ ? rd_str: wr_str)); 3793 3794 /* get local copy of transfer length */ 3795 len = uio->uio_iov->iov_len; 3796 3797 mutex_enter(ST_MUTEX); 3798 3799 /* 3800 * Clear error entry stack 3801 */ 3802 st_empty_error_stack(un); 3803 3804 /* 3805 * If in fixed block size mode and requested read or write 3806 * is not an even multiple of that block size. 3807 */ 3808 if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) { 3809 scsi_log(ST_DEVINFO, st_label, CE_WARN, 3810 "%s: not modulo %d block size\n", 3811 (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize); 3812 rval = EINVAL; 3813 } 3814 3815 /* If device has set granularity in the READ_BLKLIM we honor it. */ 3816 if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) { 3817 scsi_log(ST_DEVINFO, st_label, CE_WARN, 3818 "%s: not modulo %d device granularity\n", 3819 (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod); 3820 rval = EINVAL; 3821 } 3822 3823 if (rval != 0) { 3824 un->un_errno = rval; 3825 mutex_exit(ST_MUTEX); 3826 return (rval); 3827 } 3828 3829 /* 3830 * Reset this so it can be set if Berkeley and read over a filemark. 3831 */ 3832 un->un_silent_skip = 0; 3833 mutex_exit(ST_MUTEX); 3834 3835 len = uio->uio_resid; 3836 3837 rval = physio(st_queued_strategy, (struct buf *)NULL, 3838 dev, flag, st_minphys, uio); 3839 /* 3840 * if we have hit logical EOT during this xfer and there is not a 3841 * full residue, then set eof back to ST_EOM to make sure that 3842 * the user will see at least one zero write 3843 * after this short write 3844 */ 3845 mutex_enter(ST_MUTEX); 3846 if (un->un_pos.eof > ST_NO_EOF) { 3847 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3848 "eof=%d resid=%lx\n", un->un_pos.eof, uio->uio_resid); 3849 } 3850 if (un->un_pos.eof >= ST_EOM && (flag == B_WRITE)) { 3851 if ((uio->uio_resid != len) && (uio->uio_resid != 0)) { 3852 un->un_pos.eof = ST_EOM; 3853 } else if (uio->uio_resid == len) { 3854 un->un_pos.eof = ST_NO_EOF; 3855 } 3856 } 3857 3858 if (un->un_silent_skip && uio->uio_resid != len) { 3859 un->un_pos.eof = ST_EOF; 3860 un->un_pos.blkno = un->un_save_blkno; 3861 un->un_pos.fileno--; 3862 } 3863 3864 un->un_errno = rval; 3865 3866 mutex_exit(ST_MUTEX); 3867 3868 return (rval); 3869 } 3870 3871 static int 3872 st_arw(dev_t dev, struct aio_req *aio, int flag) 3873 { 3874 struct uio *uio = aio->aio_uio; 3875 int rval = 0; 3876 long len; 3877 3878 GET_SOFT_STATE(dev); 3879 3880 ST_FUNC(ST_DEVINFO, st_arw); 3881 3882 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3883 "st_arw(dev = 0x%lx, flag = %s)\n", dev, 3884 (flag == B_READ ? rd_str: wr_str)); 3885 3886 /* get local copy of transfer length */ 3887 len = uio->uio_iov->iov_len; 3888 3889 mutex_enter(ST_MUTEX); 3890 3891 /* 3892 * If in fixed block size mode and requested read or write 3893 * is not an even multiple of that block size. 3894 */ 3895 if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) { 3896 scsi_log(ST_DEVINFO, st_label, CE_WARN, 3897 "%s: not modulo %d block size\n", 3898 (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize); 3899 rval = EINVAL; 3900 } 3901 3902 /* If device has set granularity in the READ_BLKLIM we honor it. */ 3903 if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) { 3904 scsi_log(ST_DEVINFO, st_label, CE_WARN, 3905 "%s: not modulo %d device granularity\n", 3906 (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod); 3907 rval = EINVAL; 3908 } 3909 3910 if (rval != 0) { 3911 un->un_errno = rval; 3912 mutex_exit(ST_MUTEX); 3913 return (rval); 3914 } 3915 3916 mutex_exit(ST_MUTEX); 3917 3918 len = uio->uio_resid; 3919 3920 rval = 3921 aphysio(st_queued_strategy, anocancel, dev, flag, st_minphys, aio); 3922 3923 /* 3924 * if we have hit logical EOT during this xfer and there is not a 3925 * full residue, then set eof back to ST_EOM to make sure that 3926 * the user will see at least one zero write 3927 * after this short write 3928 * 3929 * we keep this here just in case the application is not using 3930 * persistent errors 3931 */ 3932 mutex_enter(ST_MUTEX); 3933 if (un->un_pos.eof > ST_NO_EOF) { 3934 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 3935 "eof=%d resid=%lx\n", un->un_pos.eof, uio->uio_resid); 3936 } 3937 if (un->un_pos.eof >= ST_EOM && (flag == B_WRITE)) { 3938 if ((uio->uio_resid != len) && (uio->uio_resid != 0)) { 3939 un->un_pos.eof = ST_EOM; 3940 } else if (uio->uio_resid == len && 3941 !(un->un_persistence && un->un_persist_errors)) { 3942 un->un_pos.eof = ST_NO_EOF; 3943 } 3944 } 3945 un->un_errno = rval; 3946 mutex_exit(ST_MUTEX); 3947 3948 return (rval); 3949 } 3950 3951 3952 3953 static int 3954 st_queued_strategy(buf_t *bp) 3955 { 3956 struct scsi_tape *un; 3957 char reading = bp->b_flags & B_READ; 3958 int wasopening = 0; 3959 3960 /* 3961 * validate arguments 3962 */ 3963 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 3964 if (un == NULL) { 3965 bp->b_resid = bp->b_bcount; 3966 bioerror(bp, ENXIO); 3967 ST_DEBUG6(NULL, st_label, SCSI_DEBUG, 3968 "st_queued_strategy: ENXIO error exit\n"); 3969 biodone(bp); 3970 return (0); 3971 } 3972 3973 ST_ENTR(ST_DEVINFO, st_queued_strategy); 3974 3975 mutex_enter(ST_MUTEX); 3976 3977 while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 3978 cv_wait(&un->un_suspend_cv, ST_MUTEX); 3979 } 3980 3981 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 3982 "st_queued_strategy(): bcount=0x%lx, fileno=%d, blkno=%x, eof=%d\n", 3983 bp->b_bcount, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 3984 3985 /* 3986 * If persistent errors have been flagged, just nix this one. We wait 3987 * for any outstanding I/O's below, so we will be in order. 3988 */ 3989 if (un->un_persistence && un->un_persist_errors) { 3990 goto exit; 3991 } 3992 3993 /* 3994 * If last command was non queued, wait till it finishes. 3995 */ 3996 while (un->un_sbuf_busy) { 3997 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 3998 /* woke up because of an error */ 3999 if (un->un_persistence && un->un_persist_errors) { 4000 goto exit; 4001 } 4002 } 4003 4004 /* 4005 * s_buf and recovery commands shouldn't come here. 4006 */ 4007 ASSERT(bp != un->un_recov_buf); 4008 ASSERT(bp != un->un_sbufp); 4009 4010 /* 4011 * If we haven't done/checked reservation on the tape unit 4012 * do it now. 4013 */ 4014 if ((un->un_rsvd_status & 4015 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 4016 if ((un->un_dp->options & ST_NO_RESERVE_RELEASE) == 0) { 4017 if (st_reserve_release(un, ST_RESERVE, st_uscsi_cmd)) { 4018 st_bioerror(bp, un->un_errno); 4019 goto exit; 4020 } 4021 } else if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4022 /* 4023 * Enter here to restore position for possible 4024 * resets when the device was closed and opened 4025 * in O_NDELAY mode subsequently 4026 */ 4027 un->un_state = ST_STATE_INITIALIZING; 4028 (void) st_cmd(un, SCMD_TEST_UNIT_READY, 4029 0, SYNC_CMD); 4030 un->un_state = ST_STATE_OPEN_PENDING_IO; 4031 } 4032 un->un_rsvd_status |= ST_INIT_RESERVE; 4033 } 4034 4035 /* 4036 * If we are offline, we have to initialize everything first. 4037 * This is to handle either when opened with O_NDELAY, or 4038 * we just got a new tape in the drive, after an offline. 4039 * We don't observe O_NDELAY past the open, 4040 * as it will not make sense for tapes. 4041 */ 4042 if (un->un_state == ST_STATE_OFFLINE && un->un_restore_pos) { 4043 /* 4044 * reset state to avoid recursion 4045 */ 4046 un->un_laststate = un->un_state; 4047 un->un_state = ST_STATE_INITIALIZING; 4048 if (st_tape_init(un)) { 4049 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4050 "stioctl : OFFLINE init failure "); 4051 un->un_state = ST_STATE_OFFLINE; 4052 un->un_pos.pmode = invalid; 4053 goto b_done_err; 4054 } 4055 /* WTF un_restore_pos make invalid */ 4056 un->un_state = ST_STATE_OPEN_PENDING_IO; 4057 un->un_restore_pos = 0; 4058 } 4059 /* 4060 * Check for legal operations 4061 */ 4062 if (un->un_pos.pmode == invalid) { 4063 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4064 "strategy with un->un_pos.pmode invalid\n"); 4065 goto b_done_err; 4066 } 4067 4068 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4069 "st_queued_strategy(): regular io\n"); 4070 4071 /* 4072 * Process this first. If we were reading, and we're pending 4073 * logical eot, that means we've bumped one file mark too far. 4074 */ 4075 4076 /* 4077 * Recursion warning: st_cmd will route back through here. 4078 * Not anymore st_cmd will go through st_strategy()! 4079 */ 4080 if (un->un_pos.eof == ST_EOT_PENDING) { 4081 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 4082 un->un_pos.pmode = invalid; 4083 un->un_density_known = 0; 4084 goto b_done_err; 4085 } 4086 un->un_pos.blkno = 0; /* fix up block number.. */ 4087 un->un_pos.eof = ST_EOT; 4088 } 4089 4090 /* 4091 * If we are in the process of opening, we may have to 4092 * determine/set the correct density. We also may have 4093 * to do a test_append (if QIC) to see whether we are 4094 * in a position to append to the end of the tape. 4095 * 4096 * If we're already at logical eot, we transition 4097 * to ST_NO_EOF. If we're at physical eot, we punt 4098 * to the switch statement below to handle. 4099 */ 4100 if ((un->un_state == ST_STATE_OPEN_PENDING_IO) || 4101 (un->un_test_append && (un->un_dp->options & ST_QIC))) { 4102 4103 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4104 if (st_determine_density(un, (int)reading)) { 4105 goto b_done_err; 4106 } 4107 } 4108 4109 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4110 "pending_io@fileno %d rw %d qic %d eof %d\n", 4111 un->un_pos.fileno, (int)reading, 4112 (un->un_dp->options & ST_QIC) ? 1 : 0, 4113 un->un_pos.eof); 4114 4115 if (!reading && un->un_pos.eof != ST_EOM) { 4116 if (un->un_pos.eof == ST_EOT) { 4117 un->un_pos.eof = ST_NO_EOF; 4118 } else if (un->un_pos.pmode != invalid && 4119 (un->un_dp->options & ST_QIC)) { 4120 /* 4121 * st_test_append() will do it all 4122 */ 4123 st_test_append(bp); 4124 mutex_exit(ST_MUTEX); 4125 return (0); 4126 } 4127 } 4128 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4129 wasopening = 1; 4130 } 4131 un->un_laststate = un->un_state; 4132 un->un_state = ST_STATE_OPEN; 4133 } 4134 4135 4136 /* 4137 * Process rest of END OF FILE and END OF TAPE conditions 4138 */ 4139 4140 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4141 "eof=%x, wasopening=%x\n", 4142 un->un_pos.eof, wasopening); 4143 4144 switch (un->un_pos.eof) { 4145 case ST_EOM: 4146 /* 4147 * This allows writes to proceed past physical 4148 * eot. We'll *really* be in trouble if the 4149 * user continues blindly writing data too 4150 * much past this point (unwind the tape). 4151 * Physical eot really means 'early warning 4152 * eot' in this context. 4153 * 4154 * Every other write from now on will succeed 4155 * (if sufficient tape left). 4156 * This write will return with resid == count 4157 * but the next one should be successful 4158 * 4159 * Note that we only transition to logical EOT 4160 * if the last state wasn't the OPENING state. 4161 * We explicitly prohibit running up to physical 4162 * eot, closing the device, and then re-opening 4163 * to proceed. Trailer records may only be gotten 4164 * at by keeping the tape open after hitting eot. 4165 * 4166 * Also note that ST_EOM cannot be set by reading- 4167 * this can only be set during writing. Reading 4168 * up to the end of the tape gets a blank check 4169 * or a double-filemark indication (ST_EOT_PENDING), 4170 * and we prohibit reading after that point. 4171 * 4172 */ 4173 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOM\n"); 4174 if (wasopening == 0) { 4175 /* 4176 * this allows st_rw() to reset it back to 4177 * will see a zero write 4178 */ 4179 un->un_pos.eof = ST_WRITE_AFTER_EOM; 4180 } 4181 un->un_status = SUN_KEY_EOT; 4182 goto b_done; 4183 4184 case ST_WRITE_AFTER_EOM: 4185 case ST_EOT: 4186 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOT\n"); 4187 un->un_status = SUN_KEY_EOT; 4188 if (SVR4_BEHAVIOR && reading) { 4189 goto b_done_err; 4190 } 4191 4192 if (reading) { 4193 goto b_done; 4194 } 4195 un->un_pos.eof = ST_NO_EOF; 4196 break; 4197 4198 case ST_EOF_PENDING: 4199 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4200 "EOF PENDING\n"); 4201 un->un_status = SUN_KEY_EOF; 4202 if (SVR4_BEHAVIOR) { 4203 un->un_pos.eof = ST_EOF; 4204 goto b_done; 4205 } 4206 /* FALLTHROUGH */ 4207 case ST_EOF: 4208 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOF\n"); 4209 un->un_status = SUN_KEY_EOF; 4210 if (SVR4_BEHAVIOR) { 4211 goto b_done_err; 4212 } 4213 4214 if (BSD_BEHAVIOR) { 4215 un->un_pos.eof = ST_NO_EOF; 4216 un->un_pos.fileno += 1; 4217 un->un_pos.blkno = 0; 4218 } 4219 4220 if (reading) { 4221 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4222 "now file %d (read)\n", 4223 un->un_pos.fileno); 4224 goto b_done; 4225 } 4226 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4227 "now file %d (write)\n", un->un_pos.fileno); 4228 break; 4229 default: 4230 un->un_status = 0; 4231 break; 4232 } 4233 4234 bp->b_flags &= ~(B_DONE); 4235 st_bioerror(bp, 0); 4236 bp->av_forw = NULL; 4237 bp->b_resid = 0; 4238 SET_BP_PKT(bp, 0); 4239 4240 4241 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4242 "st_queued_strategy: cmd=0x%p count=%ld resid=%ld flags=0x%x" 4243 " pkt=0x%p\n", 4244 (void *)bp->b_forw, bp->b_bcount, 4245 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 4246 4247 #ifdef __x86 4248 /* 4249 * We will replace bp with a new bp that can do big blk xfer 4250 * if the requested xfer size is bigger than un->un_maxdma_arch 4251 * 4252 * Also, we need to make sure that we're handling real I/O 4253 * by checking group 0/1 SCSI I/O commands, if needed 4254 */ 4255 if (bp->b_bcount > un->un_maxdma_arch && 4256 ((uchar_t)(uintptr_t)bp->b_forw == SCMD_READ || 4257 (uchar_t)(uintptr_t)bp->b_forw == SCMD_READ_G4 || 4258 (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE || 4259 (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE_G4)) { 4260 mutex_exit(ST_MUTEX); 4261 bp = st_get_bigblk_bp(bp); 4262 mutex_enter(ST_MUTEX); 4263 } 4264 #endif 4265 4266 /* put on wait queue */ 4267 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4268 "st_queued_strategy: un->un_quef = 0x%p, bp = 0x%p\n", 4269 (void *)un->un_quef, (void *)bp); 4270 4271 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quel, bp); 4272 4273 ST_DO_KSTATS(bp, kstat_waitq_enter); 4274 4275 st_start(un); 4276 4277 mutex_exit(ST_MUTEX); 4278 return (0); 4279 4280 b_done_err: 4281 st_bioerror(bp, EIO); 4282 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4283 "st_queued_strategy : EIO b_done_err\n"); 4284 4285 b_done: 4286 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4287 "st_queued_strategy: b_done\n"); 4288 4289 exit: 4290 /* 4291 * make sure no commands are outstanding or waiting before closing, 4292 * so we can guarantee order 4293 */ 4294 st_wait_for_io(un); 4295 un->un_err_resid = bp->b_resid = bp->b_bcount; 4296 4297 /* override errno here, if persistent errors were flagged */ 4298 if (un->un_persistence && un->un_persist_errors) 4299 bioerror(bp, un->un_errno); 4300 4301 mutex_exit(ST_MUTEX); 4302 4303 biodone(bp); 4304 ASSERT(mutex_owned(ST_MUTEX) == 0); 4305 return (0); 4306 } 4307 4308 4309 static int 4310 st_strategy(struct buf *bp) 4311 { 4312 struct scsi_tape *un; 4313 4314 /* 4315 * validate arguments 4316 */ 4317 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 4318 if (un == NULL) { 4319 bp->b_resid = bp->b_bcount; 4320 bioerror(bp, ENXIO); 4321 ST_DEBUG6(NULL, st_label, SCSI_DEBUG, 4322 "st_strategy: ENXIO error exit\n"); 4323 4324 biodone(bp); 4325 return (0); 4326 4327 } 4328 4329 ST_ENTR(ST_DEVINFO, st_strategy); 4330 4331 mutex_enter(ST_MUTEX); 4332 4333 while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 4334 cv_wait(&un->un_suspend_cv, ST_MUTEX); 4335 } 4336 4337 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4338 "st_strategy(): bcount=0x%lx, fileno=%d, blkno=%x, eof=%d\n", 4339 bp->b_bcount, un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 4340 4341 ASSERT((bp == un->un_recov_buf) || (bp == un->un_sbufp)); 4342 4343 bp->b_flags &= ~(B_DONE); 4344 st_bioerror(bp, 0); 4345 bp->av_forw = NULL; 4346 bp->b_resid = 0; 4347 SET_BP_PKT(bp, 0); 4348 4349 4350 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4351 "st_strategy: cmd=0x%x count=%ld resid=%ld flags=0x%x" 4352 " pkt=0x%p\n", 4353 (unsigned char)(uintptr_t)bp->b_forw, bp->b_bcount, 4354 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 4355 ST_DO_KSTATS(bp, kstat_waitq_enter); 4356 4357 st_start(un); 4358 4359 mutex_exit(ST_MUTEX); 4360 return (0); 4361 } 4362 4363 /* 4364 * this routine spaces forward over filemarks 4365 */ 4366 static int 4367 st_space_fmks(struct scsi_tape *un, long count) 4368 { 4369 int rval = 0; 4370 4371 ST_FUNC(ST_DEVINFO, st_space_fmks); 4372 4373 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4374 "st_space_fmks(dev = 0x%lx, count = %ld)\n", un->un_dev, count); 4375 4376 ASSERT(mutex_owned(ST_MUTEX)); 4377 4378 /* 4379 * the risk with doing only one space operation is that we 4380 * may accidentily jump in old data 4381 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD 4382 * because the 8200 does not append a marker; in order not to 4383 * sacrifice the fast file skip, we do a slow skip if the low 4384 * density device has been opened 4385 */ 4386 4387 if ((un->un_dp->options & ST_KNOWS_EOD) && 4388 !((un->un_dp->type == ST_TYPE_EXB8500 && 4389 MT_DENSITY(un->un_dev) == 0))) { 4390 if (st_cmd(un, SCMD_SPACE, Fmk(count), SYNC_CMD)) { 4391 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4392 "space_fmks : EIO can't do space cmd #1\n"); 4393 rval = EIO; 4394 } 4395 } else { 4396 while (count > 0) { 4397 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 4398 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4399 "space_fmks : EIO can't do space cmd #2\n"); 4400 rval = EIO; 4401 break; 4402 } 4403 count -= 1; 4404 /* 4405 * read a block to see if we have reached 4406 * end of medium (double filemark for reel or 4407 * medium error for others) 4408 */ 4409 if (count > 0) { 4410 if (st_cmd(un, SCMD_SPACE, Blk(1), SYNC_CMD)) { 4411 ST_DEBUG2(ST_DEVINFO, st_label, 4412 SCSI_DEBUG, 4413 "space_fmks : EIO can't do " 4414 "space cmd #3\n"); 4415 rval = EIO; 4416 break; 4417 } 4418 if ((un->un_pos.eof >= ST_EOF_PENDING) && 4419 (un->un_dp->options & ST_REEL)) { 4420 un->un_status = SUN_KEY_EOT; 4421 ST_DEBUG2(ST_DEVINFO, st_label, 4422 SCSI_DEBUG, 4423 "space_fmks : EIO ST_REEL\n"); 4424 rval = EIO; 4425 break; 4426 } else if (IN_EOF(un->un_pos)) { 4427 un->un_pos.eof = ST_NO_EOF; 4428 un->un_pos.fileno++; 4429 un->un_pos.blkno = 0; 4430 count--; 4431 } else if (un->un_pos.eof > ST_EOF) { 4432 ST_DEBUG2(ST_DEVINFO, st_label, 4433 SCSI_DEBUG, 4434 "space_fmks, EIO > ST_EOF\n"); 4435 rval = EIO; 4436 break; 4437 } 4438 4439 } 4440 } 4441 un->un_err_resid = count; 4442 COPY_POS(&un->un_pos, &un->un_err_pos); 4443 } 4444 ASSERT(mutex_owned(ST_MUTEX)); 4445 return (rval); 4446 } 4447 4448 /* 4449 * this routine spaces to EOD 4450 * 4451 * it keeps track of the current filenumber and returns the filenumber after 4452 * the last successful space operation, we keep the number high because as 4453 * tapes are getting larger, the possibility of more and more files exist, 4454 * 0x100000 (1 Meg of files) probably will never have to be changed any time 4455 * soon 4456 */ 4457 #define MAX_SKIP 0x100000 /* somewhat arbitrary */ 4458 4459 static int 4460 st_find_eod(struct scsi_tape *un) 4461 { 4462 tapepos_t savepos; 4463 int64_t sp_type; 4464 int result; 4465 4466 if (un == NULL) { 4467 return (-1); 4468 } 4469 4470 ST_FUNC(ST_DEVINFO, st_find_eod); 4471 4472 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4473 "st_find_eod(dev = 0x%lx): fileno = %d\n", un->un_dev, 4474 un->un_pos.fileno); 4475 4476 ASSERT(mutex_owned(ST_MUTEX)); 4477 4478 COPY_POS(&savepos, &un->un_pos); 4479 4480 /* 4481 * see if the drive is smart enough to do the skips in 4482 * one operation; 1/2" use two filemarks 4483 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD 4484 * because the 8200 does not append a marker; in order not to 4485 * sacrifice the fast file skip, we do a slow skip if the low 4486 * density device has been opened 4487 */ 4488 if ((un->un_dp->options & ST_KNOWS_EOD) != 0) { 4489 if ((un->un_dp->type == ST_TYPE_EXB8500) && 4490 (MT_DENSITY(un->un_dev) == 0)) { 4491 sp_type = Fmk(1); 4492 } else if (un->un_pos.pmode == logical) { 4493 sp_type = SPACE(SP_EOD, 0); 4494 } else { 4495 sp_type = Fmk(MAX_SKIP); 4496 } 4497 } else { 4498 sp_type = Fmk(1); 4499 } 4500 4501 for (;;) { 4502 result = st_cmd(un, SCMD_SPACE, sp_type, SYNC_CMD); 4503 4504 if (result == 0) { 4505 COPY_POS(&savepos, &un->un_pos); 4506 } 4507 4508 if (sp_type == SPACE(SP_EOD, 0)) { 4509 if (result != 0) { 4510 sp_type = Fmk(MAX_SKIP); 4511 continue; 4512 } 4513 4514 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4515 "st_find_eod: 0x%"PRIx64"\n", 4516 savepos.lgclblkno); 4517 /* 4518 * What we return will become the current file position. 4519 * After completing the space command with the position 4520 * mode that is not invalid a read position command will 4521 * be automaticly issued. If the drive support the long 4522 * read position format a valid file position can be 4523 * returned. 4524 */ 4525 return (un->un_pos.fileno); 4526 } 4527 4528 if (result != 0) { 4529 break; 4530 } 4531 4532 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4533 "count=%"PRIx64", eof=%x, status=%x\n", 4534 SPACE_CNT(sp_type), un->un_pos.eof, un->un_status); 4535 4536 /* 4537 * If we're not EOM smart, space a record 4538 * to see whether we're now in the slot between 4539 * the two sequential filemarks that logical 4540 * EOM consists of (REEL) or hit nowhere land 4541 * (8mm). 4542 */ 4543 if (sp_type == Fmk(1)) { 4544 /* 4545 * no fast skipping, check a record 4546 */ 4547 if (st_cmd(un, SCMD_SPACE, Blk((1)), SYNC_CMD)) { 4548 break; 4549 } 4550 if ((un->un_pos.eof >= ST_EOF_PENDING) && 4551 (un->un_dp->options & ST_REEL)) { 4552 un->un_status = KEY_BLANK_CHECK; 4553 un->un_pos.fileno++; 4554 un->un_pos.blkno = 0; 4555 break; 4556 } 4557 if (IN_EOF(un->un_pos)) { 4558 un->un_pos.eof = ST_NO_EOF; 4559 un->un_pos.fileno++; 4560 un->un_pos.blkno = 0; 4561 } 4562 if (un->un_pos.eof > ST_EOF) { 4563 break; 4564 } 4565 } else { 4566 if (un->un_pos.eof > ST_EOF) { 4567 break; 4568 } 4569 } 4570 } 4571 4572 if (un->un_dp->options & ST_KNOWS_EOD) { 4573 COPY_POS(&savepos, &un->un_pos); 4574 } 4575 4576 ASSERT(mutex_owned(ST_MUTEX)); 4577 4578 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 4579 "st_find_eod: %x\n", savepos.fileno); 4580 return (savepos.fileno); 4581 } 4582 4583 4584 /* 4585 * this routine is frequently used in ioctls below; 4586 * it determines whether we know the density and if not will 4587 * determine it 4588 * if we have written the tape before, one or more filemarks are written 4589 * 4590 * depending on the stepflag, the head is repositioned to where it was before 4591 * the filemarks were written in order not to confuse step counts 4592 */ 4593 #define STEPBACK 0 4594 #define NO_STEPBACK 1 4595 4596 static int 4597 st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag) 4598 { 4599 4600 GET_SOFT_STATE(dev); 4601 4602 ST_FUNC(ST_DEVINFO, st_check_density_or_wfm); 4603 4604 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4605 "st_check_density_or_wfm(dev= 0x%lx, wfm= %d, mode= %d, stpflg= %d)" 4606 "\n", dev, wfm, mode, stepflag); 4607 4608 ASSERT(mutex_owned(ST_MUTEX)); 4609 4610 /* 4611 * If we don't yet know the density of the tape we have inserted, 4612 * we have to either unconditionally set it (if we're 'writing'), 4613 * or we have to determine it. As side effects, check for any 4614 * write-protect errors, and for the need to put out any file-marks 4615 * before positioning a tape. 4616 * 4617 * If we are going to be spacing forward, and we haven't determined 4618 * the tape density yet, we have to do so now... 4619 */ 4620 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 4621 if (st_determine_density(un, mode)) { 4622 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4623 "check_density_or_wfm : EIO can't determine " 4624 "density\n"); 4625 un->un_errno = EIO; 4626 return (EIO); 4627 } 4628 /* 4629 * Presumably we are at BOT. If we attempt to write, it will 4630 * either work okay, or bomb. We don't do a st_test_append 4631 * unless we're past BOT. 4632 */ 4633 un->un_laststate = un->un_state; 4634 un->un_state = ST_STATE_OPEN; 4635 4636 } else if (un->un_pos.pmode != invalid && un->un_fmneeded > 0 && 4637 ((un->un_lastop == ST_OP_WEOF && wfm) || 4638 (un->un_lastop == ST_OP_WRITE && wfm))) { 4639 4640 tapepos_t spos; 4641 4642 COPY_POS(&spos, &un->un_pos); 4643 4644 /* 4645 * We need to write one or two filemarks. 4646 * In the case of the HP, we need to 4647 * position the head between the two 4648 * marks. 4649 */ 4650 if ((un->un_fmneeded > 0) || (un->un_lastop == ST_OP_WEOF)) { 4651 wfm = un->un_fmneeded; 4652 un->un_fmneeded = 0; 4653 } 4654 4655 if (st_write_fm(dev, wfm)) { 4656 un->un_pos.pmode = invalid; 4657 un->un_density_known = 0; 4658 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4659 "check_density_or_wfm : EIO can't write fm\n"); 4660 un->un_errno = EIO; 4661 return (EIO); 4662 } 4663 4664 if (stepflag == STEPBACK) { 4665 if (st_cmd(un, SCMD_SPACE, Fmk(-wfm), SYNC_CMD)) { 4666 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4667 "check_density_or_wfm : EIO can't space " 4668 "(-wfm)\n"); 4669 un->un_errno = EIO; 4670 return (EIO); 4671 } 4672 COPY_POS(&un->un_pos, &spos); 4673 } 4674 } 4675 4676 /* 4677 * Whatever we do at this point clears the state of the eof flag. 4678 */ 4679 4680 un->un_pos.eof = ST_NO_EOF; 4681 4682 /* 4683 * If writing, let's check that we're positioned correctly 4684 * at the end of tape before issuing the next write. 4685 */ 4686 if (un->un_read_only == RDWR) { 4687 un->un_test_append = 1; 4688 } 4689 4690 ASSERT(mutex_owned(ST_MUTEX)); 4691 return (0); 4692 } 4693 4694 4695 /* 4696 * Wait for all outstaning I/O's to complete 4697 * 4698 * we wait on both ncmds and the wait queue for times when we are flushing 4699 * after persistent errors are flagged, which is when ncmds can be 0, and the 4700 * queue can still have I/O's. This way we preserve order of biodone's. 4701 */ 4702 static void 4703 st_wait_for_io(struct scsi_tape *un) 4704 { 4705 ST_FUNC(ST_DEVINFO, st_wait_for_io); 4706 ASSERT(mutex_owned(ST_MUTEX)); 4707 while ((un->un_ncmds) || (un->un_quef) || (un->un_runqf)) { 4708 cv_wait(&un->un_queue_cv, ST_MUTEX); 4709 } 4710 } 4711 4712 /* 4713 * This routine implements the ioctl calls. It is called 4714 * from the device switch at normal priority. 4715 */ 4716 /*ARGSUSED*/ 4717 static int 4718 st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p, 4719 int *rval_p) 4720 { 4721 int tmp, rval = 0; 4722 4723 GET_SOFT_STATE(dev); 4724 4725 ST_ENTR(ST_DEVINFO, st_ioctl); 4726 4727 mutex_enter(ST_MUTEX); 4728 4729 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 4730 "st_ioctl(): fileno=%x, blkno=%x, eof=%x, state = %d, " 4731 "pe_flag = %d\n", 4732 un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof, un->un_state, 4733 un->un_persistence && un->un_persist_errors); 4734 4735 /* 4736 * We don't want to block on these, so let them through 4737 * and we don't care about setting driver states here. 4738 */ 4739 if ((cmd == MTIOCGETDRIVETYPE) || 4740 (cmd == MTIOCGUARANTEEDORDER) || 4741 (cmd == MTIOCPERSISTENTSTATUS)) { 4742 goto check_commands; 4743 } 4744 4745 /* 4746 * We clear error entry stack except command 4747 * MTIOCGETERROR and MTIOCGET 4748 */ 4749 if ((cmd != MTIOCGETERROR) && 4750 (cmd != MTIOCGET)) { 4751 st_empty_error_stack(un); 4752 } 4753 4754 /* 4755 * wait for all outstanding commands to complete, or be dequeued. 4756 * And because ioctl's are synchronous commands, any return value 4757 * after this, will be in order 4758 */ 4759 st_wait_for_io(un); 4760 4761 /* 4762 * allow only a through clear errors and persistent status, and 4763 * status 4764 */ 4765 if (un->un_persistence && un->un_persist_errors) { 4766 if ((cmd == MTIOCLRERR) || 4767 (cmd == MTIOCPERSISTENT) || 4768 (cmd == MTIOCGET)) { 4769 goto check_commands; 4770 } else { 4771 rval = un->un_errno; 4772 goto exit; 4773 } 4774 } 4775 4776 ASSERT(un->un_throttle != 0); 4777 un->un_throttle = 1; /* > 1 will never happen here */ 4778 un->un_errno = 0; /* start clean from here */ 4779 4780 /* 4781 * first and foremost, handle any ST_EOT_PENDING cases. 4782 * That is, if a logical eot is pending notice, notice it. 4783 */ 4784 if (un->un_pos.eof == ST_EOT_PENDING) { 4785 int resid = un->un_err_resid; 4786 uchar_t status = un->un_status; 4787 uchar_t lastop = un->un_lastop; 4788 4789 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 4790 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 4791 "stioctl : EIO can't space fmk(-1)\n"); 4792 rval = EIO; 4793 goto exit; 4794 } 4795 un->un_lastop = lastop; /* restore last operation */ 4796 if (status == SUN_KEY_EOF) { 4797 un->un_status = SUN_KEY_EOT; 4798 } else { 4799 un->un_status = status; 4800 } 4801 un->un_err_resid = resid; 4802 /* fix up block number */ 4803 un->un_err_pos.blkno = un->un_pos.blkno = 0; 4804 /* now we're at logical eot */ 4805 un->un_pos.eof = ST_EOT; 4806 } 4807 4808 /* 4809 * now, handle the rest of the situations 4810 */ 4811 check_commands: 4812 switch (cmd) { 4813 case MTIOCGET: 4814 { 4815 #ifdef _MULTI_DATAMODEL 4816 /* 4817 * For use when a 32 bit app makes a call into a 4818 * 64 bit ioctl 4819 */ 4820 struct mtget32 mtg_local32; 4821 struct mtget32 *mtget_32 = &mtg_local32; 4822 #endif /* _MULTI_DATAMODEL */ 4823 4824 /* Get tape status */ 4825 struct mtget mtg_local; 4826 struct mtget *mtget = &mtg_local; 4827 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 4828 "st_ioctl: MTIOCGET\n"); 4829 4830 bzero((caddr_t)mtget, sizeof (struct mtget)); 4831 mtget->mt_erreg = un->un_status; 4832 mtget->mt_resid = un->un_err_resid; 4833 mtget->mt_dsreg = un->un_retry_ct; 4834 if (un->un_err_pos.pmode == legacy) { 4835 mtget->mt_fileno = un->un_err_pos.fileno; 4836 } else { 4837 mtget->mt_fileno = -1; 4838 } 4839 mtget->mt_blkno = un->un_err_pos.blkno; 4840 mtget->mt_type = un->un_dp->type; 4841 mtget->mt_flags = MTF_SCSI | MTF_ASF; 4842 if (un->un_read_pos_type != NO_POS) { 4843 mtget->mt_flags |= MTF_LOGICAL_BLOCK; 4844 } 4845 if (un->un_dp->options & ST_REEL) { 4846 mtget->mt_flags |= MTF_REEL; 4847 mtget->mt_bf = 20; 4848 } else { /* 1/4" cartridges */ 4849 switch (mtget->mt_type) { 4850 /* Emulex cartridge tape */ 4851 case MT_ISMT02: 4852 mtget->mt_bf = 40; 4853 break; 4854 default: 4855 mtget->mt_bf = 126; 4856 break; 4857 } 4858 } 4859 4860 /* 4861 * If large transfers are allowed and drive options 4862 * has no record size limit set. Calculate blocking 4863 * factor from the lesser of maxbsize and maxdma. 4864 */ 4865 if ((un->un_allow_large_xfer) && 4866 (un->un_dp->options & ST_NO_RECSIZE_LIMIT)) { 4867 mtget->mt_bf = min(un->un_maxbsize, 4868 un->un_maxdma) / SECSIZE; 4869 } 4870 4871 if (un->un_read_only == WORM || 4872 un->un_read_only == RDWORM) { 4873 mtget->mt_flags |= MTF_WORM_MEDIA; 4874 } 4875 4876 /* 4877 * In persistent error mode sending a non-queued can hang 4878 * because this ioctl gets to be run without turning off 4879 * persistense. Fake the answer based on previous info. 4880 */ 4881 if (un->un_persistence) { 4882 if ((un->un_HeadClean & (TAPE_ALERT_SUPPORTED | 4883 TAPE_SEQUENTIAL_SUPPORTED|TAPE_ALERT_NOT_SUPPORTED)) 4884 != TAPE_ALERT_NOT_SUPPORTED) { 4885 mtget->mt_flags |= MTF_TAPE_CLN_SUPPORTED; 4886 } 4887 if (un->un_HeadClean & (TAPE_PREVIOUSLY_DIRTY | 4888 TAPE_ALERT_STILL_DIRTY)) { 4889 mtget->mt_flags |= MTF_TAPE_HEAD_DIRTY; 4890 } 4891 rval = 0; 4892 } else { 4893 rval = st_check_clean_bit(un); 4894 } 4895 if (rval == -1) { 4896 rval = EIO; 4897 goto exit; 4898 } else { 4899 mtget->mt_flags |= (ushort_t)rval; 4900 rval = 0; 4901 } 4902 4903 un->un_status = 0; /* Reset status */ 4904 un->un_err_resid = 0; 4905 tmp = sizeof (struct mtget); 4906 4907 #ifdef _MULTI_DATAMODEL 4908 4909 switch (ddi_model_convert_from(flag & FMODELS)) { 4910 case DDI_MODEL_ILP32: 4911 /* 4912 * Convert 64 bit back to 32 bit before doing 4913 * copyout. This is what the ILP32 app expects. 4914 */ 4915 mtget_32->mt_erreg = mtget->mt_erreg; 4916 mtget_32->mt_resid = mtget->mt_resid; 4917 mtget_32->mt_dsreg = mtget->mt_dsreg; 4918 mtget_32->mt_fileno = (daddr32_t)mtget->mt_fileno; 4919 mtget_32->mt_blkno = (daddr32_t)mtget->mt_blkno; 4920 mtget_32->mt_type = mtget->mt_type; 4921 mtget_32->mt_flags = mtget->mt_flags; 4922 mtget_32->mt_bf = mtget->mt_bf; 4923 4924 if (ddi_copyout(mtget_32, (void *)arg, 4925 sizeof (struct mtget32), flag)) { 4926 rval = EFAULT; 4927 } 4928 break; 4929 4930 case DDI_MODEL_NONE: 4931 if (ddi_copyout(mtget, (void *)arg, tmp, flag)) { 4932 rval = EFAULT; 4933 } 4934 break; 4935 } 4936 #else /* ! _MULTI_DATAMODE */ 4937 if (ddi_copyout(mtget, (void *)arg, tmp, flag)) { 4938 rval = EFAULT; 4939 } 4940 #endif /* _MULTI_DATAMODE */ 4941 4942 break; 4943 } 4944 case MTIOCGETERROR: 4945 /* 4946 * get error entry from error stack 4947 */ 4948 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 4949 "st_ioctl: MTIOCGETERROR\n"); 4950 4951 rval = st_get_error_entry(un, arg, flag); 4952 4953 break; 4954 4955 case MTIOCSTATE: 4956 { 4957 /* 4958 * return when media presence matches state 4959 */ 4960 enum mtio_state state; 4961 4962 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 4963 "st_ioctl: MTIOCSTATE\n"); 4964 4965 if (ddi_copyin((void *)arg, &state, sizeof (int), flag)) 4966 rval = EFAULT; 4967 4968 mutex_exit(ST_MUTEX); 4969 4970 rval = st_check_media(dev, state); 4971 4972 mutex_enter(ST_MUTEX); 4973 4974 if (rval != 0) { 4975 break; 4976 } 4977 4978 if (ddi_copyout(&un->un_mediastate, (void *)arg, 4979 sizeof (int), flag)) 4980 rval = EFAULT; 4981 break; 4982 4983 } 4984 4985 case MTIOCGETDRIVETYPE: 4986 { 4987 #ifdef _MULTI_DATAMODEL 4988 /* 4989 * For use when a 32 bit app makes a call into a 4990 * 64 bit ioctl 4991 */ 4992 struct mtdrivetype_request32 mtdtrq32; 4993 #endif /* _MULTI_DATAMODEL */ 4994 4995 /* 4996 * return mtdrivetype 4997 */ 4998 struct mtdrivetype_request mtdtrq; 4999 struct mtdrivetype mtdrtyp; 5000 struct mtdrivetype *mtdt = &mtdrtyp; 5001 struct st_drivetype *stdt = un->un_dp; 5002 5003 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5004 "st_ioctl: MTIOCGETDRIVETYPE\n"); 5005 5006 #ifdef _MULTI_DATAMODEL 5007 switch (ddi_model_convert_from(flag & FMODELS)) { 5008 case DDI_MODEL_ILP32: 5009 { 5010 if (ddi_copyin((void *)arg, &mtdtrq32, 5011 sizeof (struct mtdrivetype_request32), flag)) { 5012 rval = EFAULT; 5013 break; 5014 } 5015 mtdtrq.size = mtdtrq32.size; 5016 mtdtrq.mtdtp = 5017 (struct mtdrivetype *)(uintptr_t)mtdtrq32.mtdtp; 5018 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5019 "st_ioctl: size 0x%x\n", mtdtrq.size); 5020 break; 5021 } 5022 case DDI_MODEL_NONE: 5023 if (ddi_copyin((void *)arg, &mtdtrq, 5024 sizeof (struct mtdrivetype_request), flag)) { 5025 rval = EFAULT; 5026 break; 5027 } 5028 break; 5029 } 5030 5031 #else /* ! _MULTI_DATAMODEL */ 5032 if (ddi_copyin((void *)arg, &mtdtrq, 5033 sizeof (struct mtdrivetype_request), flag)) { 5034 rval = EFAULT; 5035 break; 5036 } 5037 #endif /* _MULTI_DATAMODEL */ 5038 5039 /* 5040 * if requested size is < 0 then return 5041 * error. 5042 */ 5043 if (mtdtrq.size < 0) { 5044 rval = EINVAL; 5045 break; 5046 } 5047 bzero(mtdt, sizeof (struct mtdrivetype)); 5048 (void) strncpy(mtdt->name, stdt->name, ST_NAMESIZE); 5049 (void) strncpy(mtdt->vid, stdt->vid, VIDPIDLEN - 1); 5050 mtdt->type = stdt->type; 5051 mtdt->bsize = stdt->bsize; 5052 mtdt->options = stdt->options; 5053 mtdt->max_rretries = stdt->max_rretries; 5054 mtdt->max_wretries = stdt->max_wretries; 5055 for (tmp = 0; tmp < NDENSITIES; tmp++) { 5056 mtdt->densities[tmp] = stdt->densities[tmp]; 5057 } 5058 mtdt->default_density = stdt->default_density; 5059 /* 5060 * Speed hasn't been used since the hayday of reel tape. 5061 * For all drives not setting the option ST_KNOWS_MEDIA 5062 * the speed member renamed to mediatype are zeros. 5063 * Those drives that have ST_KNOWS_MEDIA set use the 5064 * new mediatype member which is used to figure the 5065 * type of media loaded. 5066 * 5067 * So as to not break applications speed in the 5068 * mtdrivetype structure is not renamed. 5069 */ 5070 for (tmp = 0; tmp < NDENSITIES; tmp++) { 5071 mtdt->speeds[tmp] = stdt->mediatype[tmp]; 5072 } 5073 mtdt->non_motion_timeout = stdt->non_motion_timeout; 5074 mtdt->io_timeout = stdt->io_timeout; 5075 mtdt->rewind_timeout = stdt->rewind_timeout; 5076 mtdt->space_timeout = stdt->space_timeout; 5077 mtdt->load_timeout = stdt->load_timeout; 5078 mtdt->unload_timeout = stdt->unload_timeout; 5079 mtdt->erase_timeout = stdt->erase_timeout; 5080 5081 /* 5082 * Limit the maximum length of the result to 5083 * sizeof (struct mtdrivetype). 5084 */ 5085 tmp = sizeof (struct mtdrivetype); 5086 if (mtdtrq.size < tmp) 5087 tmp = mtdtrq.size; 5088 if (ddi_copyout(mtdt, mtdtrq.mtdtp, tmp, flag)) { 5089 rval = EFAULT; 5090 } 5091 break; 5092 } 5093 case MTIOCPERSISTENT: 5094 5095 if (ddi_copyin((void *)arg, &tmp, sizeof (tmp), flag)) { 5096 rval = EFAULT; 5097 break; 5098 } 5099 5100 if (tmp) { 5101 st_turn_pe_on(un); 5102 } else { 5103 st_turn_pe_off(un); 5104 } 5105 5106 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5107 "st_ioctl: MTIOCPERSISTENT : persistence = %d\n", 5108 un->un_persistence); 5109 5110 break; 5111 5112 case MTIOCPERSISTENTSTATUS: 5113 tmp = (int)un->un_persistence; 5114 5115 if (ddi_copyout(&tmp, (void *)arg, sizeof (tmp), flag)) { 5116 rval = EFAULT; 5117 } 5118 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5119 "st_ioctl: MTIOCPERSISTENTSTATUS:persistence = %d\n", 5120 un->un_persistence); 5121 5122 break; 5123 5124 case MTIOCLRERR: 5125 { 5126 /* clear persistent errors */ 5127 5128 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5129 "st_ioctl: MTIOCLRERR\n"); 5130 5131 st_clear_pe(un); 5132 5133 break; 5134 } 5135 5136 case MTIOCGUARANTEEDORDER: 5137 { 5138 /* 5139 * this is just a holder to make a valid ioctl and 5140 * it won't be in any earlier release 5141 */ 5142 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5143 "st_ioctl: MTIOCGUARANTEEDORDER\n"); 5144 5145 break; 5146 } 5147 5148 case MTIOCRESERVE: 5149 { 5150 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5151 "st_ioctl: MTIOCRESERVE\n"); 5152 5153 /* 5154 * Check if Reserve/Release is supported. 5155 */ 5156 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5157 rval = ENOTTY; 5158 break; 5159 } 5160 5161 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 5162 5163 if (rval == 0) { 5164 un->un_rsvd_status |= ST_PRESERVE_RESERVE; 5165 } 5166 break; 5167 } 5168 5169 case MTIOCRELEASE: 5170 { 5171 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5172 "st_ioctl: MTIOCRELEASE\n"); 5173 5174 /* 5175 * Check if Reserve/Release is supported. 5176 */ 5177 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5178 rval = ENOTTY; 5179 break; 5180 } 5181 5182 /* 5183 * Used to just clear ST_PRESERVE_RESERVE which 5184 * made the reservation release at next close. 5185 * As the user may have opened and then done a 5186 * persistant reservation we now need to drop 5187 * the reservation without closing if the user 5188 * attempts to do this. 5189 */ 5190 rval = st_reserve_release(un, ST_RELEASE, st_uscsi_cmd); 5191 5192 un->un_rsvd_status &= ~ST_PRESERVE_RESERVE; 5193 5194 break; 5195 } 5196 5197 case MTIOCFORCERESERVE: 5198 { 5199 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5200 "st_ioctl: MTIOCFORCERESERVE\n"); 5201 5202 /* 5203 * Check if Reserve/Release is supported. 5204 */ 5205 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 5206 rval = ENOTTY; 5207 break; 5208 } 5209 /* 5210 * allow only super user to run this. 5211 */ 5212 if (drv_priv(cred_p) != 0) { 5213 rval = EPERM; 5214 break; 5215 } 5216 /* 5217 * Throw away reserve, 5218 * not using test-unit-ready 5219 * since reserve can succeed without tape being 5220 * present in the drive. 5221 */ 5222 (void) st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 5223 5224 rval = st_take_ownership(un); 5225 5226 break; 5227 } 5228 5229 case USCSICMD: 5230 { 5231 cred_t *cr; 5232 5233 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5234 "st_ioctl: USCSICMD\n"); 5235 5236 cr = ddi_get_cred(); 5237 if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) { 5238 rval = EPERM; 5239 } else { 5240 rval = st_uscsi_cmd(un, (struct uscsi_cmd *)arg, flag); 5241 } 5242 break; 5243 } 5244 case MTIOCTOP: 5245 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5246 "st_ioctl: MTIOCTOP\n"); 5247 rval = st_mtioctop(un, arg, flag); 5248 break; 5249 5250 case MTIOCLTOP: 5251 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5252 "st_ioctl: MTIOLCTOP\n"); 5253 rval = st_mtiocltop(un, arg, flag); 5254 break; 5255 5256 case MTIOCREADIGNOREILI: 5257 { 5258 int set_ili; 5259 5260 if (ddi_copyin((void *)arg, &set_ili, 5261 sizeof (set_ili), flag)) { 5262 rval = EFAULT; 5263 break; 5264 } 5265 5266 if (un->un_bsize) { 5267 rval = ENOTTY; 5268 break; 5269 } 5270 5271 switch (set_ili) { 5272 case 0: 5273 un->un_dp->options &= ~ST_READ_IGNORE_ILI; 5274 break; 5275 5276 case 1: 5277 un->un_dp->options |= ST_READ_IGNORE_ILI; 5278 break; 5279 5280 default: 5281 rval = EINVAL; 5282 break; 5283 } 5284 break; 5285 } 5286 5287 case MTIOCREADIGNOREEOFS: 5288 { 5289 int ignore_eof; 5290 5291 if (ddi_copyin((void *)arg, &ignore_eof, 5292 sizeof (ignore_eof), flag)) { 5293 rval = EFAULT; 5294 break; 5295 } 5296 5297 if (!(un->un_dp->options & ST_REEL)) { 5298 rval = ENOTTY; 5299 break; 5300 } 5301 5302 switch (ignore_eof) { 5303 case 0: 5304 un->un_dp->options &= ~ST_READ_IGNORE_EOFS; 5305 break; 5306 5307 case 1: 5308 un->un_dp->options |= ST_READ_IGNORE_EOFS; 5309 break; 5310 5311 default: 5312 rval = EINVAL; 5313 break; 5314 } 5315 break; 5316 } 5317 5318 case MTIOCSHORTFMK: 5319 { 5320 int short_fmk; 5321 5322 if (ddi_copyin((void *)arg, &short_fmk, 5323 sizeof (short_fmk), flag)) { 5324 rval = EFAULT; 5325 break; 5326 } 5327 5328 switch (un->un_dp->type) { 5329 case ST_TYPE_EXB8500: 5330 case ST_TYPE_EXABYTE: 5331 if (!short_fmk) { 5332 un->un_dp->options &= ~ST_SHORT_FILEMARKS; 5333 } else if (short_fmk == 1) { 5334 un->un_dp->options |= ST_SHORT_FILEMARKS; 5335 } else { 5336 rval = EINVAL; 5337 } 5338 break; 5339 5340 default: 5341 rval = ENOTTY; 5342 break; 5343 } 5344 break; 5345 } 5346 5347 case MTIOCGETPOS: 5348 rval = st_update_block_pos(un, st_cmd, 0); 5349 if (rval == 0) { 5350 if (ddi_copyout((void *)&un->un_pos, (void *)arg, 5351 sizeof (tapepos_t), flag)) { 5352 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 5353 "MTIOCGETPOS copy out failed\n"); 5354 rval = EFAULT; 5355 } 5356 } 5357 break; 5358 5359 case MTIOCRESTPOS: 5360 { 5361 tapepos_t dest; 5362 5363 if (ddi_copyin((void *)arg, &dest, sizeof (tapepos_t), 5364 flag) != 0) { 5365 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 5366 "MTIOCRESTPOS copy in failed\n"); 5367 rval = EFAULT; 5368 break; 5369 } 5370 rval = st_validate_tapemarks(un, st_uscsi_cmd, &dest); 5371 if (rval != 0) { 5372 rval = EIO; 5373 } 5374 break; 5375 } 5376 default: 5377 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 5378 "st_ioctl: unknown ioctl\n"); 5379 rval = ENOTTY; 5380 } 5381 5382 exit: 5383 if (!(un->un_persistence && un->un_persist_errors)) { 5384 un->un_errno = rval; 5385 } 5386 5387 mutex_exit(ST_MUTEX); 5388 5389 return (rval); 5390 } 5391 5392 5393 /* 5394 * do some MTIOCTOP tape operations 5395 */ 5396 static int 5397 st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag) 5398 { 5399 #ifdef _MULTI_DATAMODEL 5400 /* 5401 * For use when a 32 bit app makes a call into a 5402 * 64 bit ioctl 5403 */ 5404 struct mtop32 mtop_32_for_64; 5405 #endif /* _MULTI_DATAMODEL */ 5406 struct mtop passed; 5407 struct mtlop local; 5408 int rval = 0; 5409 5410 ST_FUNC(ST_DEVINFO, st_mtioctop); 5411 5412 ASSERT(mutex_owned(ST_MUTEX)); 5413 5414 #ifdef _MULTI_DATAMODEL 5415 switch (ddi_model_convert_from(flag & FMODELS)) { 5416 case DDI_MODEL_ILP32: 5417 if (ddi_copyin((void *)arg, &mtop_32_for_64, 5418 sizeof (struct mtop32), flag)) { 5419 return (EFAULT); 5420 } 5421 local.mt_op = mtop_32_for_64.mt_op; 5422 local.mt_count = (int64_t)mtop_32_for_64.mt_count; 5423 break; 5424 5425 case DDI_MODEL_NONE: 5426 if (ddi_copyin((void *)arg, &passed, sizeof (passed), flag)) { 5427 return (EFAULT); 5428 } 5429 local.mt_op = passed.mt_op; 5430 /* prevent sign extention */ 5431 local.mt_count = (UINT32_MAX & passed.mt_count); 5432 break; 5433 } 5434 5435 #else /* ! _MULTI_DATAMODEL */ 5436 if (ddi_copyin((void *)arg, &passed, sizeof (passed), flag)) { 5437 return (EFAULT); 5438 } 5439 local.mt_op = passed.mt_op; 5440 /* prevent sign extention */ 5441 local.mt_count = (UINT32_MAX & passed.mt_count); 5442 #endif /* _MULTI_DATAMODEL */ 5443 5444 rval = st_do_mtioctop(un, &local); 5445 5446 #ifdef _MULTI_DATAMODEL 5447 switch (ddi_model_convert_from(flag & FMODELS)) { 5448 case DDI_MODEL_ILP32: 5449 if (((uint64_t)local.mt_count) > UINT32_MAX) { 5450 rval = ERANGE; 5451 break; 5452 } 5453 /* 5454 * Convert 64 bit back to 32 bit before doing 5455 * copyout. This is what the ILP32 app expects. 5456 */ 5457 mtop_32_for_64.mt_op = local.mt_op; 5458 mtop_32_for_64.mt_count = local.mt_count; 5459 5460 if (ddi_copyout(&mtop_32_for_64, (void *)arg, 5461 sizeof (struct mtop32), flag)) { 5462 rval = EFAULT; 5463 } 5464 break; 5465 5466 case DDI_MODEL_NONE: 5467 passed.mt_count = local.mt_count; 5468 passed.mt_op = local.mt_op; 5469 if (ddi_copyout(&passed, (void *)arg, sizeof (passed), flag)) { 5470 rval = EFAULT; 5471 } 5472 break; 5473 } 5474 #else /* ! _MULTI_DATAMODE */ 5475 if (((uint64_t)local.mt_count) > UINT32_MAX) { 5476 rval = ERANGE; 5477 } else { 5478 passed.mt_op = local.mt_op; 5479 passed.mt_count = local.mt_count; 5480 if (ddi_copyout(&passed, (void *)arg, sizeof (passed), flag)) { 5481 rval = EFAULT; 5482 } 5483 } 5484 #endif /* _MULTI_DATAMODE */ 5485 5486 5487 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 5488 "st_ioctl: fileno=%x, blkno=%x, eof=%x\n", un->un_pos.fileno, 5489 un->un_pos.blkno, un->un_pos.eof); 5490 5491 if (un->un_pos.pmode == invalid) { 5492 un->un_density_known = 0; 5493 } 5494 5495 ASSERT(mutex_owned(ST_MUTEX)); 5496 return (rval); 5497 } 5498 5499 static int 5500 st_mtiocltop(struct scsi_tape *un, intptr_t arg, int flag) 5501 { 5502 struct mtlop local; 5503 int rval; 5504 5505 ST_FUNC(ST_DEVINFO, st_mtiocltop); 5506 if (ddi_copyin((void *)arg, &local, sizeof (local), flag)) { 5507 return (EFAULT); 5508 } 5509 5510 rval = st_do_mtioctop(un, &local); 5511 5512 if (ddi_copyout(&local, (void *)arg, sizeof (local), flag)) { 5513 rval = EFAULT; 5514 } 5515 return (rval); 5516 } 5517 5518 5519 static int 5520 st_do_mtioctop(struct scsi_tape *un, struct mtlop *mtop) 5521 { 5522 dev_t dev = un->un_dev; 5523 int savefile; 5524 int rval = 0; 5525 5526 ST_FUNC(ST_DEVINFO, st_do_mtioctop); 5527 5528 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5529 "st_do_mtioctop(): mt_op=%x\n", mtop->mt_op); 5530 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 5531 "fileno=%x, blkno=%x, eof=%x\n", 5532 un->un_pos.fileno, un->un_pos.blkno, un->un_pos.eof); 5533 5534 un->un_status = 0; 5535 5536 /* 5537 * if we are going to mess with a tape, we have to make sure we have 5538 * one and are not offline (i.e. no tape is initialized). We let 5539 * commands pass here that don't actually touch the tape, except for 5540 * loading and initialization (rewinding). 5541 */ 5542 if (un->un_state == ST_STATE_OFFLINE) { 5543 switch (mtop->mt_op) { 5544 case MTLOAD: 5545 case MTNOP: 5546 /* 5547 * We don't want strategy calling st_tape_init here, 5548 * so, change state 5549 */ 5550 un->un_state = ST_STATE_INITIALIZING; 5551 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5552 "st_do_mtioctop : OFFLINE state = %d\n", 5553 un->un_state); 5554 break; 5555 default: 5556 /* 5557 * reinitialize by normal means 5558 */ 5559 rval = st_tape_init(un); 5560 if (rval) { 5561 un->un_state = ST_STATE_INITIALIZING; 5562 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5563 "st_do_mtioctop : OFFLINE init failure "); 5564 un->un_state = ST_STATE_OFFLINE; 5565 un->un_pos.pmode = invalid; 5566 if (rval != EACCES) { 5567 rval = EIO; 5568 } 5569 return (rval); 5570 } 5571 un->un_state = ST_STATE_OPEN_PENDING_IO; 5572 break; 5573 } 5574 } 5575 5576 /* 5577 * If the file position is invalid, allow only those 5578 * commands that properly position the tape and fail 5579 * the rest with EIO 5580 */ 5581 if (un->un_pos.pmode == invalid) { 5582 switch (mtop->mt_op) { 5583 case MTWEOF: 5584 case MTRETEN: 5585 case MTERASE: 5586 case MTEOM: 5587 case MTFSF: 5588 case MTFSR: 5589 case MTBSF: 5590 case MTNBSF: 5591 case MTBSR: 5592 case MTSRSZ: 5593 case MTGRSZ: 5594 case MTSEEK: 5595 case MTBSSF: 5596 case MTFSSF: 5597 return (EIO); 5598 /* NOTREACHED */ 5599 case MTREW: 5600 case MTLOAD: 5601 case MTOFFL: 5602 case MTNOP: 5603 case MTTELL: 5604 case MTLOCK: 5605 case MTUNLOCK: 5606 break; 5607 5608 default: 5609 return (ENOTTY); 5610 /* NOTREACHED */ 5611 } 5612 } 5613 5614 switch (mtop->mt_op) { 5615 case MTERASE: 5616 /* 5617 * MTERASE rewinds the tape, erase it completely, and returns 5618 * to the beginning of the tape 5619 */ 5620 if (un->un_mspl->wp || un->un_read_only & WORM) { 5621 un->un_status = KEY_WRITE_PROTECT; 5622 un->un_err_resid = mtop->mt_count; 5623 COPY_POS(&un->un_err_pos, &un->un_pos); 5624 return (EACCES); 5625 } 5626 if (un->un_dp->options & ST_REEL) { 5627 un->un_fmneeded = 2; 5628 } else { 5629 un->un_fmneeded = 1; 5630 } 5631 mtop->mt_count = mtop->mt_count ? 1 : 0; 5632 if (st_check_density_or_wfm(dev, 1, B_WRITE, NO_STEPBACK) || 5633 st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 5634 st_cmd(un, SCMD_ERASE, mtop->mt_count, SYNC_CMD)) { 5635 un->un_pos.pmode = invalid; 5636 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5637 "st_do_mtioctop : EIO space or erase or " 5638 "check den)\n"); 5639 rval = EIO; 5640 } else { 5641 /* QIC and helical scan rewind after erase */ 5642 if (un->un_dp->options & ST_REEL) { 5643 (void) st_cmd(un, SCMD_REWIND, 0, ASYNC_CMD); 5644 } 5645 } 5646 break; 5647 5648 case MTWEOF: 5649 /* 5650 * write an end-of-file record 5651 */ 5652 if (un->un_mspl->wp || un->un_read_only & RDONLY) { 5653 un->un_status = KEY_WRITE_PROTECT; 5654 un->un_err_resid = mtop->mt_count; 5655 COPY_POS(&un->un_err_pos, &un->un_pos); 5656 return (EACCES); 5657 } 5658 5659 /* 5660 * zero count means just flush buffers 5661 * negative count is not permitted 5662 */ 5663 if (mtop->mt_count < 0) { 5664 return (EINVAL); 5665 } 5666 5667 /* Not on worm */ 5668 if (un->un_read_only == RDWR) { 5669 un->un_test_append = 1; 5670 } 5671 5672 if (un->un_state == ST_STATE_OPEN_PENDING_IO) { 5673 if (st_determine_density(un, B_WRITE)) { 5674 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5675 "st_do_mtioctop : EIO : MTWEOF can't " 5676 "determine density"); 5677 return (EIO); 5678 } 5679 } 5680 5681 rval = st_write_fm(dev, (int)mtop->mt_count); 5682 if ((rval != 0) && (rval != EACCES)) { 5683 /* 5684 * Failure due to something other than illegal 5685 * request results in loss of state (st_intr). 5686 */ 5687 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5688 "st_do_mtioctop : EIO : MTWEOF can't write " 5689 "file mark"); 5690 rval = EIO; 5691 } 5692 break; 5693 5694 case MTRETEN: 5695 /* 5696 * retension the tape 5697 */ 5698 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK) || 5699 st_cmd(un, SCMD_LOAD, LD_LOAD | LD_RETEN, SYNC_CMD)) { 5700 un->un_pos.pmode = invalid; 5701 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5702 "st_do_mtioctop : EIO : MTRETEN "); 5703 rval = EIO; 5704 } 5705 break; 5706 5707 case MTREW: 5708 /* 5709 * rewind the tape 5710 */ 5711 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) { 5712 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5713 "st_do_mtioctop : EIO:MTREW check " 5714 "density/wfm failed"); 5715 return (EIO); 5716 } 5717 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 5718 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5719 "st_do_mtioctop : EIO : MTREW "); 5720 rval = EIO; 5721 } 5722 break; 5723 5724 case MTOFFL: 5725 /* 5726 * rewinds, and, if appropriate, takes the device offline by 5727 * unloading the tape 5728 */ 5729 if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) { 5730 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5731 "st_do_mtioctop :EIO:MTOFFL check " 5732 "density/wfm failed"); 5733 return (EIO); 5734 } 5735 (void) st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 5736 if (st_cmd(un, SCMD_LOAD, LD_UNLOAD, SYNC_CMD)) { 5737 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5738 "st_do_mtioctop : EIO : MTOFFL"); 5739 return (EIO); 5740 } 5741 un->un_pos.eof = ST_NO_EOF; 5742 un->un_laststate = un->un_state; 5743 un->un_state = ST_STATE_OFFLINE; 5744 un->un_mediastate = MTIO_EJECTED; 5745 break; 5746 5747 case MTLOAD: 5748 /* 5749 * This is to load a tape into the drive 5750 * Note that if the tape is not loaded, the device will have 5751 * to be opened via O_NDELAY or O_NONBLOCK. 5752 */ 5753 /* 5754 * Let's try and clean things up, if we are not 5755 * initializing, and then send in the load command, no 5756 * matter what. 5757 * 5758 * load after a media change by the user. 5759 */ 5760 5761 if (un->un_state > ST_STATE_INITIALIZING) { 5762 (void) st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK); 5763 } 5764 rval = st_cmd(un, SCMD_LOAD, LD_LOAD, SYNC_CMD); 5765 /* Load command to a drive that doesn't support load */ 5766 if ((rval == EIO) && 5767 ((un->un_status == KEY_NOT_READY) && 5768 /* Medium not present */ 5769 (un->un_uscsi_rqs_buf->es_add_code == 0x3a) || 5770 ((un->un_status == KEY_ILLEGAL_REQUEST) && 5771 (un->un_dp->type == MT_ISSTK9840) && 5772 /* CSL not present */ 5773 (un->un_uscsi_rqs_buf->es_add_code == 0x80)))) { 5774 rval = ENOTTY; 5775 break; 5776 } else if (rval != EACCES && rval != 0) { 5777 rval = EIO; 5778 } 5779 if (rval) { 5780 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5781 "st_do_mtioctop : %s : MTLOAD\n", 5782 rval == EACCES ? "EACCES" : "EIO"); 5783 /* 5784 * If load tape fails, who knows what happened... 5785 */ 5786 un->un_pos.pmode = invalid; 5787 break; 5788 } 5789 5790 /* 5791 * reset all counters appropriately using rewind, as if LOAD 5792 * succeeds, we are at BOT 5793 */ 5794 un->un_state = ST_STATE_INITIALIZING; 5795 5796 rval = st_tape_init(un); 5797 if ((rval == EACCES) && (un->un_read_only & WORM)) { 5798 rval = 0; 5799 break; 5800 } 5801 5802 if (rval != 0) { 5803 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5804 "st_do_mtioctop : EIO : MTLOAD calls " 5805 "st_tape_init\n"); 5806 rval = EIO; 5807 un->un_state = ST_STATE_OFFLINE; 5808 } 5809 5810 break; 5811 5812 case MTNOP: 5813 un->un_status = 0; /* Reset status */ 5814 un->un_err_resid = 0; 5815 mtop->mt_count = MTUNIT(dev); 5816 break; 5817 5818 case MTEOM: 5819 /* 5820 * positions the tape at a location just after the last file 5821 * written on the tape. For cartridge and 8 mm, this after 5822 * the last file mark; for reel, this is inbetween the two 5823 * last 2 file marks 5824 */ 5825 if ((un->un_pos.pmode == legacy && un->un_pos.eof >= ST_EOT) || 5826 (un->un_lastop == ST_OP_WRITE) || 5827 (un->un_lastop == ST_OP_WEOF)) { 5828 /* 5829 * If the command wants to move to logical end 5830 * of media, and we're already there, we're done. 5831 * If we were at logical eot, we reset the state 5832 * to be *not* at logical eot. 5833 * 5834 * If we're at physical or logical eot, we prohibit 5835 * forward space operations (unconditionally). 5836 * 5837 * Also if the last operation was a write of any 5838 * kind the tape is at EOD. 5839 */ 5840 return (0); 5841 } 5842 /* 5843 * physical tape position may not be what we've been 5844 * telling the user; adjust the request accordingly 5845 */ 5846 if (IN_EOF(un->un_pos)) { 5847 un->un_pos.fileno++; 5848 un->un_pos.blkno = 0; 5849 } 5850 5851 if (st_check_density_or_wfm(dev, 1, B_READ, NO_STEPBACK)) { 5852 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5853 "st_do_mtioctop : EIO:MTEOM check density/wfm " 5854 " failed"); 5855 return (EIO); 5856 } 5857 5858 /* 5859 * st_find_eod() returns the last fileno we knew about; 5860 */ 5861 savefile = st_find_eod(un); 5862 5863 if ((un->un_status != KEY_BLANK_CHECK) && 5864 (un->un_status != SUN_KEY_EOT)) { 5865 un->un_pos.pmode = invalid; 5866 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5867 "st_do_mtioctop : EIO : MTEOM status check failed"); 5868 rval = EIO; 5869 } else { 5870 /* 5871 * For 1/2" reel tapes assume logical EOT marked 5872 * by two file marks or we don't care that we may 5873 * be extending the last file on the tape. 5874 */ 5875 if (un->un_dp->options & ST_REEL) { 5876 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD)) { 5877 un->un_pos.pmode = invalid; 5878 ST_DEBUG2(ST_DEVINFO, st_label, 5879 SCSI_DEBUG, 5880 "st_do_mtioctop : EIO : MTEOM space" 5881 " cmd failed"); 5882 rval = EIO; 5883 break; 5884 } 5885 /* 5886 * Fix up the block number. 5887 */ 5888 un->un_pos.blkno = 0; 5889 un->un_err_pos.blkno = 0; 5890 } 5891 un->un_err_resid = 0; 5892 un->un_pos.fileno = savefile; 5893 un->un_pos.eof = ST_EOT; 5894 } 5895 un->un_status = 0; 5896 break; 5897 5898 case MTFSF: 5899 rval = st_mtfsf_ioctl(un, mtop->mt_count); 5900 break; 5901 5902 case MTFSR: 5903 rval = st_mtfsr_ioctl(un, mtop->mt_count); 5904 break; 5905 5906 case MTBSF: 5907 rval = st_mtbsf_ioctl(un, mtop->mt_count); 5908 break; 5909 5910 case MTNBSF: 5911 rval = st_mtnbsf_ioctl(un, mtop->mt_count); 5912 break; 5913 5914 case MTBSR: 5915 rval = st_mtbsr_ioctl(un, mtop->mt_count); 5916 break; 5917 5918 case MTBSSF: 5919 rval = st_mtbsfm_ioctl(un, mtop->mt_count); 5920 break; 5921 5922 case MTFSSF: 5923 rval = st_mtfsfm_ioctl(un, mtop->mt_count); 5924 break; 5925 5926 case MTSRSZ: 5927 5928 /* 5929 * Set record-size to that sent by user 5930 * Check to see if there is reason that the requested 5931 * block size should not be set. 5932 */ 5933 5934 /* If requesting variable block size is it ok? */ 5935 if ((mtop->mt_count == 0) && 5936 ((un->un_dp->options & ST_VARIABLE) == 0)) { 5937 return (ENOTTY); 5938 } 5939 5940 /* 5941 * If requested block size is not variable "0", 5942 * is it less then minimum. 5943 */ 5944 if ((mtop->mt_count != 0) && 5945 (mtop->mt_count < un->un_minbsize)) { 5946 return (EINVAL); 5947 } 5948 5949 /* Is the requested block size more then maximum */ 5950 if ((mtop->mt_count > min(un->un_maxbsize, un->un_maxdma)) && 5951 (un->un_maxbsize != 0)) { 5952 return (EINVAL); 5953 } 5954 5955 /* Is requested block size a modulus the device likes */ 5956 if ((mtop->mt_count % un->un_data_mod) != 0) { 5957 return (EINVAL); 5958 } 5959 5960 if (st_change_block_size(un, (uint32_t)mtop->mt_count) != 0) { 5961 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 5962 "st_ioctl : MTSRSZ : EIO : cant set block size"); 5963 return (EIO); 5964 } 5965 5966 return (0); 5967 5968 case MTGRSZ: 5969 /* 5970 * Get record-size to the user 5971 */ 5972 mtop->mt_count = un->un_bsize; 5973 rval = 0; 5974 break; 5975 5976 case MTTELL: 5977 rval = st_update_block_pos(un, st_cmd, 0); 5978 mtop->mt_count = un->un_pos.lgclblkno; 5979 break; 5980 5981 case MTSEEK: 5982 rval = st_logical_block_locate(un, st_uscsi_cmd, &un->un_pos, 5983 (uint64_t)mtop->mt_count, un->un_pos.partition); 5984 /* 5985 * This bit of magic make mt print the actual position if 5986 * the resulting position was not what was asked for. 5987 */ 5988 if (rval == ESPIPE) { 5989 rval = EIO; 5990 if ((uint64_t)mtop->mt_count != un->un_pos.lgclblkno) { 5991 mtop->mt_op = MTTELL; 5992 mtop->mt_count = un->un_pos.lgclblkno; 5993 } 5994 } 5995 break; 5996 5997 case MTLOCK: 5998 if (st_cmd(un, SCMD_DOORLOCK, MR_LOCK, SYNC_CMD)) { 5999 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6000 "st_do_mtioctop : EIO : MTLOCK"); 6001 rval = EIO; 6002 } 6003 break; 6004 6005 case MTUNLOCK: 6006 if (st_cmd(un, SCMD_DOORLOCK, MR_UNLOCK, SYNC_CMD)) { 6007 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6008 "st_do_mtioctop : EIO : MTUNLOCK"); 6009 rval = EIO; 6010 } 6011 break; 6012 6013 default: 6014 rval = ENOTTY; 6015 } 6016 6017 return (rval); 6018 } 6019 6020 6021 /* 6022 * Run a command for uscsi ioctl. 6023 */ 6024 static int 6025 st_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, int flag) 6026 { 6027 struct uscsi_cmd *uscmd; 6028 struct buf *bp; 6029 enum uio_seg uioseg; 6030 int offline_state = 0; 6031 int err = 0; 6032 dev_t dev = un->un_dev; 6033 6034 ST_FUNC(ST_DEVINFO, st_uscsi_cmd); 6035 6036 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6037 "st_uscsi_cmd(dev = 0x%lx)\n", un->un_dev); 6038 6039 ASSERT(mutex_owned(ST_MUTEX)); 6040 6041 /* 6042 * We really don't know what commands are coming in here and 6043 * we don't want to limit the commands coming in. 6044 * 6045 * If st_tape_init() gets called from st_strategy(), then we 6046 * will hang the process waiting for un->un_sbuf_busy to be cleared, 6047 * which it never will, as we set it below. To prevent 6048 * st_tape_init() from getting called, we have to set state to other 6049 * than ST_STATE_OFFLINE, so we choose ST_STATE_INITIALIZING, which 6050 * achieves this purpose already. 6051 * 6052 * We use offline_state to preserve the OFFLINE state, if it exists, 6053 * so other entry points to the driver might have the chance to call 6054 * st_tape_init(). 6055 */ 6056 if (un->un_state == ST_STATE_OFFLINE) { 6057 un->un_laststate = ST_STATE_OFFLINE; 6058 un->un_state = ST_STATE_INITIALIZING; 6059 offline_state = 1; 6060 } 6061 6062 mutex_exit(ST_MUTEX); 6063 err = scsi_uscsi_alloc_and_copyin((intptr_t)ucmd, flag, ROUTE, &uscmd); 6064 mutex_enter(ST_MUTEX); 6065 if (err != 0) { 6066 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6067 "st_uscsi_cmd: scsi_uscsi_alloc_and_copyin failed\n"); 6068 goto exit; 6069 } 6070 6071 uioseg = (flag & FKIOCTL) ? UIO_SYSSPACE : UIO_USERSPACE; 6072 6073 /* check to see if this command requires the drive to be reserved */ 6074 if (uscmd->uscsi_cdb != NULL) { 6075 err = st_check_cdb_for_need_to_reserve(un, 6076 (uchar_t *)uscmd->uscsi_cdb); 6077 if (err) { 6078 goto exit_free; 6079 } 6080 /* 6081 * If this is a space command we need to save the starting 6082 * point so we can retry from there if the command fails. 6083 */ 6084 if ((uscmd->uscsi_cdb[0] == SCMD_SPACE) || 6085 (uscmd->uscsi_cdb[0] == (char)SCMD_SPACE_G4)) { 6086 (void) st_update_block_pos(un, st_cmd, 0); 6087 } 6088 } 6089 6090 /* 6091 * Forground should not be doing anything while recovery is active. 6092 */ 6093 ASSERT(un->un_recov_buf_busy == 0); 6094 6095 /* 6096 * Get buffer resources... 6097 */ 6098 while (un->un_sbuf_busy) 6099 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 6100 un->un_sbuf_busy = 1; 6101 6102 #ifdef STDEBUG 6103 if ((uscmd->uscsi_cdb != NULL) && (st_debug & 0x7) > 6) { 6104 int rw = (uscmd->uscsi_flags & USCSI_READ) ? B_READ : B_WRITE; 6105 st_print_cdb(ST_DEVINFO, st_label, SCSI_DEBUG, 6106 "uscsi cdb", uscmd->uscsi_cdb); 6107 if (uscmd->uscsi_buflen) { 6108 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6109 "uscsi %s of %ld bytes %s %s space\n", 6110 (rw == B_READ) ? rd_str : wr_str, 6111 uscmd->uscsi_buflen, 6112 (rw == B_READ) ? "to" : "from", 6113 (uioseg == UIO_SYSSPACE) ? "system" : "user"); 6114 } 6115 } 6116 #endif /* STDEBUG */ 6117 6118 /* 6119 * Although st_uscsi_cmd() never makes use of these 6120 * now, we are just being safe and consistent. 6121 */ 6122 uscmd->uscsi_flags &= ~(USCSI_NOINTR | USCSI_NOPARITY | 6123 USCSI_OTAG | USCSI_HTAG | USCSI_HEAD); 6124 6125 un->un_srqbufp = uscmd->uscsi_rqbuf; 6126 bp = un->un_sbufp; 6127 bzero(bp, sizeof (buf_t)); 6128 if (uscmd->uscsi_cdb != NULL) { 6129 bp->b_forw = (struct buf *)(uintptr_t)uscmd->uscsi_cdb[0]; 6130 } 6131 bp->b_back = (struct buf *)uscmd; 6132 6133 mutex_exit(ST_MUTEX); 6134 err = scsi_uscsi_handle_cmd(dev, uioseg, uscmd, st_strategy, bp, NULL); 6135 mutex_enter(ST_MUTEX); 6136 6137 /* 6138 * If scsi reset successful, don't write any filemarks. 6139 */ 6140 if ((err == 0) && (uscmd->uscsi_flags & 6141 (USCSI_RESET_LUN | USCSI_RESET_TARGET | USCSI_RESET_ALL))) { 6142 un->un_fmneeded = 0; 6143 } 6144 6145 exit_free: 6146 /* 6147 * Free resources 6148 */ 6149 un->un_sbuf_busy = 0; 6150 un->un_srqbufp = NULL; 6151 6152 /* 6153 * If was a space command need to update logical block position. 6154 * If the command failed such that positioning is invalid, Don't 6155 * update the position as the user must do this to validate the 6156 * position for data protection. 6157 */ 6158 if ((uscmd->uscsi_cdb != NULL) && 6159 ((uscmd->uscsi_cdb[0] == SCMD_SPACE) || 6160 (uscmd->uscsi_cdb[0] == (char)SCMD_SPACE_G4)) && 6161 (un->un_pos.pmode != invalid)) { 6162 un->un_running.pmode = invalid; 6163 (void) st_update_block_pos(un, st_cmd, 1); 6164 /* 6165 * Set running position to invalid so it updates on the 6166 * next command. 6167 */ 6168 un->un_running.pmode = invalid; 6169 } 6170 cv_signal(&un->un_sbuf_cv); 6171 mutex_exit(ST_MUTEX); 6172 (void) scsi_uscsi_copyout_and_free((intptr_t)ucmd, uscmd); 6173 mutex_enter(ST_MUTEX); 6174 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6175 "st_uscsi_cmd returns 0x%x\n", err); 6176 6177 exit: 6178 /* don't lose offline state */ 6179 if (offline_state) { 6180 un->un_state = ST_STATE_OFFLINE; 6181 } 6182 6183 ASSERT(mutex_owned(ST_MUTEX)); 6184 return (err); 6185 } 6186 6187 static int 6188 st_write_fm(dev_t dev, int wfm) 6189 { 6190 int i; 6191 int rval; 6192 6193 GET_SOFT_STATE(dev); 6194 6195 ST_FUNC(ST_DEVINFO, st_write_fm); 6196 6197 ASSERT(mutex_owned(ST_MUTEX)); 6198 6199 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6200 "st_write_fm(dev = 0x%lx, wfm = %d)\n", dev, wfm); 6201 6202 /* 6203 * write one filemark at the time after EOT 6204 */ 6205 if (un->un_pos.eof >= ST_EOT) { 6206 for (i = 0; i < wfm; i++) { 6207 rval = st_cmd(un, SCMD_WRITE_FILE_MARK, 1, SYNC_CMD); 6208 if (rval == EACCES) { 6209 return (rval); 6210 } 6211 if (rval != 0) { 6212 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6213 "st_write_fm : EIO : write EOT file mark"); 6214 return (EIO); 6215 } 6216 } 6217 } else { 6218 rval = st_cmd(un, SCMD_WRITE_FILE_MARK, wfm, SYNC_CMD); 6219 if (rval == EACCES) { 6220 return (rval); 6221 } 6222 if (rval) { 6223 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6224 "st_write_fm : EIO : write file mark"); 6225 return (EIO); 6226 } 6227 } 6228 6229 ASSERT(mutex_owned(ST_MUTEX)); 6230 return (0); 6231 } 6232 6233 #ifdef STDEBUG 6234 static void 6235 st_start_dump(struct scsi_tape *un, struct buf *bp) 6236 { 6237 struct scsi_pkt *pkt = BP_PKT(bp); 6238 uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp; 6239 6240 ST_FUNC(ST_DEVINFO, st_start_dump); 6241 6242 if ((st_debug & 0x7) < 6) 6243 return; 6244 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6245 "st_start: cmd=0x%p count=%ld resid=%ld flags=0x%x pkt=0x%p\n", 6246 (void *)bp->b_forw, bp->b_bcount, 6247 bp->b_resid, bp->b_flags, (void *)BP_PKT(bp)); 6248 st_print_cdb(ST_DEVINFO, st_label, SCSI_DEBUG, 6249 "st_start: cdb", (caddr_t)cdbp); 6250 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6251 "st_start: fileno=%d, blk=%d\n", 6252 un->un_pos.fileno, un->un_pos.blkno); 6253 } 6254 #endif 6255 6256 6257 /* 6258 * Command start && done functions 6259 */ 6260 6261 /* 6262 * st_start() 6263 * 6264 * Called from: 6265 * st_strategy() to start a command. 6266 * st_runout() to retry when scsi_pkt allocation fails on previous attempt(s). 6267 * st_attach() when resuming from power down state. 6268 * st_start_restart() to retry transport when device was previously busy. 6269 * st_done_and_mutex_exit() to start the next command when previous is done. 6270 * 6271 * On entry: 6272 * scsi_pkt may or may not be allocated. 6273 * 6274 */ 6275 static void 6276 st_start(struct scsi_tape *un) 6277 { 6278 struct buf *bp; 6279 int status; 6280 int queued; 6281 6282 ST_FUNC(ST_DEVINFO, st_start); 6283 ASSERT(mutex_owned(ST_MUTEX)); 6284 6285 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6286 "st_start(): dev = 0x%lx\n", un->un_dev); 6287 6288 if (un->un_recov_buf_busy) { 6289 /* recovery commands can happen anytime */ 6290 bp = un->un_recov_buf; 6291 queued = 0; 6292 } else if (un->un_sbuf_busy) { 6293 /* sbuf commands should only happen with an empty queue. */ 6294 ASSERT(un->un_quef == NULL); 6295 ASSERT(un->un_runqf == NULL); 6296 bp = un->un_sbufp; 6297 queued = 0; 6298 } else if (un->un_quef != NULL) { 6299 if (un->un_persistence && un->un_persist_errors) { 6300 return; 6301 } 6302 bp = un->un_quef; 6303 queued = 1; 6304 } else { 6305 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6306 "st_start() returning no buf found\n"); 6307 return; 6308 } 6309 6310 ASSERT((bp->b_flags & B_DONE) == 0); 6311 6312 /* 6313 * Don't send more than un_throttle commands to the HBA 6314 */ 6315 if ((un->un_throttle <= 0) || (un->un_ncmds >= un->un_throttle)) { 6316 /* 6317 * if doing recovery we know there is outstanding commands. 6318 */ 6319 if (bp != un->un_recov_buf) { 6320 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6321 "st_start returning throttle = %d or ncmds = %d\n", 6322 un->un_throttle, un->un_ncmds); 6323 if (un->un_ncmds == 0) { 6324 typedef void (*func)(); 6325 func fnc = (func)st_runout; 6326 6327 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6328 "Sending delayed start to st_runout()\n"); 6329 mutex_exit(ST_MUTEX); 6330 (void) timeout(fnc, un, drv_usectohz(1000000)); 6331 } 6332 return; 6333 } 6334 } 6335 6336 /* 6337 * If the buf has no scsi_pkt call st_make_cmd() to get one and 6338 * build the command. 6339 */ 6340 if (BP_PKT(bp) == NULL) { 6341 ASSERT((bp->b_flags & B_DONE) == 0); 6342 st_make_cmd(un, bp, st_runout); 6343 ASSERT((bp->b_flags & B_DONE) == 0); 6344 status = geterror(bp); 6345 6346 /* 6347 * Some HBA's don't call bioerror() to set an error. 6348 * And geterror() returns zero if B_ERROR is not set. 6349 * So if we get zero we must check b_error. 6350 */ 6351 if (status == 0 && bp->b_error != 0) { 6352 status = bp->b_error; 6353 bioerror(bp, status); 6354 } 6355 6356 /* 6357 * Some HBA's convert DDI_DMA_NORESOURCES into ENOMEM. 6358 * In tape ENOMEM has special meaning so we'll change it. 6359 */ 6360 if (status == ENOMEM) { 6361 status = 0; 6362 bioerror(bp, status); 6363 } 6364 6365 /* 6366 * Did it fail and is it retryable? 6367 * If so return and wait for the callback through st_runout. 6368 * Also looks like scsi_init_pkt() will setup a callback even 6369 * if it isn't retryable. 6370 */ 6371 if (BP_PKT(bp) == NULL) { 6372 if (status == 0) { 6373 /* 6374 * If first attempt save state. 6375 */ 6376 if (un->un_state != ST_STATE_RESOURCE_WAIT) { 6377 un->un_laststate = un->un_state; 6378 un->un_state = ST_STATE_RESOURCE_WAIT; 6379 } 6380 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 6381 "temp no resources for pkt\n"); 6382 } else if (status == EINVAL) { 6383 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6384 "scsi_init_pkt rejected pkt as too big\n"); 6385 if (un->un_persistence) { 6386 st_set_pe_flag(un); 6387 } 6388 } else { 6389 /* 6390 * Unlikely that it would be retryable then not. 6391 */ 6392 if (un->un_state == ST_STATE_RESOURCE_WAIT) { 6393 un->un_state = un->un_laststate; 6394 } 6395 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 6396 "perm no resources for pkt errno = 0x%x\n", 6397 status); 6398 } 6399 return; 6400 } 6401 /* 6402 * Worked this time set the state back. 6403 */ 6404 if (un->un_state == ST_STATE_RESOURCE_WAIT) { 6405 un->un_state = un->un_laststate; 6406 } 6407 } 6408 6409 if (queued) { 6410 /* 6411 * move from waitq to runq 6412 */ 6413 (void) st_remove_from_queue(&un->un_quef, &un->un_quel, bp); 6414 st_add_to_queue(&un->un_runqf, &un->un_runql, un->un_runql, bp); 6415 } 6416 6417 6418 #ifdef STDEBUG 6419 st_start_dump(un, bp); 6420 #endif 6421 6422 /* could not get here if throttle was zero */ 6423 un->un_last_throttle = un->un_throttle; 6424 un->un_throttle = 0; /* so nothing else will come in here */ 6425 un->un_ncmds++; 6426 6427 ST_DO_KSTATS(bp, kstat_waitq_to_runq); 6428 6429 status = st_transport(un, BP_PKT(bp)); 6430 6431 if (un->un_last_throttle) { 6432 un->un_throttle = un->un_last_throttle; 6433 } 6434 6435 if (status != TRAN_ACCEPT) { 6436 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 6437 mutex_exit(ST_MUTEX); 6438 6439 if (status == TRAN_BUSY) { 6440 /* if too many retries, fail the transport */ 6441 if (st_handle_start_busy(un, bp, 6442 ST_TRAN_BUSY_TIMEOUT, queued) == 0) 6443 goto done; 6444 } 6445 scsi_log(ST_DEVINFO, st_label, CE_WARN, 6446 "transport rejected %d\n", status); 6447 bp->b_resid = bp->b_bcount; 6448 6449 6450 #ifndef __lock_lint 6451 /* 6452 * warlock doesn't understand this potential 6453 * recursion? 6454 */ 6455 mutex_enter(ST_MUTEX); 6456 ST_DO_KSTATS(bp, kstat_waitq_exit); 6457 ST_DO_ERRSTATS(un, st_transerrs); 6458 st_bioerror(bp, EIO); 6459 st_set_pe_flag(un); 6460 st_done_and_mutex_exit(un, bp); 6461 #endif 6462 } else { 6463 un->un_tran_retry_ct = 0; 6464 mutex_exit(ST_MUTEX); 6465 } 6466 6467 done: 6468 6469 mutex_enter(ST_MUTEX); 6470 } 6471 6472 /* 6473 * if the transport is busy, then put this bp back on the waitq 6474 */ 6475 static int 6476 st_handle_start_busy(struct scsi_tape *un, struct buf *bp, 6477 clock_t timeout_interval, int queued) 6478 { 6479 6480 ST_FUNC(ST_DEVINFO, st_handle_start_busy); 6481 6482 mutex_enter(ST_MUTEX); 6483 6484 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6485 "st_handle_start_busy()\n"); 6486 6487 /* 6488 * Check to see if we hit the retry timeout and one last check for 6489 * making sure this is the last on the runq, if it is not, we have 6490 * to fail 6491 */ 6492 if (((int)un->un_tran_retry_ct++ > st_retry_count) || 6493 ((queued) && (un->un_runql != bp))) { 6494 mutex_exit(ST_MUTEX); 6495 return (-1); 6496 } 6497 6498 if (queued) { 6499 /* put the bp back on the waitq */ 6500 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quef, bp); 6501 } 6502 6503 /* 6504 * Decrement un_ncmds so that this 6505 * gets thru' st_start() again. 6506 */ 6507 un->un_ncmds--; 6508 6509 if (queued) { 6510 /* 6511 * since this is an error case, we won't have to do this list 6512 * walking much. We've already made sure this bp was the 6513 * last on the runq 6514 */ 6515 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 6516 6517 /* 6518 * send a marker pkt, if appropriate 6519 */ 6520 st_hba_unflush(un); 6521 6522 } 6523 /* 6524 * all queues are aligned, we are just waiting to 6525 * transport, don't alloc any more buf p's, when 6526 * st_start is reentered. 6527 */ 6528 (void) timeout(st_start_restart, un, timeout_interval); 6529 6530 mutex_exit(ST_MUTEX); 6531 return (0); 6532 } 6533 6534 6535 /* 6536 * st_runout a callback that is called what a resource allocatation failed 6537 */ 6538 static int 6539 st_runout(caddr_t arg) 6540 { 6541 struct scsi_tape *un = (struct scsi_tape *)arg; 6542 struct buf *bp; 6543 int queued; 6544 6545 ASSERT(un != NULL); 6546 6547 ST_FUNC(ST_DEVINFO, st_runout); 6548 6549 mutex_enter(ST_MUTEX); 6550 6551 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_runout()\n"); 6552 6553 if (un->un_recov_buf_busy != 0) { 6554 bp = un->un_recov_buf; 6555 queued = 0; 6556 } else if (un->un_sbuf_busy != 0) { 6557 /* sbuf commands should only happen with an empty queue. */ 6558 ASSERT(un->un_quef == NULL); 6559 ASSERT(un->un_runqf == NULL); 6560 bp = un->un_sbufp; 6561 queued = 0; 6562 } else if (un->un_quef != NULL) { 6563 bp = un->un_quef; 6564 if (un->un_persistence && un->un_persist_errors) { 6565 mutex_exit(ST_MUTEX); 6566 bp->b_resid = bp->b_bcount; 6567 biodone(bp); 6568 return (1); 6569 } 6570 queued = 1; 6571 } else { 6572 ASSERT(1 == 0); 6573 mutex_exit(ST_MUTEX); 6574 return (1); 6575 } 6576 6577 /* 6578 * failed scsi_init_pkt(). If errno is zero its retryable. 6579 */ 6580 if ((bp != NULL) && (geterror(bp) != 0)) { 6581 6582 scsi_log(ST_DEVINFO, st_label, CE_WARN, 6583 "errors after pkt alloc (b_flags=0x%x, b_error=0x%x)\n", 6584 bp->b_flags, geterror(bp)); 6585 ASSERT((bp->b_flags & B_DONE) == 0); 6586 6587 if (queued) { 6588 (void) st_remove_from_queue(&un->un_quef, &un->un_quel, 6589 bp); 6590 } 6591 mutex_exit(ST_MUTEX); 6592 6593 ASSERT((bp->b_flags & B_DONE) == 0); 6594 6595 /* 6596 * Set resid, Error already set, then unblock calling thread. 6597 */ 6598 bp->b_resid = bp->b_bcount; 6599 biodone(bp); 6600 } else { 6601 /* 6602 * Try Again 6603 */ 6604 st_start(un); 6605 mutex_exit(ST_MUTEX); 6606 } 6607 6608 /* 6609 * Comments courtesy of sd.c 6610 * The scsi_init_pkt routine allows for the callback function to 6611 * return a 0 indicating the callback should be rescheduled or a 1 6612 * indicating not to reschedule. This routine always returns 1 6613 * because the driver always provides a callback function to 6614 * scsi_init_pkt. This results in a callback always being scheduled 6615 * (via the scsi_init_pkt callback implementation) if a resource 6616 * failure occurs. 6617 */ 6618 6619 return (1); 6620 } 6621 6622 /* 6623 * st_done_and_mutex_exit() 6624 * - remove bp from runq 6625 * - start up the next request 6626 * - if this was an asynch bp, clean up 6627 * - exit with released mutex 6628 */ 6629 static void 6630 st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp) 6631 { 6632 int pe_flagged = 0; 6633 6634 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 6635 #if !defined(lint) 6636 _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex)) 6637 #endif 6638 6639 ST_FUNC(ST_DEVINFO, st_done_and_mutex_exit); 6640 6641 ASSERT(mutex_owned(ST_MUTEX)); 6642 6643 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 6644 6645 un->un_ncmds--; 6646 cv_signal(&un->un_queue_cv); 6647 6648 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6649 "st_done_and_mutex_exit(): cmd=0x%x count=%ld resid=%ld flags=" 6650 "0x%x\n", (uchar_t)*((caddr_t)(BP_PKT(bp))->pkt_cdbp), bp->b_bcount, 6651 bp->b_resid, bp->b_flags); 6652 6653 6654 /* 6655 * update kstats with transfer count info 6656 */ 6657 if (un->un_stats && (bp != un->un_sbufp) && IS_RW(bp)) { 6658 uint32_t n_done = bp->b_bcount - bp->b_resid; 6659 if (bp->b_flags & B_READ) { 6660 IOSP->reads++; 6661 IOSP->nread += n_done; 6662 } else { 6663 IOSP->writes++; 6664 IOSP->nwritten += n_done; 6665 } 6666 } 6667 6668 /* 6669 * Start the next one before releasing resources on this one, if 6670 * there is something on the queue and persistent errors has not been 6671 * flagged 6672 */ 6673 6674 if ((pe_flagged = (un->un_persistence && un->un_persist_errors)) != 0) { 6675 un->un_last_resid = bp->b_resid; 6676 un->un_last_count = bp->b_bcount; 6677 } 6678 6679 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 6680 cv_broadcast(&un->un_tape_busy_cv); 6681 } else if (un->un_quef && un->un_throttle && !pe_flagged && 6682 (bp != un->un_recov_buf)) { 6683 st_start(un); 6684 } 6685 6686 if (bp == un->un_sbufp && (bp->b_flags & B_ASYNC)) { 6687 /* 6688 * Since we marked this ourselves as ASYNC, 6689 * there isn't anybody around waiting for 6690 * completion any more. 6691 */ 6692 uchar_t *cdb = (uchar_t *)bp->b_forw; 6693 if (*cdb == SCMD_READ || *cdb == SCMD_WRITE) { 6694 bp->b_un.b_addr = (caddr_t)0; 6695 } 6696 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 6697 "st_done_and_mutex_exit(async): freeing pkt\n"); 6698 st_print_cdb(ST_DEVINFO, st_label, CE_NOTE, 6699 "CDB sent with B_ASYNC", (caddr_t)cdb); 6700 if (BP_PKT(bp)) { 6701 scsi_destroy_pkt(BP_PKT(bp)); 6702 } 6703 un->un_sbuf_busy = 0; 6704 cv_signal(&un->un_sbuf_cv); 6705 mutex_exit(ST_MUTEX); 6706 return; 6707 } 6708 6709 if (bp == un->un_sbufp && BP_UCMD(bp)) { 6710 /* 6711 * Copy status from scsi_pkt to uscsi_cmd 6712 * since st_uscsi_cmd needs it 6713 */ 6714 BP_UCMD(bp)->uscsi_status = SCBP_C(BP_PKT(bp)); 6715 } 6716 6717 6718 #ifdef STDEBUG 6719 if (((st_debug & 0x7) >= 4) && 6720 (((un->un_pos.blkno % 100) == 0) || 6721 (un->un_persistence && un->un_persist_errors))) { 6722 6723 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6724 "st_d_a_m_exit(): ncmds = %d, thr = %d, " 6725 "un_errno = %d, un_pe = %d\n", 6726 un->un_ncmds, un->un_throttle, un->un_errno, 6727 un->un_persist_errors); 6728 } 6729 6730 #endif 6731 6732 mutex_exit(ST_MUTEX); 6733 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 6734 "st_done_and_mutex_exit: freeing pkt\n"); 6735 6736 if (BP_PKT(bp)) { 6737 scsi_destroy_pkt(BP_PKT(bp)); 6738 } 6739 6740 biodone(bp); 6741 6742 /* 6743 * now that we biodoned that command, if persistent errors have been 6744 * flagged, flush the waitq 6745 */ 6746 if (pe_flagged) 6747 st_flush(un); 6748 } 6749 6750 6751 /* 6752 * Tape error, flush tape driver queue. 6753 */ 6754 static void 6755 st_flush(struct scsi_tape *un) 6756 { 6757 struct buf *bp; 6758 6759 ST_FUNC(ST_DEVINFO, st_flush); 6760 6761 mutex_enter(ST_MUTEX); 6762 6763 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6764 "st_flush(), ncmds = %d, quef = 0x%p\n", 6765 un->un_ncmds, (void *)un->un_quef); 6766 6767 /* 6768 * if we still have commands outstanding, wait for them to come in 6769 * before flushing the queue, and make sure there is a queue 6770 */ 6771 if (un->un_ncmds || !un->un_quef) 6772 goto exit; 6773 6774 /* 6775 * we have no more commands outstanding, so let's deal with special 6776 * cases in the queue for EOM and FM. If we are here, and un_errno 6777 * is 0, then we know there was no error and we return a 0 read or 6778 * write before showing errors 6779 */ 6780 6781 /* Flush the wait queue. */ 6782 while ((bp = un->un_quef) != NULL) { 6783 un->un_quef = bp->b_actf; 6784 6785 bp->b_resid = bp->b_bcount; 6786 6787 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 6788 "st_flush() : blkno=%d, err=%d, b_bcount=%ld\n", 6789 un->un_pos.blkno, un->un_errno, bp->b_bcount); 6790 6791 st_set_pe_errno(un); 6792 6793 bioerror(bp, un->un_errno); 6794 6795 mutex_exit(ST_MUTEX); 6796 /* it should have one, but check anyway */ 6797 if (BP_PKT(bp)) { 6798 scsi_destroy_pkt(BP_PKT(bp)); 6799 } 6800 biodone(bp); 6801 mutex_enter(ST_MUTEX); 6802 } 6803 6804 /* 6805 * It's not a bad practice to reset the 6806 * waitq tail pointer to NULL. 6807 */ 6808 un->un_quel = NULL; 6809 6810 exit: 6811 /* we mucked with the queue, so let others know about it */ 6812 cv_signal(&un->un_queue_cv); 6813 mutex_exit(ST_MUTEX); 6814 } 6815 6816 6817 /* 6818 * Utility functions 6819 */ 6820 static int 6821 st_determine_generic(struct scsi_tape *un) 6822 { 6823 int bsize; 6824 static char *cart = "0.25 inch cartridge"; 6825 char *sizestr; 6826 6827 ST_FUNC(ST_DEVINFO, st_determine_generic); 6828 6829 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 6830 "st_determine_generic(un = 0x%p)\n", (void*)un); 6831 6832 ASSERT(mutex_owned(ST_MUTEX)); 6833 6834 if (st_modesense(un)) { 6835 return (-1); 6836 } 6837 6838 bsize = (un->un_mspl->high_bl << 16) | 6839 (un->un_mspl->mid_bl << 8) | 6840 (un->un_mspl->low_bl); 6841 6842 if (bsize == 0) { 6843 un->un_dp->options |= ST_VARIABLE; 6844 un->un_dp->bsize = 0; 6845 un->un_bsize = 0; 6846 } else if (bsize > ST_MAXRECSIZE_FIXED) { 6847 /* 6848 * record size of this device too big. 6849 * try and convert it to variable record length. 6850 * 6851 */ 6852 un->un_dp->options |= ST_VARIABLE; 6853 if (st_change_block_size(un, 0) != 0) { 6854 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 6855 "Fixed Record Size %d is too large\n", bsize); 6856 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 6857 "Cannot switch to variable record size\n"); 6858 un->un_dp->options &= ~ST_VARIABLE; 6859 return (-1); 6860 } 6861 } else if (st_change_block_size(un, 0) == 0) { 6862 /* 6863 * If the drive was set to a non zero block size, 6864 * See if it can be set to a zero block size. 6865 * If it works, ST_VARIABLE so user can set it as they want. 6866 */ 6867 un->un_dp->options |= ST_VARIABLE; 6868 un->un_dp->bsize = 0; 6869 un->un_bsize = 0; 6870 } else { 6871 un->un_dp->bsize = bsize; 6872 un->un_bsize = bsize; 6873 } 6874 6875 6876 switch (un->un_mspl->density) { 6877 default: 6878 case 0x0: 6879 /* 6880 * default density, cannot determine any other 6881 * information. 6882 */ 6883 sizestr = "Unknown type- assuming 0.25 inch cartridge"; 6884 un->un_dp->type = ST_TYPE_DEFAULT; 6885 un->un_dp->options |= (ST_AUTODEN_OVERRIDE|ST_QIC); 6886 break; 6887 case 0x1: 6888 case 0x2: 6889 case 0x3: 6890 case 0x6: 6891 /* 6892 * 1/2" reel 6893 */ 6894 sizestr = "0.50 inch reel"; 6895 un->un_dp->type = ST_TYPE_REEL; 6896 un->un_dp->options |= ST_REEL; 6897 un->un_dp->densities[0] = 0x1; 6898 un->un_dp->densities[1] = 0x2; 6899 un->un_dp->densities[2] = 0x6; 6900 un->un_dp->densities[3] = 0x3; 6901 break; 6902 case 0x4: 6903 case 0x5: 6904 case 0x7: 6905 case 0x0b: 6906 6907 /* 6908 * Quarter inch. 6909 */ 6910 sizestr = cart; 6911 un->un_dp->type = ST_TYPE_DEFAULT; 6912 un->un_dp->options |= ST_QIC; 6913 6914 un->un_dp->densities[1] = 0x4; 6915 un->un_dp->densities[2] = 0x5; 6916 un->un_dp->densities[3] = 0x7; 6917 un->un_dp->densities[0] = 0x0b; 6918 break; 6919 6920 case 0x0f: 6921 case 0x10: 6922 case 0x11: 6923 case 0x12: 6924 /* 6925 * QIC-120, QIC-150, QIC-320, QIC-600 6926 */ 6927 sizestr = cart; 6928 un->un_dp->type = ST_TYPE_DEFAULT; 6929 un->un_dp->options |= ST_QIC; 6930 un->un_dp->densities[0] = 0x0f; 6931 un->un_dp->densities[1] = 0x10; 6932 un->un_dp->densities[2] = 0x11; 6933 un->un_dp->densities[3] = 0x12; 6934 break; 6935 6936 case 0x09: 6937 case 0x0a: 6938 case 0x0c: 6939 case 0x0d: 6940 /* 6941 * 1/2" cartridge tapes. Include HI-TC. 6942 */ 6943 sizestr = cart; 6944 sizestr[2] = '5'; 6945 sizestr[3] = '0'; 6946 un->un_dp->type = ST_TYPE_HIC; 6947 un->un_dp->densities[0] = 0x09; 6948 un->un_dp->densities[1] = 0x0a; 6949 un->un_dp->densities[2] = 0x0c; 6950 un->un_dp->densities[3] = 0x0d; 6951 break; 6952 6953 case 0x13: 6954 /* DDS-2/DDS-3 scsi spec densities */ 6955 case 0x24: 6956 case 0x25: 6957 case 0x26: 6958 sizestr = "DAT Data Storage (DDS)"; 6959 un->un_dp->type = ST_TYPE_DAT; 6960 un->un_dp->options |= ST_AUTODEN_OVERRIDE; 6961 break; 6962 6963 case 0x14: 6964 /* 6965 * Helical Scan (Exabyte) devices 6966 */ 6967 sizestr = "8mm helical scan cartridge"; 6968 un->un_dp->type = ST_TYPE_EXABYTE; 6969 un->un_dp->options |= ST_AUTODEN_OVERRIDE; 6970 break; 6971 } 6972 6973 /* 6974 * Assume LONG ERASE, BSF and BSR 6975 */ 6976 6977 un->un_dp->options |= 6978 (ST_LONG_ERASE | ST_UNLOADABLE | ST_BSF | ST_BSR | ST_KNOWS_EOD); 6979 6980 /* 6981 * Only if mode sense data says no buffered write, set NOBUF 6982 */ 6983 if (un->un_mspl->bufm == 0) 6984 un->un_dp->options |= ST_NOBUF; 6985 6986 /* 6987 * set up large read and write retry counts 6988 */ 6989 6990 un->un_dp->max_rretries = un->un_dp->max_wretries = 1000; 6991 6992 /* 6993 * If this is a 0.50 inch reel tape, and 6994 * it is *not* variable mode, try and 6995 * set it to variable record length 6996 * mode. 6997 */ 6998 if ((un->un_dp->options & ST_REEL) && un->un_bsize != 0 && 6999 (un->un_dp->options & ST_VARIABLE)) { 7000 if (st_change_block_size(un, 0) == 0) { 7001 un->un_dp->bsize = 0; 7002 un->un_mspl->high_bl = un->un_mspl->mid_bl = 7003 un->un_mspl->low_bl = 0; 7004 } 7005 } 7006 7007 /* 7008 * Write to console about type of device found 7009 */ 7010 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 7011 "Generic Drive, Vendor=%s\n\t%s", un->un_dp->name, 7012 sizestr); 7013 if (un->un_dp->options & ST_VARIABLE) { 7014 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7015 "!Variable record length I/O\n"); 7016 } else { 7017 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7018 "!Fixed record length (%d byte blocks) I/O\n", 7019 un->un_dp->bsize); 7020 } 7021 ASSERT(mutex_owned(ST_MUTEX)); 7022 return (0); 7023 } 7024 7025 static int 7026 st_determine_density(struct scsi_tape *un, int rw) 7027 { 7028 int rval = 0; 7029 7030 ST_FUNC(ST_DEVINFO, st_determine_density); 7031 7032 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7033 "st_determine_density(un = 0x%p, rw = %s)\n", 7034 (void*)un, (rw == B_WRITE ? wr_str: rd_str)); 7035 7036 ASSERT(mutex_owned(ST_MUTEX)); 7037 7038 /* 7039 * If we're past BOT, density is determined already. 7040 */ 7041 if (un->un_pos.pmode == logical) { 7042 if (un->un_pos.lgclblkno != 0) { 7043 goto exit; 7044 } 7045 } else if (un->un_pos.pmode == legacy) { 7046 if ((un->un_pos.fileno != 0) || (un->un_pos.blkno != 0)) { 7047 /* 7048 * XXX: put in a bitch message about attempting to 7049 * XXX: change density past BOT. 7050 */ 7051 goto exit; 7052 } 7053 } else { 7054 goto exit; 7055 } 7056 if ((un->un_pos.pmode == logical) && 7057 (un->un_pos.lgclblkno != 0)) { 7058 goto exit; 7059 } 7060 7061 7062 /* 7063 * If we're going to be writing, we set the density 7064 */ 7065 if (rw == 0 || rw == B_WRITE) { 7066 /* un_curdens is used as an index into densities table */ 7067 un->un_curdens = MT_DENSITY(un->un_dev); 7068 if (st_set_density(un)) { 7069 rval = -1; 7070 } 7071 goto exit; 7072 } 7073 7074 /* 7075 * If density is known already, 7076 * we don't have to get it again.(?) 7077 */ 7078 if (!un->un_density_known) { 7079 if (st_get_density(un)) { 7080 rval = -1; 7081 } 7082 } 7083 7084 exit: 7085 ASSERT(mutex_owned(ST_MUTEX)); 7086 return (rval); 7087 } 7088 7089 7090 /* 7091 * Try to determine density. We do this by attempting to read the 7092 * first record off the tape, cycling through the available density 7093 * codes as we go. 7094 */ 7095 7096 static int 7097 st_get_density(struct scsi_tape *un) 7098 { 7099 int succes = 0, rval = -1, i; 7100 uint_t size; 7101 uchar_t dens, olddens; 7102 7103 ST_FUNC(ST_DEVINFO, st_get_density); 7104 7105 ST_FUNC(ST_DEVINFO, st_get_density); 7106 7107 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7108 "st_get_density(un = 0x%p)\n", (void*)un); 7109 7110 ASSERT(mutex_owned(ST_MUTEX)); 7111 7112 /* 7113 * If Auto Density override is enabled The drive has 7114 * only one density and there is no point in attempting 7115 * find the correct one. 7116 * 7117 * Since most modern drives auto detect the density 7118 * and format of the recorded media before they come 7119 * ready. What this function does is a legacy behavior 7120 * and modern drives not only don't need it, The backup 7121 * utilities that do positioning via uscsi find the un- 7122 * expected rewinds problematic. 7123 * 7124 * The drives that need this are old reel to reel devices. 7125 * I took a swag and said they must be scsi-1 or older. 7126 * I don't beleave there will any of the newer devices 7127 * that need this. There will be some scsi-1 devices that 7128 * don't need this but I don't think they will be using the 7129 * BIG aftermarket backup and restore utilitys. 7130 */ 7131 if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) || 7132 (un->un_sd->sd_inq->inq_ansi > 1)) { 7133 un->un_density_known = 1; 7134 rval = 0; 7135 goto exit; 7136 } 7137 7138 /* 7139 * This will only work on variable record length tapes 7140 * if and only if all variable record length tapes autodensity 7141 * select. 7142 */ 7143 size = (unsigned)(un->un_dp->bsize ? un->un_dp->bsize : SECSIZE); 7144 un->un_tmpbuf = kmem_alloc(size, KM_SLEEP); 7145 7146 /* 7147 * Start at the specified density 7148 */ 7149 7150 dens = olddens = un->un_curdens = MT_DENSITY(un->un_dev); 7151 7152 for (i = 0; i < NDENSITIES; i++, ((un->un_curdens == NDENSITIES - 1) ? 7153 (un->un_curdens = 0) : (un->un_curdens += 1))) { 7154 /* 7155 * If we've done this density before, 7156 * don't bother to do it again. 7157 */ 7158 dens = un->un_dp->densities[un->un_curdens]; 7159 if (i > 0 && dens == olddens) 7160 continue; 7161 olddens = dens; 7162 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7163 "trying density 0x%x\n", dens); 7164 if (st_set_density(un)) { 7165 continue; 7166 } 7167 7168 /* 7169 * XXX - the creates lots of headaches and slowdowns - must 7170 * fix. 7171 */ 7172 succes = (st_cmd(un, SCMD_READ, (int)size, SYNC_CMD) == 0); 7173 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 7174 break; 7175 } 7176 if (succes) { 7177 st_init(un); 7178 rval = 0; 7179 un->un_density_known = 1; 7180 break; 7181 } 7182 } 7183 kmem_free(un->un_tmpbuf, size); 7184 un->un_tmpbuf = 0; 7185 7186 exit: 7187 ASSERT(mutex_owned(ST_MUTEX)); 7188 return (rval); 7189 } 7190 7191 static int 7192 st_set_density(struct scsi_tape *un) 7193 { 7194 int rval = 0; 7195 7196 ST_FUNC(ST_DEVINFO, st_set_density); 7197 7198 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7199 "st_set_density(un = 0x%p): density = 0x%x\n", (void*)un, 7200 un->un_dp->densities[un->un_curdens]); 7201 7202 ASSERT(mutex_owned(ST_MUTEX)); 7203 7204 un->un_mspl->density = un->un_dp->densities[un->un_curdens]; 7205 7206 if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) == 0) { 7207 /* 7208 * If auto density override is not set, Use mode select 7209 * to set density and compression. 7210 */ 7211 if (st_modeselect(un)) { 7212 rval = -1; 7213 } 7214 } else if ((un->un_dp->options & ST_MODE_SEL_COMP) != 0) { 7215 /* 7216 * If auto density and mode select compression are set, 7217 * This is a drive with one density code but compression 7218 * can be enabled or disabled. 7219 * Set compression but no need to set density. 7220 */ 7221 rval = st_set_compression(un); 7222 if ((rval != 0) && (rval != EALREADY)) { 7223 rval = -1; 7224 } else { 7225 rval = 0; 7226 } 7227 } 7228 7229 /* If sucessful set density and/or compression, mark density known */ 7230 if (rval == 0) { 7231 un->un_density_known = 1; 7232 } 7233 7234 ASSERT(mutex_owned(ST_MUTEX)); 7235 return (rval); 7236 } 7237 7238 static int 7239 st_loadtape(struct scsi_tape *un) 7240 { 7241 int rval; 7242 7243 ST_FUNC(ST_DEVINFO, st_loadtape); 7244 7245 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7246 "st_loadtape(un = 0x%p)\n", (void*) un); 7247 7248 ASSERT(mutex_owned(ST_MUTEX)); 7249 7250 rval = st_update_block_pos(un, st_cmd, 0); 7251 if (rval == EACCES) { 7252 return (rval); 7253 } 7254 7255 /* 7256 * 'LOAD' the tape to BOT by rewinding 7257 */ 7258 rval = st_cmd(un, SCMD_REWIND, 1, SYNC_CMD); 7259 if (rval == 0) { 7260 st_init(un); 7261 un->un_density_known = 0; 7262 } 7263 7264 ASSERT(mutex_owned(ST_MUTEX)); 7265 return (rval); 7266 } 7267 7268 7269 /* 7270 * Note: QIC devices aren't so smart. If you try to append 7271 * after EOM, the write can fail because the device doesn't know 7272 * it's at EOM. In that case, issue a read. The read should fail 7273 * because there's no data, but the device knows it's at EOM, 7274 * so a subsequent write should succeed. To further confuse matters, 7275 * the target returns the same error if the tape is positioned 7276 * such that a write would overwrite existing data. That's why 7277 * we have to do the append test. A read in the middle of 7278 * recorded data would succeed, thus indicating we're attempting 7279 * something illegal. 7280 */ 7281 7282 7283 static void 7284 st_test_append(struct buf *bp) 7285 { 7286 dev_t dev = bp->b_edev; 7287 struct scsi_tape *un; 7288 uchar_t status; 7289 unsigned bcount; 7290 7291 un = ddi_get_soft_state(st_state, MTUNIT(dev)); 7292 7293 ST_FUNC(ST_DEVINFO, st_test_append); 7294 7295 ASSERT(mutex_owned(ST_MUTEX)); 7296 7297 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7298 "st_test_append(): fileno %d\n", un->un_pos.fileno); 7299 7300 un->un_laststate = un->un_state; 7301 un->un_state = ST_STATE_APPEND_TESTING; 7302 un->un_test_append = 0; 7303 7304 /* 7305 * first, map in the buffer, because we're doing a double write -- 7306 * first into the kernel, then onto the tape. 7307 */ 7308 bp_mapin(bp); 7309 7310 /* 7311 * get a copy of the data.... 7312 */ 7313 un->un_tmpbuf = kmem_alloc((unsigned)bp->b_bcount, KM_SLEEP); 7314 bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount); 7315 7316 /* 7317 * attempt the write.. 7318 */ 7319 7320 if (st_cmd(un, (int)SCMD_WRITE, (int)bp->b_bcount, SYNC_CMD) == 0) { 7321 success: 7322 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7323 "append write succeeded\n"); 7324 bp->b_resid = un->un_sbufp->b_resid; 7325 mutex_exit(ST_MUTEX); 7326 bcount = (unsigned)bp->b_bcount; 7327 biodone(bp); 7328 mutex_enter(ST_MUTEX); 7329 un->un_laststate = un->un_state; 7330 un->un_state = ST_STATE_OPEN; 7331 kmem_free(un->un_tmpbuf, bcount); 7332 un->un_tmpbuf = NULL; 7333 return; 7334 } 7335 7336 /* 7337 * The append failed. Do a short read. If that fails, we are at EOM 7338 * so we can retry the write command. If that succeeds, than we're 7339 * all screwed up (the controller reported a real error). 7340 * 7341 * XXX: should the dummy read be > SECSIZE? should it be the device's 7342 * XXX: block size? 7343 * 7344 */ 7345 status = un->un_status; 7346 un->un_status = 0; 7347 (void) st_cmd(un, SCMD_READ, SECSIZE, SYNC_CMD); 7348 if (un->un_status == KEY_BLANK_CHECK) { 7349 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7350 "append at EOM\n"); 7351 /* 7352 * Okay- the read failed. We should actually have confused 7353 * the controller enough to allow writing. In any case, the 7354 * i/o is on its own from here on out. 7355 */ 7356 un->un_laststate = un->un_state; 7357 un->un_state = ST_STATE_OPEN; 7358 bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount); 7359 if (st_cmd(un, (int)SCMD_WRITE, (int)bp->b_bcount, 7360 SYNC_CMD) == 0) { 7361 goto success; 7362 } 7363 } 7364 7365 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7366 "append write failed- not at EOM\n"); 7367 bp->b_resid = bp->b_bcount; 7368 st_bioerror(bp, EIO); 7369 7370 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 7371 "st_test_append : EIO : append write failed - not at EOM"); 7372 7373 /* 7374 * backspace one record to get back to where we were 7375 */ 7376 if (st_cmd(un, SCMD_SPACE, Blk(-1), SYNC_CMD)) { 7377 un->un_pos.pmode = invalid; 7378 } 7379 7380 un->un_err_resid = bp->b_resid; 7381 un->un_status = status; 7382 7383 /* 7384 * Note: biodone will do a bp_mapout() 7385 */ 7386 mutex_exit(ST_MUTEX); 7387 bcount = (unsigned)bp->b_bcount; 7388 biodone(bp); 7389 mutex_enter(ST_MUTEX); 7390 un->un_laststate = un->un_state; 7391 un->un_state = ST_STATE_OPEN_PENDING_IO; 7392 kmem_free(un->un_tmpbuf, bcount); 7393 un->un_tmpbuf = NULL; 7394 } 7395 7396 /* 7397 * Special command handler 7398 */ 7399 7400 /* 7401 * common st_cmd code. The fourth parameter states 7402 * whether the caller wishes to await the results 7403 * Note the release of the mutex during most of the function 7404 */ 7405 static int 7406 st_cmd(struct scsi_tape *un, int com, int64_t count, int wait) 7407 { 7408 struct buf *bp; 7409 int err; 7410 7411 ST_FUNC(ST_DEVINFO, st_cmd); 7412 7413 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7414 "st_cmd(dev = 0x%lx, com = 0x%x, count = %"PRIx64", wait = %d)\n", 7415 un->un_dev, com, count, wait); 7416 7417 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 7418 ASSERT(mutex_owned(ST_MUTEX)); 7419 7420 #ifdef STDEBUG 7421 if ((st_debug & 0x7)) { 7422 st_debug_cmds(un, com, count, wait); 7423 } 7424 #endif 7425 7426 st_wait_for_io(un); 7427 7428 /* check to see if this command requires the drive to be reserved */ 7429 err = st_check_cmd_for_need_to_reserve(un, com, count); 7430 7431 if (err) { 7432 return (err); 7433 } 7434 7435 /* 7436 * A space command is not recoverable if we don't know were we 7437 * were when it was issued. 7438 */ 7439 if ((com == SCMD_SPACE) || (com == SCMD_SPACE_G4)) { 7440 (void) st_update_block_pos(un, st_cmd, 0); 7441 } 7442 7443 /* 7444 * Forground should not be doing anything while recovery is active. 7445 */ 7446 ASSERT(un->un_recov_buf_busy == 0); 7447 7448 while (un->un_sbuf_busy) 7449 cv_wait(&un->un_sbuf_cv, ST_MUTEX); 7450 un->un_sbuf_busy = 1; 7451 7452 bp = un->un_sbufp; 7453 bzero(bp, sizeof (buf_t)); 7454 7455 bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC; 7456 7457 err = st_setup_cmd(un, bp, com, count); 7458 7459 un->un_sbuf_busy = 0; 7460 7461 /* 7462 * If was a space command need to update logical block position. 7463 * Only do this if the command was sucessful or it will mask the fact 7464 * that the space command failed by promoting the pmode to logical. 7465 */ 7466 if (((com == SCMD_SPACE) || (com == SCMD_SPACE_G4)) && 7467 (un->un_pos.pmode != invalid)) { 7468 un->un_running.pmode = invalid; 7469 (void) st_update_block_pos(un, st_cmd, 1); 7470 /* 7471 * Set running position to invalid so it updates on the 7472 * next command. 7473 */ 7474 un->un_running.pmode = invalid; 7475 } 7476 7477 cv_signal(&un->un_sbuf_cv); 7478 7479 return (err); 7480 } 7481 7482 static int 7483 st_setup_cmd(struct scsi_tape *un, buf_t *bp, int com, int64_t count) 7484 { 7485 int err; 7486 dev_t dev = un->un_dev; 7487 7488 ST_FUNC(ST_DEVINFO, st_setup_cmd); 7489 /* 7490 * Set count to the actual size of the data tranfer. 7491 * For commands with no data transfer, set bp->b_bcount 7492 * to the value to be used when constructing the 7493 * cdb in st_make_cmd(). 7494 */ 7495 switch (com) { 7496 case SCMD_READ: 7497 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7498 "special read %"PRId64"\n", count); 7499 bp->b_flags |= B_READ; 7500 bp->b_un.b_addr = un->un_tmpbuf; 7501 break; 7502 7503 case SCMD_WRITE: 7504 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7505 "special write %"PRId64"\n", count); 7506 bp->b_un.b_addr = un->un_tmpbuf; 7507 break; 7508 7509 case SCMD_WRITE_FILE_MARK: 7510 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7511 "write %"PRId64" file marks\n", count); 7512 bp->b_bcount = count; 7513 count = 0; 7514 break; 7515 7516 case SCMD_REWIND: 7517 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "rewind\n"); 7518 bp->b_bcount = count; 7519 count = 0; 7520 break; 7521 7522 case SCMD_SPACE: 7523 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "space\n"); 7524 /* 7525 * If the user could have entered a number that will 7526 * not fit in the 12 bit count field of space(8), 7527 * use space(16). 7528 */ 7529 if (((int64_t)SPACE_CNT(count) > 0x7fffff) || 7530 ((int64_t)SPACE_CNT(count) < -(0x7fffff))) { 7531 com = SCMD_SPACE_G4; 7532 } 7533 bp->b_bcount = count; 7534 count = 0; 7535 break; 7536 7537 case SCMD_RESERVE: 7538 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "reserve"); 7539 bp->b_bcount = 0; 7540 count = 0; 7541 break; 7542 7543 case SCMD_RELEASE: 7544 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "release"); 7545 bp->b_bcount = 0; 7546 count = 0; 7547 break; 7548 7549 case SCMD_LOAD: 7550 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7551 "%s tape\n", (count & LD_LOAD) ? "load" : "unload"); 7552 bp->b_bcount = count; 7553 count = 0; 7554 break; 7555 7556 case SCMD_ERASE: 7557 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7558 "erase tape\n"); 7559 bp->b_bcount = count; 7560 count = 0; 7561 break; 7562 7563 case SCMD_MODE_SENSE: 7564 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7565 "mode sense\n"); 7566 bp->b_flags |= B_READ; 7567 bp->b_un.b_addr = (caddr_t)(un->un_mspl); 7568 break; 7569 7570 case SCMD_MODE_SELECT: 7571 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7572 "mode select\n"); 7573 bp->b_un.b_addr = (caddr_t)(un->un_mspl); 7574 break; 7575 7576 case SCMD_READ_BLKLIM: 7577 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7578 "read block limits\n"); 7579 bp->b_bcount = count; 7580 bp->b_flags |= B_READ; 7581 bp->b_un.b_addr = (caddr_t)(un->un_rbl); 7582 break; 7583 7584 case SCMD_TEST_UNIT_READY: 7585 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7586 "test unit ready\n"); 7587 bp->b_bcount = 0; 7588 count = 0; 7589 break; 7590 7591 case SCMD_DOORLOCK: 7592 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7593 "%s tape\n", (count & MR_LOCK) ? "lock" : "unlock"); 7594 bp->b_bcount = count = 0; 7595 break; 7596 7597 case SCMD_READ_POSITION: 7598 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7599 "read position\n"); 7600 switch (un->un_read_pos_type) { 7601 case LONG_POS: 7602 count = sizeof (tape_position_long_t); 7603 break; 7604 case EXT_POS: 7605 count = min(count, sizeof (tape_position_ext_t)); 7606 break; 7607 case SHORT_POS: 7608 count = sizeof (tape_position_t); 7609 break; 7610 default: 7611 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 7612 "Unknown read position type 0x%x in " 7613 "st_make_cmd()\n", un->un_read_pos_type); 7614 } 7615 bp->b_bcount = count; 7616 bp->b_flags |= B_READ; 7617 bp->b_un.b_addr = (caddr_t)un->un_read_pos_data; 7618 break; 7619 7620 default: 7621 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 7622 "Unhandled scsi command 0x%x in st_setup_cmd()\n", com); 7623 } 7624 7625 mutex_exit(ST_MUTEX); 7626 7627 if (count > 0) { 7628 int flg = (bp->b_flags & B_READ) ? B_READ : B_WRITE; 7629 /* 7630 * We're going to do actual I/O. 7631 * Set things up for physio. 7632 */ 7633 struct iovec aiov; 7634 struct uio auio; 7635 struct uio *uio = &auio; 7636 7637 bzero(&auio, sizeof (struct uio)); 7638 bzero(&aiov, sizeof (struct iovec)); 7639 aiov.iov_base = bp->b_un.b_addr; 7640 aiov.iov_len = count; 7641 7642 uio->uio_iov = &aiov; 7643 uio->uio_iovcnt = 1; 7644 uio->uio_resid = aiov.iov_len; 7645 uio->uio_segflg = UIO_SYSSPACE; 7646 7647 /* 7648 * Let physio do the rest... 7649 */ 7650 bp->b_forw = (struct buf *)(uintptr_t)com; 7651 bp->b_back = NULL; 7652 err = physio(st_strategy, bp, dev, flg, st_minphys, uio); 7653 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7654 "st_setup_cmd: physio returns %d\n", err); 7655 } else { 7656 /* 7657 * Mimic physio 7658 */ 7659 bp->b_forw = (struct buf *)(uintptr_t)com; 7660 bp->b_back = NULL; 7661 bp->b_edev = dev; 7662 bp->b_dev = cmpdev(dev); 7663 bp->b_blkno = 0; 7664 bp->b_resid = 0; 7665 (void) st_strategy(bp); 7666 if (bp->b_flags & B_ASYNC) { 7667 /* 7668 * This is an async command- the caller won't wait 7669 * and doesn't care about errors. 7670 */ 7671 mutex_enter(ST_MUTEX); 7672 return (0); 7673 } 7674 7675 /* 7676 * BugTraq #4260046 7677 * ---------------- 7678 * Restore Solaris 2.5.1 behavior, namely call biowait 7679 * unconditionally. The old comment said... 7680 * 7681 * "if strategy was flagged with persistent errors, we would 7682 * have an error here, and the bp would never be sent, so we 7683 * don't want to wait on a bp that was never sent...or hang" 7684 * 7685 * The new rationale, courtesy of Chitrank... 7686 * 7687 * "we should unconditionally biowait() here because 7688 * st_strategy() will do a biodone() in the persistent error 7689 * case and the following biowait() will return immediately. 7690 * If not, in the case of "errors after pkt alloc" in 7691 * st_start(), we will not biowait here which will cause the 7692 * next biowait() to return immediately which will cause 7693 * us to send out the next command. In the case where both of 7694 * these use the sbuf, when the first command completes we'll 7695 * free the packet attached to sbuf and the same pkt will 7696 * get freed again when we complete the second command. 7697 * see esc 518987. BTW, it is necessary to do biodone() in 7698 * st_start() for the pkt alloc failure case because physio() 7699 * does biowait() and will hang if we don't do biodone()" 7700 */ 7701 7702 err = biowait(bp); 7703 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 7704 "st_setup_cmd: biowait returns %d\n", err); 7705 } 7706 7707 mutex_enter(ST_MUTEX); 7708 7709 return (err); 7710 } 7711 7712 static int 7713 st_set_compression(struct scsi_tape *un) 7714 { 7715 int rval; 7716 int turn_compression_on; 7717 minor_t minor; 7718 7719 ST_FUNC(ST_DEVINFO, st_set_compression); 7720 7721 /* 7722 * Drive either dosn't have compression or it is controlled with 7723 * special density codes. Return ENOTTY so caller 7724 * knows nothing was done. 7725 */ 7726 if ((un->un_dp->options & ST_MODE_SEL_COMP) == 0) { 7727 un->un_comp_page = 0; 7728 return (ENOTTY); 7729 } 7730 7731 /* set compression based on minor node opened */ 7732 minor = MT_DENSITY(un->un_dev); 7733 7734 /* 7735 * If this the compression density or 7736 * the drive has two densities and uses mode select for 7737 * control of compression turn on compression for MT_DENSITY2 7738 * as well. 7739 */ 7740 if ((minor == ST_COMPRESSION_DENSITY) || 7741 (minor == MT_DENSITY(MT_DENSITY2)) && 7742 (un->un_dp->densities[0] == un->un_dp->densities[1]) && 7743 (un->un_dp->densities[2] == un->un_dp->densities[3]) && 7744 (un->un_dp->densities[0] != un->un_dp->densities[2])) { 7745 7746 turn_compression_on = 1; 7747 } else { 7748 turn_compression_on = 0; 7749 } 7750 7751 un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16); 7752 un->un_mspl->mid_bl = (uchar_t)(un->un_bsize >> 8); 7753 un->un_mspl->low_bl = (uchar_t)(un->un_bsize); 7754 7755 /* 7756 * Need to determine which page does the device use for compression. 7757 * First try the data compression page. If this fails try the device 7758 * configuration page 7759 */ 7760 7761 if ((un->un_comp_page & ST_DEV_DATACOMP_PAGE) == ST_DEV_DATACOMP_PAGE) { 7762 rval = st_set_datacomp_page(un, turn_compression_on); 7763 if (rval == EALREADY) { 7764 return (rval); 7765 } 7766 if (rval != 0) { 7767 if (un->un_status == KEY_ILLEGAL_REQUEST) { 7768 /* 7769 * This device does not support data 7770 * compression page 7771 */ 7772 un->un_comp_page = ST_DEV_CONFIG_PAGE; 7773 } else if (un->un_state >= ST_STATE_OPEN) { 7774 un->un_pos.pmode = invalid; 7775 rval = EIO; 7776 } else { 7777 rval = -1; 7778 } 7779 } else { 7780 un->un_comp_page = ST_DEV_DATACOMP_PAGE; 7781 } 7782 } 7783 7784 if ((un->un_comp_page & ST_DEV_CONFIG_PAGE) == ST_DEV_CONFIG_PAGE) { 7785 rval = st_set_devconfig_page(un, turn_compression_on); 7786 if (rval == EALREADY) { 7787 return (rval); 7788 } 7789 if (rval != 0) { 7790 if (un->un_status == KEY_ILLEGAL_REQUEST) { 7791 /* 7792 * This device does not support 7793 * compression at all advice the 7794 * user and unset ST_MODE_SEL_COMP 7795 */ 7796 un->un_dp->options &= ~ST_MODE_SEL_COMP; 7797 un->un_comp_page = 0; 7798 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 7799 "Device Does Not Support Compression\n"); 7800 } else if (un->un_state >= ST_STATE_OPEN) { 7801 un->un_pos.pmode = invalid; 7802 rval = EIO; 7803 } else { 7804 rval = -1; 7805 } 7806 } 7807 } 7808 7809 return (rval); 7810 } 7811 7812 /* 7813 * set or unset compression thru device configuration page. 7814 */ 7815 static int 7816 st_set_devconfig_page(struct scsi_tape *un, int compression_on) 7817 { 7818 unsigned char cflag; 7819 int rval = 0; 7820 7821 7822 ST_FUNC(ST_DEVINFO, st_set_devconfig_page); 7823 7824 ASSERT(mutex_owned(ST_MUTEX)); 7825 /* 7826 * Figure what to set compression flag to. 7827 */ 7828 if (compression_on) { 7829 /* They have selected a compression node */ 7830 if (un->un_dp->type == ST_TYPE_FUJI) { 7831 cflag = 0x84; /* use EDRC */ 7832 } else { 7833 cflag = ST_DEV_CONFIG_DEF_COMP; 7834 } 7835 } else { 7836 cflag = ST_DEV_CONFIG_NO_COMP; 7837 } 7838 7839 /* 7840 * If compression is already set the way it was requested. 7841 * And if this not the first time we has tried. 7842 */ 7843 if ((cflag == un->un_mspl->page.dev.comp_alg) && 7844 (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) { 7845 return (EALREADY); 7846 } 7847 7848 un->un_mspl->page.dev.comp_alg = cflag; 7849 /* 7850 * need to send mode select even if correct compression is 7851 * already set since need to set density code 7852 */ 7853 7854 #ifdef STDEBUG 7855 if ((st_debug & 0x7) >= 6) { 7856 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 7857 "st_set_devconfig_page: sense data for mode select", 7858 (char *)un->un_mspl, sizeof (struct seq_mode)); 7859 } 7860 #endif 7861 rval = st_gen_mode_select(un, st_uscsi_cmd, un->un_mspl, 7862 sizeof (struct seq_mode)); 7863 7864 return (rval); 7865 } 7866 7867 /* 7868 * set/reset compression bit thru data compression page 7869 */ 7870 static int 7871 st_set_datacomp_page(struct scsi_tape *un, int compression_on) 7872 { 7873 int compression_on_already; 7874 int rval = 0; 7875 7876 7877 ST_FUNC(ST_DEVINFO, st_set_datacomp_page); 7878 7879 ASSERT(mutex_owned(ST_MUTEX)); 7880 /* 7881 * If drive is not capable of compression (at this time) 7882 * return EALREADY so caller doesn't think that this page 7883 * is not supported. This check is for drives that can 7884 * disable compression from the front panel or configuration. 7885 * I doubt that a drive that supports this page is not really 7886 * capable of compression. 7887 */ 7888 if (un->un_mspl->page.comp.dcc == 0) { 7889 return (EALREADY); 7890 } 7891 7892 /* See if compression currently turned on */ 7893 if (un->un_mspl->page.comp.dce) { 7894 compression_on_already = 1; 7895 } else { 7896 compression_on_already = 0; 7897 } 7898 7899 /* 7900 * If compression is already set the way it was requested. 7901 * And if this not the first time we has tried. 7902 */ 7903 if ((compression_on == compression_on_already) && 7904 (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) { 7905 return (EALREADY); 7906 } 7907 7908 /* 7909 * if we are already set to the appropriate compression 7910 * mode, don't set it again 7911 */ 7912 if (compression_on) { 7913 /* compression selected */ 7914 un->un_mspl->page.comp.dce = 1; 7915 } else { 7916 un->un_mspl->page.comp.dce = 0; 7917 } 7918 7919 7920 #ifdef STDEBUG 7921 if ((st_debug & 0x7) >= 6) { 7922 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 7923 "st_set_datacomp_page: sense data for mode select", 7924 (char *)un->un_mspl, sizeof (struct seq_mode)); 7925 } 7926 #endif 7927 rval = st_gen_mode_select(un, st_uscsi_cmd, un->un_mspl, 7928 sizeof (struct seq_mode)); 7929 7930 return (rval); 7931 } 7932 7933 static int 7934 st_modesense(struct scsi_tape *un) 7935 { 7936 int rval; 7937 uchar_t page; 7938 7939 ST_FUNC(ST_DEVINFO, st_modesense); 7940 7941 page = un->un_comp_page; 7942 7943 switch (page) { 7944 case ST_DEV_DATACOMP_PAGE: 7945 case ST_DEV_CONFIG_PAGE: /* FALLTHROUGH */ 7946 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, un->un_mspl, 7947 sizeof (struct seq_mode)); 7948 break; 7949 7950 case ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE: 7951 if (un->un_dp->options & ST_MODE_SEL_COMP) { 7952 page = ST_DEV_CONFIG_PAGE; 7953 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, 7954 un->un_mspl, sizeof (struct seq_mode)); 7955 if (rval == 0 && un->un_mspl->page_code == page) { 7956 un->un_comp_page = page; 7957 break; 7958 } 7959 page = ST_DEV_DATACOMP_PAGE; 7960 rval = st_gen_mode_sense(un, st_uscsi_cmd, page, 7961 un->un_mspl, sizeof (struct seq_mode)); 7962 if (rval == 0 && un->un_mspl->page_code == page) { 7963 un->un_comp_page = page; 7964 break; 7965 } 7966 un->un_dp->options &= ~ST_MODE_SEL_COMP; 7967 un->un_comp_page = 0; 7968 } else { 7969 un->un_comp_page = 0; 7970 } 7971 7972 default: /* FALLTHROUGH */ 7973 rval = st_cmd(un, SCMD_MODE_SENSE, MSIZE, SYNC_CMD); 7974 } 7975 return (rval); 7976 } 7977 7978 static int 7979 st_modeselect(struct scsi_tape *un) 7980 { 7981 int rval = 0; 7982 int ix; 7983 7984 ST_FUNC(ST_DEVINFO, st_modeselect); 7985 7986 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 7987 "st_modeselect(dev = 0x%lx): density = 0x%x\n", 7988 un->un_dev, un->un_mspl->density); 7989 7990 ASSERT(mutex_owned(ST_MUTEX)); 7991 7992 /* 7993 * The parameter list should be the same for all of the 7994 * cases that follow so set them here 7995 * 7996 * Try mode select first if if fails set fields manually 7997 */ 7998 rval = st_modesense(un); 7999 if (rval != 0) { 8000 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 8001 "st_modeselect: First mode sense failed\n"); 8002 un->un_mspl->bd_len = 8; 8003 un->un_mspl->high_nb = 0; 8004 un->un_mspl->mid_nb = 0; 8005 un->un_mspl->low_nb = 0; 8006 } 8007 un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16); 8008 un->un_mspl->mid_bl = (uchar_t)(un->un_bsize >> 8); 8009 un->un_mspl->low_bl = (uchar_t)(un->un_bsize); 8010 8011 8012 /* 8013 * If configured to use a specific density code for a media type. 8014 * curdens is previously set by the minor node opened. 8015 * If the media type doesn't match the minor node we change it so it 8016 * looks like the correct one was opened. 8017 */ 8018 if (un->un_dp->options & ST_KNOWS_MEDIA) { 8019 uchar_t best; 8020 8021 for (best = 0xff, ix = 0; ix < NDENSITIES; ix++) { 8022 if (un->un_mspl->media_type == 8023 un->un_dp->mediatype[ix]) { 8024 best = ix; 8025 /* 8026 * It matches but it might not be the only one. 8027 * Use the highest matching media type but not 8028 * to exceed the density selected by the open. 8029 */ 8030 if (ix < un->un_curdens) { 8031 continue; 8032 } 8033 un->un_curdens = ix; 8034 break; 8035 } 8036 } 8037 /* If a match was found best will not be 0xff any more */ 8038 if (best < NDENSITIES) { 8039 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 8040 "found media 0x%X using density 0x%X\n", 8041 un->un_mspl->media_type, 8042 un->un_dp->densities[best]); 8043 un->un_mspl->density = un->un_dp->densities[best]; 8044 } else { 8045 /* Otherwise set density based on minor node opened */ 8046 un->un_mspl->density = 8047 un->un_dp->densities[un->un_curdens]; 8048 } 8049 } else { 8050 un->un_mspl->density = un->un_dp->densities[un->un_curdens]; 8051 } 8052 8053 if (un->un_dp->options & ST_NOBUF) { 8054 un->un_mspl->bufm = 0; 8055 } else { 8056 un->un_mspl->bufm = 1; 8057 } 8058 8059 rval = st_set_compression(un); 8060 8061 /* 8062 * If st_set_compression returned invalid or already it 8063 * found no need to do the mode select. 8064 * So do it here. 8065 */ 8066 if ((rval == ENOTTY) || (rval == EALREADY)) { 8067 8068 /* Zero non-writeable fields */ 8069 un->un_mspl->data_len = 0; 8070 un->un_mspl->media_type = 0; 8071 un->un_mspl->wp = 0; 8072 8073 /* need to set the density code */ 8074 rval = st_cmd(un, SCMD_MODE_SELECT, MSIZE, SYNC_CMD); 8075 if (rval != 0) { 8076 if (un->un_state >= ST_STATE_OPEN) { 8077 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 8078 "unable to set tape mode\n"); 8079 un->un_pos.pmode = invalid; 8080 rval = EIO; 8081 } else { 8082 rval = -1; 8083 } 8084 } 8085 } 8086 8087 /* 8088 * The spec recommends to send a mode sense after a mode select 8089 */ 8090 (void) st_modesense(un); 8091 8092 ASSERT(mutex_owned(ST_MUTEX)); 8093 8094 return (rval); 8095 } 8096 8097 /* 8098 * st_gen_mode_sense 8099 * 8100 * generic mode sense.. it allows for any page 8101 */ 8102 static int 8103 st_gen_mode_sense(struct scsi_tape *un, ubufunc_t ubf, int page, 8104 struct seq_mode *page_data, int page_size) 8105 { 8106 8107 int r; 8108 char cdb[CDB_GROUP0]; 8109 struct uscsi_cmd *com; 8110 8111 ST_FUNC(ST_DEVINFO, st_gen_mode_sense); 8112 8113 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8114 8115 bzero(cdb, CDB_GROUP0); 8116 cdb[0] = SCMD_MODE_SENSE; 8117 cdb[2] = (char)page; 8118 cdb[4] = (char)page_size; 8119 8120 com->uscsi_cdb = cdb; 8121 com->uscsi_cdblen = CDB_GROUP0; 8122 com->uscsi_bufaddr = (caddr_t)page_data; 8123 com->uscsi_buflen = page_size; 8124 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8125 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 8126 8127 r = ubf(un, com, FKIOCTL); 8128 kmem_free(com, sizeof (*com)); 8129 return (r); 8130 } 8131 8132 /* 8133 * st_gen_mode_select 8134 * 8135 * generic mode select.. it allows for any page 8136 */ 8137 static int 8138 st_gen_mode_select(struct scsi_tape *un, ubufunc_t ubf, 8139 struct seq_mode *page_data, int page_size) 8140 { 8141 8142 int r; 8143 char cdb[CDB_GROUP0]; 8144 struct uscsi_cmd *com; 8145 8146 ST_FUNC(ST_DEVINFO, st_gen_mode_select); 8147 8148 /* Zero non-writeable fields */ 8149 page_data->data_len = 0; 8150 page_data->media_type = 0; 8151 page_data->wp = 0; 8152 8153 /* 8154 * If mode select has any page data, zero the ps (Page Savable) bit. 8155 */ 8156 if (page_size > MSIZE) { 8157 page_data->ps = 0; 8158 } 8159 8160 8161 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8162 8163 /* 8164 * then, do a mode select to set what ever info 8165 */ 8166 bzero(cdb, CDB_GROUP0); 8167 cdb[0] = SCMD_MODE_SELECT; 8168 cdb[1] = 0x10; /* set PF bit for many third party drives */ 8169 cdb[4] = (char)page_size; 8170 8171 com->uscsi_cdb = cdb; 8172 com->uscsi_cdblen = CDB_GROUP0; 8173 com->uscsi_bufaddr = (caddr_t)page_data; 8174 com->uscsi_buflen = page_size; 8175 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8176 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_WRITE; 8177 8178 r = ubf(un, com, FKIOCTL); 8179 8180 kmem_free(com, sizeof (*com)); 8181 return (r); 8182 } 8183 8184 static int 8185 st_read_block_limits(struct scsi_tape *un, struct read_blklim *read_blk) 8186 { 8187 int rval; 8188 char cdb[CDB_GROUP0]; 8189 struct uscsi_cmd *com; 8190 8191 ST_FUNC(ST_DEVINFO, st_read_block_limits); 8192 8193 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8194 8195 bzero(cdb, CDB_GROUP0); 8196 cdb[0] = SCMD_READ_BLKLIM; 8197 8198 com->uscsi_cdb = cdb; 8199 com->uscsi_cdblen = CDB_GROUP0; 8200 com->uscsi_bufaddr = (caddr_t)read_blk; 8201 com->uscsi_buflen = sizeof (struct read_blklim); 8202 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8203 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 8204 8205 rval = st_uscsi_cmd(un, com, FKIOCTL); 8206 if (com->uscsi_status || com->uscsi_resid) { 8207 rval = -1; 8208 } 8209 8210 kmem_free(com, sizeof (*com)); 8211 return (rval); 8212 } 8213 8214 static int 8215 st_report_density_support(struct scsi_tape *un, uchar_t *density_data, 8216 size_t buflen) 8217 { 8218 int rval; 8219 char cdb[CDB_GROUP1]; 8220 struct uscsi_cmd *com; 8221 8222 ST_FUNC(ST_DEVINFO, st_report_density_support); 8223 8224 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8225 8226 bzero(cdb, CDB_GROUP1); 8227 cdb[0] = SCMD_REPORT_DENSITIES; 8228 cdb[7] = (buflen & 0xff00) >> 8; 8229 cdb[8] = buflen & 0xff; 8230 8231 com->uscsi_cdb = cdb; 8232 com->uscsi_cdblen = CDB_GROUP1; 8233 com->uscsi_bufaddr = (caddr_t)density_data; 8234 com->uscsi_buflen = buflen; 8235 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8236 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 8237 8238 rval = st_uscsi_cmd(un, com, FKIOCTL); 8239 if (com->uscsi_status || com->uscsi_resid) { 8240 rval = -1; 8241 } 8242 8243 kmem_free(com, sizeof (*com)); 8244 return (rval); 8245 } 8246 8247 static int 8248 st_report_supported_operation(struct scsi_tape *un, uchar_t *oper_data, 8249 uchar_t option_code, ushort_t service_action) 8250 { 8251 int rval; 8252 char cdb[CDB_GROUP5]; 8253 struct uscsi_cmd *com; 8254 uint32_t allo_length; 8255 8256 ST_FUNC(ST_DEVINFO, st_report_supported_operation); 8257 8258 allo_length = sizeof (struct one_com_des) + 8259 sizeof (struct com_timeout_des); 8260 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 8261 8262 bzero(cdb, CDB_GROUP5); 8263 cdb[0] = (char)SCMD_MAINTENANCE_IN; 8264 cdb[1] = 0x0c; /* service action */ 8265 if (service_action) { 8266 cdb[2] = (char)(ONE_COMMAND_DATA_FORMAT | 0x80); /* RCTD */ 8267 cdb[4] = (service_action & 0xff00) >> 8; 8268 cdb[5] = service_action & 0xff; 8269 } else { 8270 cdb[2] = (char)(ONE_COMMAND_NO_SERVICE_DATA_FORMAT | 8271 0x80); /* RCTD */ 8272 } 8273 cdb[3] = option_code; 8274 cdb[6] = (allo_length & 0xff000000) >> 24; 8275 cdb[7] = (allo_length & 0xff0000) >> 16; 8276 cdb[8] = (allo_length & 0xff00) >> 8; 8277 cdb[9] = allo_length & 0xff; 8278 8279 com->uscsi_cdb = cdb; 8280 com->uscsi_cdblen = CDB_GROUP5; 8281 com->uscsi_bufaddr = (caddr_t)oper_data; 8282 com->uscsi_buflen = allo_length; 8283 com->uscsi_timeout = un->un_dp->non_motion_timeout; 8284 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 8285 8286 rval = st_uscsi_cmd(un, com, FKIOCTL); 8287 if (com->uscsi_status) { 8288 rval = -1; 8289 } 8290 8291 kmem_free(com, sizeof (*com)); 8292 return (rval); 8293 } 8294 8295 /* 8296 * Changes devices blocksize and bsize to requested blocksize nblksz. 8297 * Returns returned value from first failed call or zero on success. 8298 */ 8299 static int 8300 st_change_block_size(struct scsi_tape *un, uint32_t nblksz) 8301 { 8302 struct seq_mode *current; 8303 int rval; 8304 uint32_t oldblksz; 8305 8306 ST_FUNC(ST_DEVINFO, st_change_block_size); 8307 8308 ST_FUNC(ST_DEVINFO, st_change_block_size); 8309 8310 current = kmem_zalloc(MSIZE, KM_SLEEP); 8311 8312 /* 8313 * If we haven't got the compression page yet, do that first. 8314 */ 8315 if (un->un_comp_page == (ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE)) { 8316 (void) st_modesense(un); 8317 } 8318 8319 /* Read current settings */ 8320 rval = st_gen_mode_sense(un, st_uscsi_cmd, 0, current, MSIZE); 8321 if (rval != 0) { 8322 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8323 "mode sense for change block size failed: rval = %d", rval); 8324 goto finish; 8325 } 8326 8327 /* Figure the current block size */ 8328 oldblksz = 8329 (current->high_bl << 16) | 8330 (current->mid_bl << 8) | 8331 (current->low_bl); 8332 8333 /* If current block size is the same as requested were done */ 8334 if (oldblksz == nblksz) { 8335 un->un_bsize = nblksz; 8336 rval = 0; 8337 goto finish; 8338 } 8339 8340 /* Change to requested block size */ 8341 current->high_bl = (uchar_t)(nblksz >> 16); 8342 current->mid_bl = (uchar_t)(nblksz >> 8); 8343 current->low_bl = (uchar_t)(nblksz); 8344 8345 /* Attempt to change block size */ 8346 rval = st_gen_mode_select(un, st_uscsi_cmd, current, MSIZE); 8347 if (rval != 0) { 8348 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8349 "Set new block size failed: rval = %d", rval); 8350 goto finish; 8351 } 8352 8353 /* Read back and verify setting */ 8354 rval = st_modesense(un); 8355 if (rval == 0) { 8356 un->un_bsize = 8357 (un->un_mspl->high_bl << 16) | 8358 (un->un_mspl->mid_bl << 8) | 8359 (un->un_mspl->low_bl); 8360 8361 if (un->un_bsize != nblksz) { 8362 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 8363 "Blocksize set does not equal requested blocksize" 8364 "(read: %u requested: %u)\n", nblksz, un->un_bsize); 8365 rval = EIO; 8366 } 8367 } 8368 finish: 8369 kmem_free(current, MSIZE); 8370 return (rval); 8371 } 8372 8373 8374 static void 8375 st_init(struct scsi_tape *un) 8376 { 8377 ST_FUNC(ST_DEVINFO, st_init); 8378 8379 ASSERT(mutex_owned(ST_MUTEX)); 8380 8381 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8382 "st_init(): dev = 0x%lx, will reset fileno, blkno, eof\n", 8383 un->un_dev); 8384 8385 un->un_pos.blkno = 0; 8386 un->un_pos.fileno = 0; 8387 un->un_lastop = ST_OP_NIL; 8388 un->un_pos.eof = ST_NO_EOF; 8389 un->un_pwr_mgmt = ST_PWR_NORMAL; 8390 if (st_error_level != SCSI_ERR_ALL) { 8391 if (DEBUGGING) { 8392 st_error_level = SCSI_ERR_ALL; 8393 } else { 8394 st_error_level = SCSI_ERR_RETRYABLE; 8395 } 8396 } 8397 } 8398 8399 8400 static void 8401 st_make_cmd(struct scsi_tape *un, struct buf *bp, int (*func)(caddr_t)) 8402 { 8403 struct scsi_pkt *pkt; 8404 struct uscsi_cmd *ucmd; 8405 recov_info *ri; 8406 int tval = 0; 8407 uint64_t count; 8408 uint32_t additional; 8409 int flags = 0; 8410 int cdb_len = CDB_GROUP0; /* default */ 8411 uchar_t com; 8412 char fixbit; 8413 char short_fm = 0; 8414 int stat_size = 8415 (un->un_arq_enabled ? sizeof (struct scsi_arq_status) : 1); 8416 8417 ST_FUNC(ST_DEVINFO, st_make_cmd); 8418 8419 ASSERT(mutex_owned(ST_MUTEX)); 8420 8421 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8422 "st_make_cmd(): dev = 0x%lx\n", un->un_dev); 8423 8424 8425 /* 8426 * fixbit is for setting the Fixed Mode and Suppress Incorrect 8427 * Length Indicator bits on read/write commands, for setting 8428 * the Long bit on erase commands, and for setting the Code 8429 * Field bits on space commands. 8430 */ 8431 8432 /* regular raw I/O */ 8433 if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) { 8434 pkt = scsi_init_pkt(ROUTE, NULL, bp, 8435 CDB_GROUP0, stat_size, st_recov_sz, 0, func, 8436 (caddr_t)un); 8437 if (pkt == NULL) { 8438 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 8439 "Read Write scsi_init_pkt() failure\n"); 8440 goto exit; 8441 } 8442 ASSERT(pkt->pkt_resid == 0); 8443 #ifdef STDEBUG 8444 bzero(pkt->pkt_private, st_recov_sz); 8445 bzero(pkt->pkt_scbp, stat_size); 8446 #endif 8447 ri = (recov_info *)pkt->pkt_private; 8448 ri->privatelen = st_recov_sz; 8449 if (un->un_bsize == 0) { 8450 count = bp->b_bcount; 8451 fixbit = 0; 8452 } else { 8453 count = bp->b_bcount / un->un_bsize; 8454 fixbit = 1; 8455 } 8456 if (bp->b_flags & B_READ) { 8457 com = SCMD_READ; 8458 un->un_lastop = ST_OP_READ; 8459 if ((un->un_bsize == 0) && /* Not Fixed Block */ 8460 (un->un_dp->options & ST_READ_IGNORE_ILI)) { 8461 fixbit = 2; 8462 } 8463 } else { 8464 com = SCMD_WRITE; 8465 un->un_lastop = ST_OP_WRITE; 8466 } 8467 tval = un->un_dp->io_timeout; 8468 8469 /* 8470 * For really large xfers, increase timeout 8471 */ 8472 if (bp->b_bcount > (10 * ONE_MEG)) 8473 tval *= bp->b_bcount/(10 * ONE_MEG); 8474 8475 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8476 "%s %d amt 0x%lx\n", (com == SCMD_WRITE) ? 8477 wr_str: rd_str, un->un_pos.blkno, bp->b_bcount); 8478 8479 } else if ((ucmd = BP_UCMD(bp)) != NULL) { 8480 /* 8481 * uscsi - build command, allocate scsi resources 8482 */ 8483 st_make_uscsi_cmd(un, ucmd, bp, func); 8484 goto exit; 8485 8486 } else { /* special I/O */ 8487 int stat_size = (un->un_arq_enabled ? 8488 sizeof (struct scsi_arq_status) : 1); 8489 struct buf *allocbp = NULL; 8490 com = (uchar_t)(uintptr_t)bp->b_forw; 8491 count = bp->b_bcount; 8492 8493 switch (com) { 8494 case SCMD_READ: 8495 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8496 "special read %"PRId64"\n", count); 8497 if (un->un_bsize == 0) { 8498 fixbit = 2; /* suppress SILI */ 8499 } else { 8500 fixbit = 1; /* Fixed Block Mode */ 8501 count /= un->un_bsize; 8502 } 8503 allocbp = bp; 8504 un->un_lastop = ST_OP_READ; 8505 tval = un->un_dp->io_timeout; 8506 break; 8507 8508 case SCMD_WRITE: 8509 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8510 "special write %"PRId64"\n", count); 8511 if (un->un_bsize != 0) { 8512 fixbit = 1; /* Fixed Block Mode */ 8513 count /= un->un_bsize; 8514 } else { 8515 fixbit = 0; 8516 } 8517 allocbp = bp; 8518 un->un_lastop = ST_OP_WRITE; 8519 tval = un->un_dp->io_timeout; 8520 break; 8521 8522 case SCMD_WRITE_FILE_MARK: 8523 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8524 "write %"PRId64" file marks\n", count); 8525 un->un_lastop = ST_OP_WEOF; 8526 fixbit = 0; 8527 tval = un->un_dp->io_timeout; 8528 /* 8529 * If ST_SHORT_FILEMARKS bit is ON for EXABYTE 8530 * device, set the Vendor Unique bit to 8531 * write Short File Mark. 8532 */ 8533 if ((un->un_dp->options & ST_SHORT_FILEMARKS) && 8534 ((un->un_dp->type == ST_TYPE_EXB8500) || 8535 (un->un_dp->type == ST_TYPE_EXABYTE))) { 8536 /* 8537 * Now the Vendor Unique bit 7 in Byte 5 of CDB 8538 * is set to to write Short File Mark 8539 */ 8540 short_fm = 1; 8541 } 8542 break; 8543 8544 case SCMD_REWIND: 8545 /* 8546 * In the case of rewind we're gona do the rewind with 8547 * the immediate bit set so status will be retured when 8548 * the command is accepted by the device. We clear the 8549 * B_ASYNC flag so we wait for that acceptance. 8550 */ 8551 if (bp->b_flags & B_ASYNC) { 8552 allocbp = bp; 8553 if (count) { 8554 fixbit = 1; 8555 bp->b_flags &= ~B_ASYNC; 8556 } 8557 } else { 8558 fixbit = 0; 8559 } 8560 count = 0; 8561 bp->b_bcount = 0; 8562 un->un_lastop = ST_OP_CTL; 8563 tval = un->un_dp->rewind_timeout; 8564 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8565 "rewind\n"); 8566 break; 8567 8568 case SCMD_SPACE_G4: 8569 cdb_len = CDB_GROUP4; 8570 case SCMD_SPACE: /* FALL THROUGH */ 8571 fixbit = SPACE_TYPE(bp->b_bcount); 8572 count = SPACE_CNT(bp->b_bcount); 8573 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8574 " %s space %s %"PRId64" from file %d blk %d\n", 8575 bp->b_bcount & SP_BACKSP ? "backward" : "forward", 8576 space_strs[fixbit & 7], count, 8577 un->un_pos.fileno, un->un_pos.blkno); 8578 additional = count >> 32; 8579 count &= 0xffffffff; 8580 un->un_lastop = ST_OP_CTL; 8581 tval = un->un_dp->space_timeout; 8582 break; 8583 8584 case SCMD_LOAD: 8585 ASSERT(count < 10); 8586 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8587 "%s tape\n", load_strs[count]); 8588 fixbit = 0; 8589 8590 /* Loading or Unloading */ 8591 if (count & LD_LOAD) { 8592 tval = un->un_dp->load_timeout; 8593 } else { 8594 tval = un->un_dp->unload_timeout; 8595 } 8596 /* Is Retension requested */ 8597 if (count & LD_RETEN) { 8598 tval += un->un_dp->rewind_timeout; 8599 } 8600 un->un_lastop = ST_OP_CTL; 8601 break; 8602 8603 case SCMD_ERASE: 8604 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8605 "erase tape\n"); 8606 ASSERT(count == 1); /* mt sets this */ 8607 if (count == 1) { 8608 /* 8609 * do long erase 8610 */ 8611 fixbit = 1; /* Long */ 8612 8613 /* Drive might not honor immidiate bit */ 8614 tval = un->un_dp->erase_timeout; 8615 } else { 8616 /* Short Erase */ 8617 tval = un->un_dp->erase_timeout; 8618 fixbit = 0; 8619 } 8620 un->un_lastop = ST_OP_CTL; 8621 count = 0; 8622 break; 8623 8624 case SCMD_MODE_SENSE: 8625 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8626 "mode sense\n"); 8627 allocbp = bp; 8628 fixbit = 0; 8629 tval = un->un_dp->non_motion_timeout; 8630 un->un_lastop = ST_OP_CTL; 8631 break; 8632 8633 case SCMD_MODE_SELECT: 8634 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8635 "mode select\n"); 8636 allocbp = bp; 8637 fixbit = 0; 8638 tval = un->un_dp->non_motion_timeout; 8639 un->un_lastop = ST_OP_CTL; 8640 break; 8641 8642 case SCMD_RESERVE: 8643 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8644 "reserve\n"); 8645 fixbit = 0; 8646 tval = un->un_dp->non_motion_timeout; 8647 un->un_lastop = ST_OP_CTL; 8648 break; 8649 8650 case SCMD_RELEASE: 8651 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8652 "release\n"); 8653 fixbit = 0; 8654 tval = un->un_dp->non_motion_timeout; 8655 un->un_lastop = ST_OP_CTL; 8656 break; 8657 8658 case SCMD_READ_BLKLIM: 8659 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8660 "read block limits\n"); 8661 allocbp = bp; 8662 fixbit = count = 0; 8663 tval = un->un_dp->non_motion_timeout; 8664 un->un_lastop = ST_OP_CTL; 8665 break; 8666 8667 case SCMD_TEST_UNIT_READY: 8668 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8669 "test unit ready\n"); 8670 fixbit = 0; 8671 tval = un->un_dp->non_motion_timeout; 8672 un->un_lastop = ST_OP_CTL; 8673 break; 8674 8675 case SCMD_DOORLOCK: 8676 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8677 "prevent/allow media removal\n"); 8678 fixbit = 0; 8679 tval = un->un_dp->non_motion_timeout; 8680 un->un_lastop = ST_OP_CTL; 8681 break; 8682 8683 case SCMD_READ_POSITION: 8684 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8685 "read position\n"); 8686 fixbit = un->un_read_pos_type; 8687 cdb_len = CDB_GROUP1; 8688 tval = un->un_dp->non_motion_timeout; 8689 allocbp = bp; 8690 un->un_lastop = ST_OP_CTL; 8691 switch (un->un_read_pos_type) { 8692 case LONG_POS: 8693 count = 0; 8694 break; 8695 case EXT_POS: 8696 count = sizeof (tape_position_ext_t); 8697 break; 8698 case SHORT_POS: 8699 count = 0; 8700 break; 8701 default: 8702 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 8703 "Unknown read position type 0x%x in " 8704 " st_make_cmd()\n", un->un_read_pos_type); 8705 } 8706 break; 8707 8708 default: 8709 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 8710 "Unhandled scsi command 0x%x in st_make_cmd()\n", 8711 com); 8712 } 8713 pkt = scsi_init_pkt(ROUTE, NULL, allocbp, cdb_len, stat_size, 8714 st_recov_sz, 0, func, (caddr_t)un); 8715 if (pkt == NULL) { 8716 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 8717 "generic command scsi_init_pkt() failure\n"); 8718 goto exit; 8719 } 8720 8721 ASSERT(pkt->pkt_resid == 0); 8722 #ifdef STDEBUG 8723 bzero(pkt->pkt_private, st_recov_sz); 8724 bzero(pkt->pkt_scbp, stat_size); 8725 #endif 8726 ri = (recov_info *)pkt->pkt_private; 8727 ri->privatelen = st_recov_sz; 8728 if (allocbp) { 8729 ASSERT(geterror(allocbp) == 0); 8730 } 8731 8732 } 8733 8734 8735 (void) scsi_setup_cdb((union scsi_cdb *)pkt->pkt_cdbp, 8736 com, 0, (uint_t)count, additional); 8737 FILL_SCSI1_LUN(un->un_sd, pkt); 8738 /* 8739 * Initialize the SILI/Fixed bits of the byte 1 of cdb. 8740 */ 8741 ((union scsi_cdb *)(pkt->pkt_cdbp))->t_code = fixbit; 8742 ((union scsi_cdb *)pkt->pkt_cdbp)->g0_vu_1 = short_fm; 8743 pkt->pkt_flags = flags; 8744 8745 ASSERT(tval); 8746 pkt->pkt_time = tval; 8747 if (bp == un->un_recov_buf) { 8748 pkt->pkt_comp = st_recov_cb; 8749 } else { 8750 pkt->pkt_comp = st_intr; 8751 } 8752 8753 st_add_recovery_info_to_pkt(un, bp, pkt); 8754 8755 exit: 8756 ASSERT(mutex_owned(ST_MUTEX)); 8757 } 8758 8759 8760 /* 8761 * Build a command based on a uscsi command; 8762 */ 8763 static void 8764 st_make_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, 8765 struct buf *bp, int (*func)(caddr_t)) 8766 { 8767 struct scsi_pkt *pkt; 8768 recov_info *ri; 8769 caddr_t cdb; 8770 int cdblen; 8771 int stat_size = 1; 8772 int flags = 0; 8773 8774 ST_FUNC(ST_DEVINFO, st_make_uscsi_cmd); 8775 8776 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8777 "st_make_uscsi_cmd(): dev = 0x%lx\n", un->un_dev); 8778 8779 if (ucmd->uscsi_flags & USCSI_RQENABLE) { 8780 if (un->un_arq_enabled) { 8781 if (ucmd->uscsi_rqlen > SENSE_LENGTH) { 8782 stat_size = (int)(ucmd->uscsi_rqlen) + 8783 sizeof (struct scsi_arq_status) - 8784 sizeof (struct scsi_extended_sense); 8785 flags = PKT_XARQ; 8786 } else { 8787 stat_size = sizeof (struct scsi_arq_status); 8788 } 8789 } 8790 } 8791 8792 ASSERT(mutex_owned(ST_MUTEX)); 8793 8794 cdb = ucmd->uscsi_cdb; 8795 cdblen = ucmd->uscsi_cdblen; 8796 8797 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 8798 "st_make_uscsi_cmd: buflen=%ld bcount=%ld\n", 8799 ucmd->uscsi_buflen, bp->b_bcount); 8800 pkt = scsi_init_pkt(ROUTE, NULL, 8801 (bp->b_bcount > 0) ? bp : NULL, 8802 cdblen, stat_size, st_recov_sz, flags, func, (caddr_t)un); 8803 if (pkt == NULL) { 8804 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 8805 "uscsi command scsi_init_pkt() failure\n"); 8806 goto exit; 8807 } 8808 8809 ASSERT(pkt->pkt_resid == 0); 8810 #ifdef STDEBUG 8811 bzero(pkt->pkt_private, st_recov_sz); 8812 bzero(pkt->pkt_scbp, stat_size); 8813 #endif 8814 ri = (recov_info *)pkt->pkt_private; 8815 ri->privatelen = st_recov_sz; 8816 8817 bcopy(cdb, pkt->pkt_cdbp, (uint_t)cdblen); 8818 8819 #ifdef STDEBUG 8820 if ((st_debug & 0x7) >= 6) { 8821 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 8822 "pkt_cdbp", (char *)cdb, cdblen); 8823 } 8824 #endif 8825 8826 if (ucmd->uscsi_flags & USCSI_SILENT) { 8827 pkt->pkt_flags |= FLAG_SILENT; 8828 } 8829 8830 pkt->pkt_time = ucmd->uscsi_timeout; 8831 if (bp == un->un_recov_buf) { 8832 pkt->pkt_comp = st_recov_cb; 8833 } else { 8834 pkt->pkt_comp = st_intr; 8835 } 8836 st_add_recovery_info_to_pkt(un, bp, pkt); 8837 exit: 8838 ASSERT(mutex_owned(ST_MUTEX)); 8839 } 8840 8841 8842 /* 8843 * restart cmd currently at the head of the runq 8844 * 8845 * If scsi_transport() succeeds or the retries 8846 * count exhausted, restore the throttle that was 8847 * zeroed out in st_handle_intr_busy(). 8848 * 8849 */ 8850 static void 8851 st_intr_restart(void *arg) 8852 { 8853 struct scsi_tape *un = arg; 8854 struct buf *bp; 8855 int queued; 8856 int status = TRAN_ACCEPT; 8857 8858 mutex_enter(ST_MUTEX); 8859 8860 ST_FUNC(ST_DEVINFO, st_intr_restart); 8861 8862 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 8863 "st_intr_restart(), un = 0x%p\n", (void *)un); 8864 8865 un->un_hib_tid = 0; 8866 8867 if (un->un_recov_buf_busy != 0) { 8868 bp = un->un_recov_buf; 8869 queued = 0; 8870 } else if (un->un_sbuf_busy != 0) { 8871 bp = un->un_sbufp; 8872 queued = 0; 8873 } else if (un->un_quef != NULL) { 8874 bp = un->un_quef; 8875 queued = 1; 8876 } else { 8877 mutex_exit(ST_MUTEX); 8878 return; 8879 } 8880 8881 /* 8882 * Here we know : 8883 * throttle = 0, via st_handle_intr_busy 8884 */ 8885 8886 if (queued) { 8887 /* 8888 * move from waitq to runq, if there is anything on the waitq 8889 */ 8890 (void) st_remove_from_queue(&un->un_quef, &un->un_quef, bp); 8891 8892 if (un->un_runqf) { 8893 /* 8894 * not good, we don't want to requeue something after 8895 * another. 8896 */ 8897 mutex_exit(ST_MUTEX); 8898 goto done_error; 8899 } else { 8900 un->un_runqf = bp; 8901 un->un_runql = bp; 8902 } 8903 } 8904 8905 ST_CDB(ST_DEVINFO, "Interrupt restart CDB", 8906 (char *)BP_PKT(bp)->pkt_cdbp); 8907 8908 ST_DO_KSTATS(bp, kstat_waitq_to_runq); 8909 8910 status = st_transport(un, BP_PKT(bp)); 8911 8912 if (status != TRAN_ACCEPT) { 8913 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 8914 mutex_exit(ST_MUTEX); 8915 8916 if (status == TRAN_BUSY) { 8917 if (st_handle_intr_busy(un, bp, 8918 ST_TRAN_BUSY_TIMEOUT) == 0) 8919 return; /* timeout is setup again */ 8920 } 8921 8922 } else { 8923 un->un_tran_retry_ct = 0; 8924 if (un->un_last_throttle) { 8925 un->un_throttle = un->un_last_throttle; 8926 } 8927 mutex_exit(ST_MUTEX); 8928 return; 8929 } 8930 8931 done_error: 8932 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 8933 "restart transport rejected\n"); 8934 bp->b_resid = bp->b_bcount; 8935 8936 #ifndef __lock_lint 8937 /* 8938 * warlock doesn't understand this potential 8939 * recursion? 8940 */ 8941 mutex_enter(ST_MUTEX); 8942 if (un->un_last_throttle) { 8943 un->un_throttle = un->un_last_throttle; 8944 } 8945 if (status != TRAN_ACCEPT) 8946 ST_DO_ERRSTATS(un, st_transerrs); 8947 ST_DO_KSTATS(bp, kstat_waitq_exit); 8948 st_set_pe_flag(un); 8949 st_bioerror(bp, EIO); 8950 st_done_and_mutex_exit(un, bp); 8951 #endif 8952 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 8953 "busy restart aborted\n"); 8954 } 8955 8956 /* 8957 * st_check_media(): 8958 * Periodically check the media state using scsi_watch service; 8959 * this service calls back after TUR and possibly request sense 8960 * the callback handler (st_media_watch_cb()) decodes the request sense 8961 * data (if any) 8962 */ 8963 8964 static int 8965 st_check_media(dev_t dev, enum mtio_state state) 8966 { 8967 int rval = 0; 8968 enum mtio_state prev_state; 8969 opaque_t token = NULL; 8970 8971 GET_SOFT_STATE(dev); 8972 8973 ST_FUNC(ST_DEVINFO, st_check_media); 8974 8975 mutex_enter(ST_MUTEX); 8976 8977 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 8978 "st_check_media:state=%x, mediastate=%x\n", 8979 state, un->un_mediastate); 8980 8981 prev_state = un->un_mediastate; 8982 8983 /* 8984 * is there anything to do? 8985 */ 8986 retry: 8987 if (state == un->un_mediastate || un->un_mediastate == MTIO_NONE) { 8988 /* 8989 * submit the request to the scsi_watch service; 8990 * scsi_media_watch_cb() does the real work 8991 */ 8992 mutex_exit(ST_MUTEX); 8993 token = scsi_watch_request_submit(ST_SCSI_DEVP, 8994 st_check_media_time, SENSE_LENGTH, 8995 st_media_watch_cb, (caddr_t)dev); 8996 if (token == NULL) { 8997 rval = EAGAIN; 8998 goto done; 8999 } 9000 mutex_enter(ST_MUTEX); 9001 9002 un->un_swr_token = token; 9003 un->un_specified_mediastate = state; 9004 9005 /* 9006 * now wait for media change 9007 * we will not be signalled unless mediastate == state but it 9008 * still better to test for this condition, since there 9009 * is a 5 sec cv_broadcast delay when 9010 * mediastate == MTIO_INSERTED 9011 */ 9012 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9013 "st_check_media:waiting for media state change\n"); 9014 while (un->un_mediastate == state) { 9015 if (cv_wait_sig(&un->un_state_cv, ST_MUTEX) == 0) { 9016 mutex_exit(ST_MUTEX); 9017 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9018 "st_check_media:waiting for media state " 9019 "was interrupted\n"); 9020 rval = EINTR; 9021 goto done; 9022 } 9023 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9024 "st_check_media:received signal, state=%x\n", 9025 un->un_mediastate); 9026 } 9027 } 9028 9029 /* 9030 * if we transitioned to MTIO_INSERTED, media has really been 9031 * inserted. If TUR fails, it is probably a exabyte slow spin up. 9032 * Reset and retry the state change. If everything is ok, replay 9033 * the open() logic. 9034 */ 9035 if ((un->un_mediastate == MTIO_INSERTED) && 9036 (un->un_state == ST_STATE_OFFLINE)) { 9037 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9038 "st_check_media: calling st_cmd to confirm inserted\n"); 9039 9040 /* 9041 * set this early so that TUR will make it through strategy 9042 * without triggering a st_tape_init(). We needed it set 9043 * before calling st_tape_init() ourselves anyway. If TUR 9044 * fails, set it back 9045 */ 9046 un->un_state = ST_STATE_INITIALIZING; 9047 9048 /* 9049 * If not reserved fail as getting reservation conflict 9050 * will make this hang forever. 9051 */ 9052 if ((un->un_rsvd_status & 9053 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 9054 mutex_exit(ST_MUTEX); 9055 rval = EACCES; 9056 goto done; 9057 } 9058 rval = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 9059 if (rval == EACCES) { 9060 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9061 "st_check_media: TUR got Reservation Conflict\n"); 9062 mutex_exit(ST_MUTEX); 9063 goto done; 9064 } 9065 if (rval) { 9066 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9067 "st_check_media: TUR failed, going to retry\n"); 9068 un->un_mediastate = prev_state; 9069 un->un_state = ST_STATE_OFFLINE; 9070 goto retry; 9071 } 9072 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9073 "st_check_media: media inserted\n"); 9074 9075 /* this also rewinds the tape */ 9076 rval = st_tape_init(un); 9077 if (rval != 0) { 9078 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9079 "st_check_media : OFFLINE init failure "); 9080 un->un_state = ST_STATE_OFFLINE; 9081 un->un_pos.pmode = invalid; 9082 } else { 9083 un->un_state = ST_STATE_OPEN_PENDING_IO; 9084 } 9085 } else if ((un->un_mediastate == MTIO_EJECTED) && 9086 (un->un_state != ST_STATE_OFFLINE)) { 9087 /* 9088 * supported devices must be rewound before ejection 9089 * rewind resets fileno & blkno 9090 */ 9091 un->un_laststate = un->un_state; 9092 un->un_state = ST_STATE_OFFLINE; 9093 } 9094 mutex_exit(ST_MUTEX); 9095 done: 9096 if (token) { 9097 (void) scsi_watch_request_terminate(token, 9098 SCSI_WATCH_TERMINATE_WAIT); 9099 mutex_enter(ST_MUTEX); 9100 un->un_swr_token = (opaque_t)NULL; 9101 mutex_exit(ST_MUTEX); 9102 } 9103 9104 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_media: done\n"); 9105 9106 return (rval); 9107 } 9108 9109 /* 9110 * st_media_watch_cb() is called by scsi_watch_thread for 9111 * verifying the request sense data (if any) 9112 */ 9113 static int 9114 st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp) 9115 { 9116 struct scsi_status *statusp = resultp->statusp; 9117 struct scsi_extended_sense *sensep = resultp->sensep; 9118 uchar_t actual_sense_length = resultp->actual_sense_length; 9119 struct scsi_tape *un; 9120 enum mtio_state state = MTIO_NONE; 9121 int instance; 9122 dev_t dev = (dev_t)arg; 9123 9124 instance = MTUNIT(dev); 9125 if ((un = ddi_get_soft_state(st_state, instance)) == NULL) { 9126 return (-1); 9127 } 9128 9129 mutex_enter(ST_MUTEX); 9130 ST_FUNC(ST_DEVINFO, st_media_watch_cb); 9131 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9132 "st_media_watch_cb: status=%x, sensep=%p, len=%x\n", 9133 *((char *)statusp), (void *)sensep, 9134 actual_sense_length); 9135 9136 9137 /* 9138 * if there was a check condition then sensep points to valid 9139 * sense data 9140 * if status was not a check condition but a reservation or busy 9141 * status then the new state is MTIO_NONE 9142 */ 9143 if (sensep) { 9144 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9145 "st_media_watch_cb: KEY=%x, ASC=%x, ASCQ=%x\n", 9146 sensep->es_key, sensep->es_add_code, sensep->es_qual_code); 9147 9148 switch (un->un_dp->type) { 9149 default: 9150 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9151 "st_media_watch_cb: unknown drive type %d, " 9152 "default to ST_TYPE_HP\n", un->un_dp->type); 9153 /* FALLTHROUGH */ 9154 9155 case ST_TYPE_STC3490: /* STK 4220 1/2" cartridge */ 9156 case ST_TYPE_FUJI: /* 1/2" cartridge */ 9157 case ST_TYPE_HP: /* HP 88780 1/2" reel */ 9158 if (un->un_dp->type == ST_TYPE_FUJI) { 9159 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9160 "st_media_watch_cb: ST_TYPE_FUJI\n"); 9161 } else { 9162 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9163 "st_media_watch_cb: ST_TYPE_HP\n"); 9164 } 9165 switch (sensep->es_key) { 9166 case KEY_UNIT_ATTENTION: 9167 /* not ready to ready transition */ 9168 /* hp/es_qual_code == 80 on>off>on */ 9169 /* hp/es_qual_code == 0 on>off>unld>ld>on */ 9170 if (sensep->es_add_code == 0x28) { 9171 state = MTIO_INSERTED; 9172 } 9173 break; 9174 case KEY_NOT_READY: 9175 /* in process, rewinding or loading */ 9176 if ((sensep->es_add_code == 0x04) && 9177 (sensep->es_qual_code == 0x00)) { 9178 state = MTIO_EJECTED; 9179 } 9180 break; 9181 } 9182 break; 9183 9184 case ST_TYPE_EXB8500: /* Exabyte 8500 */ 9185 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9186 "st_media_watch_cb: ST_TYPE_EXB8500\n"); 9187 switch (sensep->es_key) { 9188 case KEY_UNIT_ATTENTION: 9189 /* operator medium removal request */ 9190 if ((sensep->es_add_code == 0x5a) && 9191 (sensep->es_qual_code == 0x01)) { 9192 state = MTIO_EJECTED; 9193 /* not ready to ready transition */ 9194 } else if ((sensep->es_add_code == 0x28) && 9195 (sensep->es_qual_code == 0x00)) { 9196 state = MTIO_INSERTED; 9197 } 9198 break; 9199 case KEY_NOT_READY: 9200 /* medium not present */ 9201 if (sensep->es_add_code == 0x3a) { 9202 state = MTIO_EJECTED; 9203 } 9204 break; 9205 } 9206 break; 9207 case ST_TYPE_EXABYTE: /* Exabyte 8200 */ 9208 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9209 "st_media_watch_cb: ST_TYPE_EXABYTE\n"); 9210 switch (sensep->es_key) { 9211 case KEY_NOT_READY: 9212 if ((sensep->es_add_code == 0x04) && 9213 (sensep->es_qual_code == 0x00)) { 9214 /* volume not mounted? */ 9215 state = MTIO_EJECTED; 9216 } else if (sensep->es_add_code == 0x3a) { 9217 state = MTIO_EJECTED; 9218 } 9219 break; 9220 case KEY_UNIT_ATTENTION: 9221 state = MTIO_EJECTED; 9222 break; 9223 } 9224 break; 9225 9226 case ST_TYPE_DLT: /* quantum DLT4xxx */ 9227 switch (sensep->es_key) { 9228 case KEY_UNIT_ATTENTION: 9229 if (sensep->es_add_code == 0x28) { 9230 state = MTIO_INSERTED; 9231 } 9232 break; 9233 case KEY_NOT_READY: 9234 if (sensep->es_add_code == 0x04) { 9235 /* in transition but could be either */ 9236 state = un->un_specified_mediastate; 9237 } else if ((sensep->es_add_code == 0x3a) && 9238 (sensep->es_qual_code == 0x00)) { 9239 state = MTIO_EJECTED; 9240 } 9241 break; 9242 } 9243 break; 9244 } 9245 } else if (*((char *)statusp) == STATUS_GOOD) { 9246 state = MTIO_INSERTED; 9247 } 9248 9249 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9250 "st_media_watch_cb:state=%x, specified=%x\n", 9251 state, un->un_specified_mediastate); 9252 9253 /* 9254 * now signal the waiting thread if this is *not* the specified state; 9255 * delay the signal if the state is MTIO_INSERTED 9256 * to allow the target to recover 9257 */ 9258 if (state != un->un_specified_mediastate) { 9259 un->un_mediastate = state; 9260 if (state == MTIO_INSERTED) { 9261 /* 9262 * delay the signal to give the drive a chance 9263 * to do what it apparently needs to do 9264 */ 9265 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9266 "st_media_watch_cb:delayed cv_broadcast\n"); 9267 un->un_delay_tid = timeout(st_delayed_cv_broadcast, 9268 un, drv_usectohz((clock_t)MEDIA_ACCESS_DELAY)); 9269 } else { 9270 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9271 "st_media_watch_cb:immediate cv_broadcast\n"); 9272 cv_broadcast(&un->un_state_cv); 9273 } 9274 } 9275 mutex_exit(ST_MUTEX); 9276 return (0); 9277 } 9278 9279 /* 9280 * delayed cv_broadcast to allow for target to recover 9281 * from media insertion 9282 */ 9283 static void 9284 st_delayed_cv_broadcast(void *arg) 9285 { 9286 struct scsi_tape *un = arg; 9287 9288 ST_FUNC(ST_DEVINFO, st_delayed_cv_broadcast); 9289 9290 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9291 "st_delayed_cv_broadcast:delayed cv_broadcast\n"); 9292 9293 mutex_enter(ST_MUTEX); 9294 cv_broadcast(&un->un_state_cv); 9295 mutex_exit(ST_MUTEX); 9296 } 9297 9298 /* 9299 * restart cmd currently at the start of the waitq 9300 */ 9301 static void 9302 st_start_restart(void *arg) 9303 { 9304 struct scsi_tape *un = arg; 9305 9306 ST_FUNC(ST_DEVINFO, st_start_restart); 9307 9308 ASSERT(un != NULL); 9309 9310 mutex_enter(ST_MUTEX); 9311 9312 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_tran_restart()\n"); 9313 9314 st_start(un); 9315 9316 mutex_exit(ST_MUTEX); 9317 } 9318 9319 9320 /* 9321 * Command completion processing 9322 * 9323 */ 9324 static void 9325 st_intr(struct scsi_pkt *pkt) 9326 { 9327 recov_info *rcv = pkt->pkt_private; 9328 struct buf *bp = rcv->cmd_bp; 9329 struct scsi_tape *un; 9330 errstate action = COMMAND_DONE; 9331 clock_t timout; 9332 int status; 9333 9334 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 9335 9336 ST_FUNC(ST_DEVINFO, st_intr); 9337 9338 ASSERT(un != NULL); 9339 9340 mutex_enter(ST_MUTEX); 9341 9342 ASSERT(bp != un->un_recov_buf); 9343 9344 if (pkt == un->un_rqs) { 9345 scsi_sync_pkt(pkt); 9346 } 9347 9348 un->un_rqs_state &= ~(ST_RQS_ERROR); 9349 9350 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_intr()\n"); 9351 9352 if (pkt->pkt_reason != CMD_CMPLT) { 9353 ST_DEBUG(ST_DEVINFO, st_label, CE_WARN, 9354 "Unhappy packet status reason = %s statistics = 0x%x\n", 9355 scsi_rname(pkt->pkt_reason), pkt->pkt_statistics); 9356 9357 /* If device has gone away not much else to do */ 9358 if (pkt->pkt_reason == CMD_DEV_GONE) { 9359 action = COMMAND_DONE_ERROR; 9360 } else if ((pkt == un->un_rqs) || 9361 (un->un_state == ST_STATE_SENSING)) { 9362 ASSERT(pkt == un->un_rqs); 9363 ASSERT(un->un_state == ST_STATE_SENSING); 9364 un->un_state = un->un_laststate; 9365 ((recov_info *)un->un_rqs->pkt_private)->cmd_bp = 9366 un->un_rqs_bp; 9367 ST_DO_ERRSTATS(un, st_transerrs); 9368 action = COMMAND_DONE_ERROR; 9369 } else { 9370 action = st_handle_incomplete(un, bp); 9371 } 9372 /* 9373 * At this point we know that the command was successfully 9374 * completed. Now what? 9375 */ 9376 } else if ((pkt == un->un_rqs) || (un->un_state == ST_STATE_SENSING)) { 9377 /* 9378 * okay. We were running a REQUEST SENSE. Find 9379 * out what to do next. 9380 */ 9381 ASSERT(pkt == un->un_rqs); 9382 ASSERT(un->un_state == ST_STATE_SENSING); 9383 action = st_handle_sense(un, bp, &un->un_pos); 9384 /* 9385 * Make rqs isn't going to be retied. 9386 */ 9387 if (action != QUE_BUSY_COMMAND && action != QUE_COMMAND) { 9388 /* 9389 * set pkt back to original packet in case we will have 9390 * to requeue it 9391 */ 9392 pkt = BP_PKT(bp); 9393 ((recov_info *)un->un_rqs->pkt_private)->cmd_bp = 9394 un->un_rqs_bp; 9395 /* 9396 * some actions are based on un_state, hence 9397 * restore the state st was in before ST_STATE_SENSING. 9398 */ 9399 un->un_state = un->un_laststate; 9400 } 9401 9402 } else if (un->un_arq_enabled && (pkt->pkt_state & STATE_ARQ_DONE)) { 9403 /* 9404 * the transport layer successfully completed an autorqsense 9405 */ 9406 action = st_handle_autosense(un, bp, &un->un_pos); 9407 9408 } else if ((SCBP(pkt)->sts_busy) || (SCBP(pkt)->sts_chk)) { 9409 /* 9410 * Okay, we weren't running a REQUEST SENSE. Call a routine 9411 * to see if the status bits we're okay. If a request sense 9412 * is to be run, that will happen. 9413 */ 9414 action = st_check_error(un, pkt); 9415 } 9416 9417 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 9418 switch (action) { 9419 case QUE_COMMAND: 9420 /* 9421 * return cmd to head to the queue 9422 * since we are suspending so that 9423 * it gets restarted during resume 9424 */ 9425 st_add_to_queue(&un->un_runqf, &un->un_runql, 9426 un->un_runqf, bp); 9427 9428 action = JUST_RETURN; 9429 break; 9430 9431 case QUE_SENSE: 9432 action = COMMAND_DONE_ERROR; 9433 break; 9434 9435 default: 9436 break; 9437 } 9438 } 9439 9440 /* 9441 * Restore old state if we were sensing. 9442 */ 9443 if (un->un_state == ST_STATE_SENSING && action != QUE_SENSE) { 9444 un->un_state = un->un_laststate; 9445 } 9446 9447 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 9448 "st_intr: pkt=%p, bp=%p, action=%x, status=%x\n", 9449 (void *)pkt, (void *)bp, action, SCBP_C(pkt)); 9450 9451 again: 9452 switch (action) { 9453 case COMMAND_DONE_EACCES: 9454 /* this is to report a reservation conflict */ 9455 st_bioerror(bp, EACCES); 9456 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 9457 "Reservation Conflict \n"); 9458 un->un_pos.pmode = invalid; 9459 9460 /*FALLTHROUGH*/ 9461 case COMMAND_DONE_ERROR: 9462 if (un->un_pos.eof < ST_EOT_PENDING && 9463 un->un_state >= ST_STATE_OPEN) { 9464 /* 9465 * all errors set state of the tape to 'unknown' 9466 * unless we're at EOT or are doing append testing. 9467 * If sense key was illegal request, preserve state. 9468 */ 9469 if (un->un_status != KEY_ILLEGAL_REQUEST) { 9470 un->un_pos.pmode = invalid; 9471 } 9472 } 9473 9474 un->un_err_resid = bp->b_resid = bp->b_bcount; 9475 /* 9476 * since we have an error (COMMAND_DONE_ERROR), we want to 9477 * make sure an error ocurrs, so make sure at least EIO is 9478 * returned 9479 */ 9480 if (geterror(bp) == 0) 9481 st_bioerror(bp, EIO); 9482 9483 st_set_pe_flag(un); 9484 if (!(un->un_rqs_state & ST_RQS_ERROR) && 9485 (un->un_errno == EIO)) { 9486 un->un_rqs_state &= ~(ST_RQS_VALID); 9487 } 9488 break; 9489 9490 case COMMAND_DONE_ERROR_RECOVERED: 9491 un->un_err_resid = bp->b_resid = bp->b_bcount; 9492 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 9493 "st_intr(): COMMAND_DONE_ERROR_RECOVERED"); 9494 if (geterror(bp) == 0) { 9495 st_bioerror(bp, EIO); 9496 } 9497 st_set_pe_flag(un); 9498 if (!(un->un_rqs_state & ST_RQS_ERROR) && 9499 (un->un_errno == EIO)) { 9500 un->un_rqs_state &= ~(ST_RQS_VALID); 9501 } 9502 /*FALLTHROUGH*/ 9503 case COMMAND_DONE: 9504 st_set_state(un, bp); 9505 break; 9506 9507 case QUE_SENSE: 9508 if ((un->un_ncmds > 1) && !un->un_flush_on_errors) 9509 goto sense_error; 9510 9511 if (un->un_state != ST_STATE_SENSING) { 9512 un->un_laststate = un->un_state; 9513 un->un_state = ST_STATE_SENSING; 9514 } 9515 9516 /* Whats going to happen here? */ 9517 9518 ((recov_info *)un->un_rqs->pkt_private)->cmd_bp = bp; 9519 9520 bzero(ST_RQSENSE, SENSE_LENGTH); 9521 9522 scsi_sync_pkt(un->un_rqs); /* HELLO */ 9523 9524 if (un->un_throttle) { 9525 un->un_last_throttle = un->un_throttle; 9526 un->un_throttle = 0; 9527 } 9528 9529 ST_CDB(ST_DEVINFO, "Queue sense CDB", 9530 (char *)BP_PKT(bp)->pkt_cdbp); 9531 9532 /* 9533 * never retry this, some other command will have nuked the 9534 * sense, anyway 9535 */ 9536 status = st_transport(un, un->un_rqs); 9537 9538 if (un->un_last_throttle) { 9539 un->un_throttle = un->un_last_throttle; 9540 } 9541 9542 if (status == TRAN_ACCEPT) { 9543 mutex_exit(ST_MUTEX); 9544 return; 9545 } 9546 if (status != TRAN_BUSY) 9547 ST_DO_ERRSTATS(un, st_transerrs); 9548 sense_error: 9549 un->un_pos.pmode = invalid; 9550 st_bioerror(bp, EIO); 9551 st_set_pe_flag(un); 9552 break; 9553 9554 case QUE_BUSY_COMMAND: 9555 /* longish timeout */ 9556 timout = ST_STATUS_BUSY_TIMEOUT; 9557 goto que_it_up; 9558 9559 case QUE_COMMAND: 9560 /* short timeout */ 9561 timout = ST_TRAN_BUSY_TIMEOUT; 9562 que_it_up: 9563 /* 9564 * let st_handle_intr_busy put this bp back on waitq and make 9565 * checks to see if it is ok to requeue the command. 9566 */ 9567 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 9568 9569 /* 9570 * Save the throttle before setting up the timeout 9571 */ 9572 if (un->un_throttle) { 9573 un->un_last_throttle = un->un_throttle; 9574 } 9575 mutex_exit(ST_MUTEX); 9576 if (st_handle_intr_busy(un, bp, timout) == 0) 9577 return; /* timeout is setup again */ 9578 9579 mutex_enter(ST_MUTEX); 9580 un->un_pos.pmode = invalid; 9581 un->un_err_resid = bp->b_resid = bp->b_bcount; 9582 st_bioerror(bp, EIO); 9583 st_set_pe_flag(un); 9584 break; 9585 9586 case QUE_LAST_COMMAND: 9587 9588 if ((un->un_ncmds > 1) && !un->un_flush_on_errors) { 9589 scsi_log(ST_DEVINFO, st_label, CE_CONT, 9590 "un_ncmds: %d can't retry cmd \n", un->un_ncmds); 9591 goto last_command_error; 9592 } 9593 mutex_exit(ST_MUTEX); 9594 if (st_handle_intr_retry_lcmd(un, bp) == 0) 9595 return; 9596 mutex_enter(ST_MUTEX); 9597 last_command_error: 9598 un->un_err_resid = bp->b_resid = bp->b_bcount; 9599 un->un_pos.pmode = invalid; 9600 st_bioerror(bp, EIO); 9601 st_set_pe_flag(un); 9602 break; 9603 9604 case COMMAND_TIMEOUT: 9605 case DEVICE_RESET: 9606 case DEVICE_TAMPER: 9607 case ATTEMPT_RETRY: 9608 action = st_command_recovery(un, pkt, action); 9609 goto again; 9610 9611 default: 9612 ASSERT(0); 9613 /* FALLTHRU */ 9614 case JUST_RETURN: 9615 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 9616 mutex_exit(ST_MUTEX); 9617 return; 9618 } 9619 9620 ST_DO_KSTATS(bp, kstat_runq_exit); 9621 st_done_and_mutex_exit(un, bp); 9622 } 9623 9624 static errstate 9625 st_handle_incomplete(struct scsi_tape *un, struct buf *bp) 9626 { 9627 static char *fail = "SCSI transport failed: reason '%s': %s\n"; 9628 recov_info *rinfo; 9629 errstate rval = COMMAND_DONE_ERROR; 9630 struct scsi_pkt *pkt = (un->un_state == ST_STATE_SENSING) ? 9631 un->un_rqs : BP_PKT(bp); 9632 int result; 9633 9634 ST_FUNC(ST_DEVINFO, st_handle_incomplete); 9635 9636 rinfo = (recov_info *)pkt->pkt_private; 9637 9638 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9639 "st_handle_incomplete(): dev = 0x%lx\n", un->un_dev); 9640 9641 ASSERT(mutex_owned(ST_MUTEX)); 9642 9643 switch (pkt->pkt_reason) { 9644 case CMD_INCOMPLETE: /* tran stopped with not normal state */ 9645 /* 9646 * this occurs when accessing a powered down drive, no 9647 * need to complain; just fail the open 9648 */ 9649 ST_CDB(ST_DEVINFO, "Incomplete CDB", (char *)pkt->pkt_cdbp); 9650 9651 /* 9652 * if we have commands outstanding in HBA, and a command 9653 * comes back incomplete, we're hosed, so reset target 9654 * If we have the bus, but cmd_incomplete, we probably just 9655 * have a failed selection, so don't reset the target, just 9656 * requeue the command and try again 9657 */ 9658 if ((un->un_ncmds > 1) || (pkt->pkt_state != STATE_GOT_BUS)) { 9659 goto reset_target; 9660 } 9661 9662 /* 9663 * Retry selection a couple more times if we're 9664 * open. If opening, we only try just once to 9665 * reduce probe time for nonexistant devices. 9666 */ 9667 if ((un->un_laststate > ST_STATE_OPENING) && 9668 ((int)un->un_retry_ct < st_selection_retry_count)) { 9669 /* XXX check retriable? */ 9670 rval = QUE_COMMAND; 9671 } 9672 ST_DO_ERRSTATS(un, st_transerrs); 9673 break; 9674 9675 case CMD_ABORTED: 9676 /* 9677 * most likely this is caused by flush-on-error support. If 9678 * it was not there, the we're in trouble. 9679 */ 9680 if (!un->un_flush_on_errors) { 9681 un->un_status = SUN_KEY_FATAL; 9682 goto reset_target; 9683 } 9684 9685 st_set_pe_errno(un); 9686 bioerror(bp, un->un_errno); 9687 if (un->un_errno) 9688 return (COMMAND_DONE_ERROR); 9689 else 9690 return (COMMAND_DONE); 9691 9692 case CMD_TIMEOUT: /* Command timed out */ 9693 un->un_status = SUN_KEY_TIMEOUT; 9694 return (COMMAND_TIMEOUT); 9695 9696 case CMD_TRAN_ERR: 9697 case CMD_RESET: 9698 if (pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET)) { 9699 if ((un->un_rsvd_status & 9700 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 9701 ST_RESERVE) { 9702 un->un_rsvd_status |= ST_LOST_RESERVE; 9703 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 9704 "Lost Reservation\n"); 9705 } 9706 rval = DEVICE_RESET; 9707 return (rval); 9708 } 9709 if (pkt->pkt_statistics & (STAT_ABORTED | STAT_TERMINATED)) { 9710 rval = DEVICE_RESET; 9711 return (rval); 9712 } 9713 /*FALLTHROUGH*/ 9714 default: 9715 scsi_log(ST_DEVINFO, st_label, CE_WARN, 9716 "Unhandled packet status reason = %s statistics = 0x%x\n", 9717 scsi_rname(pkt->pkt_reason), pkt->pkt_statistics); 9718 reset_target: 9719 9720 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 9721 "transport completed with %s\n", 9722 scsi_rname(pkt->pkt_reason)); 9723 ST_DO_ERRSTATS(un, st_transerrs); 9724 if ((pkt->pkt_state & STATE_GOT_TARGET) && 9725 ((pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET | 9726 STAT_ABORTED)) == 0)) { 9727 9728 /* 9729 * If we haven't reserved the drive don't reset it. 9730 */ 9731 if ((un->un_rsvd_status & 9732 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 9733 return (rval); 9734 } 9735 9736 /* 9737 * if we aren't lost yet we will be soon. 9738 */ 9739 un->un_pos.pmode = invalid; 9740 9741 result = st_reset(un, RESET_LUN); 9742 9743 if ((result == 0) && (un->un_state >= ST_STATE_OPEN)) { 9744 /* no hope left to recover */ 9745 scsi_log(ST_DEVINFO, st_label, CE_WARN, 9746 "recovery by resets failed\n"); 9747 return (rval); 9748 } 9749 } 9750 } 9751 9752 9753 if ((int)un->un_retry_ct++ < st_retry_count) { 9754 if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) { 9755 rval = QUE_COMMAND; 9756 } else if (bp == un->un_sbufp) { 9757 if (rinfo->privatelen == sizeof (recov_info)) { 9758 if (rinfo->cmd_attrib->retriable) { 9759 /* 9760 * These commands can be rerun 9761 * with impunity 9762 */ 9763 rval = QUE_COMMAND; 9764 } 9765 } else { 9766 cmd_attribute const *attrib; 9767 attrib = 9768 st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 9769 if (attrib->retriable) { 9770 rval = QUE_COMMAND; 9771 } 9772 } 9773 } 9774 } else { 9775 rval = COMMAND_DONE_ERROR; 9776 } 9777 9778 if (un->un_state >= ST_STATE_OPEN) { 9779 scsi_log(ST_DEVINFO, st_label, CE_WARN, 9780 fail, scsi_rname(pkt->pkt_reason), 9781 (rval == COMMAND_DONE_ERROR)? 9782 "giving up" : "retrying command"); 9783 } 9784 return (rval); 9785 } 9786 9787 /* 9788 * if the device is busy, then put this bp back on the waitq, on the 9789 * interrupt thread, where we want the head of the queue and not the 9790 * end 9791 * 9792 * The callers of this routine should take measures to save the 9793 * un_throttle in un_last_throttle which will be restored in 9794 * st_intr_restart(). The only exception should be st_intr_restart() 9795 * calling this routine for which the saving is already done. 9796 */ 9797 static int 9798 st_handle_intr_busy(struct scsi_tape *un, struct buf *bp, 9799 clock_t timeout_interval) 9800 { 9801 9802 int queued; 9803 int rval = 0; 9804 9805 mutex_enter(ST_MUTEX); 9806 9807 ST_FUNC(ST_DEVINFO, st_handle_intr_busy); 9808 9809 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9810 "st_handle_intr_busy(), un = 0x%p\n", (void *)un); 9811 9812 if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) { 9813 queued = 1; 9814 } else { 9815 queued = 0; 9816 } 9817 9818 /* 9819 * Check to see if we hit the retry timeout. We check to make sure 9820 * this is the first one on the runq and make sure we have not 9821 * queued up any more, so this one has to be the last on the list 9822 * also. If it is not, we have to fail. If it is not the first, but 9823 * is the last we are in trouble anyway, as we are in the interrupt 9824 * context here. 9825 */ 9826 if (((int)un->un_tran_retry_ct++ > st_retry_count) || 9827 ((un->un_runqf != bp) && (un->un_runql != bp) && (queued))) { 9828 rval = -1; 9829 goto exit; 9830 } 9831 9832 /* put the bp back on the waitq */ 9833 if (queued) { 9834 (void) st_remove_from_queue(&un->un_runqf, &un->un_runql, bp); 9835 st_add_to_queue(&un->un_quef, &un->un_quel, un->un_quef, bp); 9836 } 9837 9838 /* 9839 * We don't want any other commands being started in the mean time. 9840 * If start had just released mutex after putting something on the 9841 * runq, we won't even get here. 9842 */ 9843 un->un_throttle = 0; 9844 9845 /* 9846 * send a marker pkt, if appropriate 9847 */ 9848 st_hba_unflush(un); 9849 9850 /* 9851 * all queues are aligned, we are just waiting to 9852 * transport 9853 */ 9854 un->un_hib_tid = timeout(st_intr_restart, un, timeout_interval); 9855 9856 exit: 9857 mutex_exit(ST_MUTEX); 9858 return (rval); 9859 } 9860 9861 /* 9862 * To get one error entry from error stack 9863 */ 9864 static int 9865 st_get_error_entry(struct scsi_tape *un, intptr_t arg, int flag) 9866 { 9867 #ifdef _MULTI_DATAMODEL 9868 /* 9869 * For use when a 32 bit app makes a call into a 9870 * 64 bit ioctl 9871 */ 9872 struct mterror_entry32 err_entry32; 9873 #endif /* _MULTI_DATAMODEL */ 9874 9875 int rval = 0; 9876 struct mterror_entry err_entry; 9877 struct mterror_entry_stack *err_link_entry_p; 9878 size_t arq_status_len_in, arq_status_len_kr; 9879 9880 ST_FUNC(ST_DEVINFO, st_get_error_entry); 9881 9882 ASSERT(mutex_owned(ST_MUTEX)); 9883 9884 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 9885 "st_get_error_entry()\n"); 9886 9887 /* 9888 * if error record stack empty, return ENXIO 9889 */ 9890 if (un->un_error_entry_stk == NULL) { 9891 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9892 "st_get_error_entry: Error Entry Stack Empty!\n"); 9893 rval = ENXIO; 9894 goto ret; 9895 } 9896 9897 /* 9898 * get the top entry from stack 9899 */ 9900 err_link_entry_p = un->un_error_entry_stk; 9901 arq_status_len_kr = 9902 err_link_entry_p->mtees_entry.mtee_arq_status_len; 9903 9904 #ifdef _MULTI_DATAMODEL 9905 switch (ddi_model_convert_from(flag & FMODELS)) { 9906 case DDI_MODEL_ILP32: 9907 if (ddi_copyin((void *)arg, &err_entry32, 9908 MTERROR_ENTRY_SIZE_32, flag)) { 9909 rval = EFAULT; 9910 goto ret; 9911 } 9912 9913 arq_status_len_in = 9914 (size_t)err_entry32.mtee_arq_status_len; 9915 9916 err_entry32.mtee_cdb_len = 9917 (size32_t)err_link_entry_p->mtees_entry.mtee_cdb_len; 9918 9919 if (arq_status_len_in > arq_status_len_kr) 9920 err_entry32.mtee_arq_status_len = 9921 (size32_t)arq_status_len_kr; 9922 9923 if (ddi_copyout( 9924 err_link_entry_p->mtees_entry.mtee_cdb_buf, 9925 (void *)(uintptr_t)err_entry32.mtee_cdb_buf, 9926 err_entry32.mtee_cdb_len, flag)) { 9927 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9928 "st_get_error_entry: Copy cdb buffer error!"); 9929 rval = EFAULT; 9930 } 9931 9932 if (ddi_copyout( 9933 err_link_entry_p->mtees_entry.mtee_arq_status, 9934 (void *)(uintptr_t)err_entry32.mtee_arq_status, 9935 err_entry32.mtee_arq_status_len, flag)) { 9936 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9937 "st_get_error_entry: copy arq status error!"); 9938 rval = EFAULT; 9939 } 9940 9941 if (ddi_copyout(&err_entry32, (void *)arg, 9942 MTERROR_ENTRY_SIZE_32, flag)) { 9943 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9944 "st_get_error_entry: copy arq status out error!"); 9945 rval = EFAULT; 9946 } 9947 break; 9948 9949 case DDI_MODEL_NONE: 9950 if (ddi_copyin((void *)arg, &err_entry, 9951 MTERROR_ENTRY_SIZE_64, flag)) { 9952 rval = EFAULT; 9953 goto ret; 9954 } 9955 arq_status_len_in = err_entry.mtee_arq_status_len; 9956 9957 err_entry.mtee_cdb_len = 9958 err_link_entry_p->mtees_entry.mtee_cdb_len; 9959 9960 if (arq_status_len_in > arq_status_len_kr) 9961 err_entry.mtee_arq_status_len = 9962 arq_status_len_kr; 9963 9964 if (ddi_copyout( 9965 err_link_entry_p->mtees_entry.mtee_cdb_buf, 9966 err_entry.mtee_cdb_buf, 9967 err_entry.mtee_cdb_len, flag)) { 9968 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9969 "st_get_error_entry: Copy cdb buffer error!"); 9970 rval = EFAULT; 9971 } 9972 9973 if (ddi_copyout( 9974 err_link_entry_p->mtees_entry.mtee_arq_status, 9975 err_entry.mtee_arq_status, 9976 err_entry.mtee_arq_status_len, flag)) { 9977 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9978 "st_get_error_entry: copy arq status error!"); 9979 rval = EFAULT; 9980 } 9981 9982 if (ddi_copyout(&err_entry, (void *)arg, 9983 MTERROR_ENTRY_SIZE_64, flag)) { 9984 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 9985 "st_get_error_entry: copy arq status out error!"); 9986 rval = EFAULT; 9987 } 9988 break; 9989 } 9990 #else /* _MULTI_DATAMODEL */ 9991 if (ddi_copyin((void *)arg, &err_entry, 9992 MTERROR_ENTRY_SIZE_64, flag)) { 9993 rval = EFAULT; 9994 goto ret; 9995 } 9996 arq_status_len_in = err_entry.mtee_arq_status_len; 9997 9998 err_entry.mtee_cdb_len = 9999 err_link_entry_p->mtees_entry.mtee_cdb_len; 10000 10001 if (arq_status_len_in > arq_status_len_kr) 10002 err_entry.mtee_arq_status_len = 10003 arq_status_len_kr; 10004 10005 if (ddi_copyout( 10006 err_link_entry_p->mtees_entry.mtee_cdb_buf, 10007 err_entry.mtee_cdb_buf, 10008 err_entry.mtee_cdb_len, flag)) { 10009 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10010 "st_get_error_entry: Copy cdb buffer error!"); 10011 rval = EFAULT; 10012 } 10013 10014 if (ddi_copyout( 10015 err_link_entry_p->mtees_entry.mtee_arq_status, 10016 err_entry.mtee_arq_status, 10017 err_entry.mtee_arq_status_len, flag)) { 10018 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10019 "st_get_error_entry: copy arq status buffer error!"); 10020 rval = EFAULT; 10021 } 10022 10023 if (ddi_copyout(&err_entry, (void *)arg, 10024 MTERROR_ENTRY_SIZE_64, flag)) { 10025 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10026 "st_get_error_entry: copy arq status out error!"); 10027 rval = EFAULT; 10028 } 10029 #endif /* _MULTI_DATAMODEL */ 10030 10031 /* 10032 * update stack 10033 */ 10034 un->un_error_entry_stk = err_link_entry_p->mtees_nextp; 10035 10036 kmem_free(err_link_entry_p->mtees_entry.mtee_cdb_buf, 10037 err_link_entry_p->mtees_entry.mtee_cdb_len); 10038 err_link_entry_p->mtees_entry.mtee_cdb_buf = NULL; 10039 10040 kmem_free(err_link_entry_p->mtees_entry.mtee_arq_status, 10041 SECMDS_STATUS_SIZE); 10042 err_link_entry_p->mtees_entry.mtee_arq_status = NULL; 10043 10044 kmem_free(err_link_entry_p, MTERROR_LINK_ENTRY_SIZE); 10045 err_link_entry_p = NULL; 10046 ret: 10047 return (rval); 10048 } 10049 10050 /* 10051 * MTIOCGETERROR ioctl needs to retrieve the current sense data along with 10052 * the scsi CDB command which causes the error and generates sense data and 10053 * the scsi status. 10054 * 10055 * error-record stack 10056 * 10057 * 10058 * TOP BOTTOM 10059 * ------------------------------------------ 10060 * | 0 | 1 | 2 | ... | n | 10061 * ------------------------------------------ 10062 * ^ 10063 * | 10064 * pointer to error entry 10065 * 10066 * when st driver generates one sense data record, it creates a error-entry 10067 * and pushes it onto the stack. 10068 * 10069 */ 10070 10071 static void 10072 st_update_error_stack(struct scsi_tape *un, 10073 struct scsi_pkt *pkt, 10074 struct scsi_arq_status *cmd) 10075 { 10076 struct mterror_entry_stack *err_entry_tmp; 10077 uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp; 10078 size_t cdblen = scsi_cdb_size[CDB_GROUPID(cdbp[0])]; 10079 10080 ST_FUNC(ST_DEVINFO, st_update_error_stack); 10081 10082 ASSERT(mutex_owned(ST_MUTEX)); 10083 10084 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10085 "st_update_error_stack()\n"); 10086 10087 ASSERT(cmd); 10088 ASSERT(cdbp); 10089 if (cdblen == 0) { 10090 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10091 "st_update_error_stack: CDB length error!\n"); 10092 return; 10093 } 10094 10095 err_entry_tmp = kmem_alloc(MTERROR_LINK_ENTRY_SIZE, KM_SLEEP); 10096 ASSERT(err_entry_tmp != NULL); 10097 10098 err_entry_tmp->mtees_entry.mtee_cdb_buf = 10099 kmem_alloc(cdblen, KM_SLEEP); 10100 ASSERT(err_entry_tmp->mtees_entry.mtee_cdb_buf != NULL); 10101 10102 err_entry_tmp->mtees_entry.mtee_arq_status = 10103 kmem_alloc(SECMDS_STATUS_SIZE, KM_SLEEP); 10104 ASSERT(err_entry_tmp->mtees_entry.mtee_arq_status != NULL); 10105 10106 /* 10107 * copy cdb command & length to current error entry 10108 */ 10109 err_entry_tmp->mtees_entry.mtee_cdb_len = cdblen; 10110 bcopy(cdbp, err_entry_tmp->mtees_entry.mtee_cdb_buf, cdblen); 10111 10112 /* 10113 * copy scsi status length to current error entry 10114 */ 10115 err_entry_tmp->mtees_entry.mtee_arq_status_len = 10116 SECMDS_STATUS_SIZE; 10117 10118 /* 10119 * copy sense data and scsi status to current error entry 10120 */ 10121 bcopy(cmd, err_entry_tmp->mtees_entry.mtee_arq_status, 10122 SECMDS_STATUS_SIZE); 10123 10124 err_entry_tmp->mtees_nextp = un->un_error_entry_stk; 10125 un->un_error_entry_stk = err_entry_tmp; 10126 10127 } 10128 10129 /* 10130 * Empty all the error entry in stack 10131 */ 10132 static void 10133 st_empty_error_stack(struct scsi_tape *un) 10134 { 10135 struct mterror_entry_stack *linkp; 10136 10137 ST_FUNC(ST_DEVINFO, st_empty_error_stack); 10138 10139 ASSERT(mutex_owned(ST_MUTEX)); 10140 10141 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10142 "st_empty_entry_stack()\n"); 10143 10144 while (un->un_error_entry_stk != NULL) { 10145 linkp = un->un_error_entry_stk; 10146 un->un_error_entry_stk = 10147 un->un_error_entry_stk->mtees_nextp; 10148 10149 if (linkp->mtees_entry.mtee_cdb_buf != NULL) 10150 kmem_free(linkp->mtees_entry.mtee_cdb_buf, 10151 linkp->mtees_entry.mtee_cdb_len); 10152 10153 if (linkp->mtees_entry.mtee_arq_status != NULL) 10154 kmem_free(linkp->mtees_entry.mtee_arq_status, 10155 linkp->mtees_entry.mtee_arq_status_len); 10156 10157 kmem_free(linkp, MTERROR_LINK_ENTRY_SIZE); 10158 linkp = NULL; 10159 } 10160 } 10161 10162 static errstate 10163 st_handle_sense(struct scsi_tape *un, struct buf *bp, tapepos_t *pos) 10164 { 10165 struct scsi_pkt *pkt = BP_PKT(bp); 10166 struct scsi_pkt *rqpkt = un->un_rqs; 10167 struct scsi_arq_status arqstat; 10168 10169 errstate rval = COMMAND_DONE_ERROR; 10170 int amt; 10171 10172 ST_FUNC(ST_DEVINFO, st_handle_sense); 10173 10174 ASSERT(mutex_owned(ST_MUTEX)); 10175 10176 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10177 "st_handle_sense()\n"); 10178 10179 if (SCBP(rqpkt)->sts_busy) { 10180 ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN, 10181 "busy unit on request sense\n"); 10182 if ((int)un->un_retry_ct++ < st_retry_count) { 10183 rval = QUE_BUSY_COMMAND; 10184 } 10185 return (rval); 10186 } else if (SCBP(rqpkt)->sts_chk) { 10187 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10188 "Check Condition on REQUEST SENSE\n"); 10189 return (rval); 10190 } 10191 10192 /* was there enough data? */ 10193 amt = (int)MAX_SENSE_LENGTH - rqpkt->pkt_resid; 10194 if ((rqpkt->pkt_state & STATE_XFERRED_DATA) == 0 || 10195 (amt < SUN_MIN_SENSE_LENGTH)) { 10196 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10197 "REQUEST SENSE couldn't get sense data\n"); 10198 return (rval); 10199 } 10200 10201 bcopy(SCBP(pkt), &arqstat.sts_status, 10202 sizeof (struct scsi_status)); 10203 bcopy(SCBP(rqpkt), &arqstat.sts_rqpkt_status, 10204 sizeof (struct scsi_status)); 10205 arqstat.sts_rqpkt_reason = rqpkt->pkt_reason; 10206 arqstat.sts_rqpkt_resid = rqpkt->pkt_resid; 10207 arqstat.sts_rqpkt_state = rqpkt->pkt_state; 10208 arqstat.sts_rqpkt_statistics = rqpkt->pkt_statistics; 10209 bcopy(ST_RQSENSE, &arqstat.sts_sensedata, SENSE_LENGTH); 10210 10211 /* 10212 * copy one arqstat entry in the sense data buffer 10213 */ 10214 st_update_error_stack(un, pkt, &arqstat); 10215 return (st_decode_sense(un, bp, amt, SCBP(rqpkt), pos)); 10216 } 10217 10218 static errstate 10219 st_handle_autosense(struct scsi_tape *un, struct buf *bp, tapepos_t *pos) 10220 { 10221 struct scsi_pkt *pkt = BP_PKT(bp); 10222 struct scsi_arq_status *arqstat = 10223 (struct scsi_arq_status *)pkt->pkt_scbp; 10224 errstate rval = COMMAND_DONE_ERROR; 10225 int amt; 10226 10227 ST_FUNC(ST_DEVINFO, st_handle_autosense); 10228 10229 ASSERT(mutex_owned(ST_MUTEX)); 10230 10231 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10232 "st_handle_autosense()\n"); 10233 10234 if (arqstat->sts_rqpkt_status.sts_busy) { 10235 ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN, 10236 "busy unit on request sense\n"); 10237 /* 10238 * we return QUE_SENSE so st_intr will setup the SENSE cmd. 10239 * the disadvantage is that we do not have any delay for the 10240 * second retry of rqsense and we have to keep a packet around 10241 */ 10242 return (QUE_SENSE); 10243 10244 } else if (arqstat->sts_rqpkt_reason != CMD_CMPLT) { 10245 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10246 "transport error on REQUEST SENSE\n"); 10247 if ((arqstat->sts_rqpkt_state & STATE_GOT_TARGET) && 10248 ((arqstat->sts_rqpkt_statistics & 10249 (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) == 0)) { 10250 if (st_reset(un, RESET_LUN) == 0) { 10251 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10252 "recovery by resets failed\n"); 10253 } 10254 } 10255 return (rval); 10256 10257 } else if (arqstat->sts_rqpkt_status.sts_chk) { 10258 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10259 "Check Condition on REQUEST SENSE\n"); 10260 return (rval); 10261 } 10262 10263 10264 /* was there enough data? */ 10265 if (pkt->pkt_state & STATE_XARQ_DONE) { 10266 amt = (int)MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10267 } else { 10268 if (arqstat->sts_rqpkt_resid > SENSE_LENGTH) { 10269 amt = (int)MAX_SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10270 } else { 10271 amt = (int)SENSE_LENGTH - arqstat->sts_rqpkt_resid; 10272 } 10273 } 10274 if ((arqstat->sts_rqpkt_state & STATE_XFERRED_DATA) == 0 || 10275 (amt < SUN_MIN_SENSE_LENGTH)) { 10276 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10277 "REQUEST SENSE couldn't get sense data\n"); 10278 return (rval); 10279 } 10280 10281 if (pkt->pkt_state & STATE_XARQ_DONE) { 10282 bcopy(&arqstat->sts_sensedata, ST_RQSENSE, MAX_SENSE_LENGTH); 10283 } else { 10284 bcopy(&arqstat->sts_sensedata, ST_RQSENSE, SENSE_LENGTH); 10285 } 10286 10287 /* 10288 * copy one arqstat entry in the sense data buffer 10289 */ 10290 st_update_error_stack(un, pkt, arqstat); 10291 10292 return (st_decode_sense(un, bp, amt, &arqstat->sts_rqpkt_status, pos)); 10293 } 10294 10295 static errstate 10296 st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt, 10297 struct scsi_status *statusp, tapepos_t *pos) 10298 { 10299 struct scsi_pkt *pkt = BP_PKT(bp); 10300 recov_info *ri = (recov_info *)pkt->pkt_private; 10301 errstate rval = COMMAND_DONE_ERROR; 10302 cmd_attribute const *attrib; 10303 long resid; 10304 struct scsi_extended_sense *sensep = ST_RQSENSE; 10305 int severity; 10306 int get_error; 10307 10308 ST_FUNC(ST_DEVINFO, st_decode_sense); 10309 10310 ASSERT(mutex_owned(ST_MUTEX)); 10311 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10312 "st_decode_sense()\n"); 10313 10314 /* 10315 * For uscsi commands, squirrel away a copy of the 10316 * results of the Request Sense. 10317 */ 10318 if (USCSI_CMD(bp)) { 10319 struct uscsi_cmd *ucmd = BP_UCMD(bp); 10320 ucmd->uscsi_rqstatus = *(uchar_t *)statusp; 10321 if (ucmd->uscsi_rqlen && un->un_srqbufp) { 10322 uchar_t rqlen = min((uchar_t)amt, ucmd->uscsi_rqlen); 10323 ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen; 10324 bcopy(ST_RQSENSE, un->un_srqbufp, rqlen); 10325 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 10326 "st_decode_sense: stat=0x%x resid=0x%x\n", 10327 ucmd->uscsi_rqstatus, ucmd->uscsi_rqresid); 10328 } 10329 } 10330 10331 if (ri->privatelen == sizeof (recov_info)) { 10332 attrib = ri->cmd_attrib; 10333 } else { 10334 attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 10335 } 10336 10337 /* 10338 * If the drive is an MT-02, reposition the 10339 * secondary error code into the proper place. 10340 * 10341 * XXX MT-02 is non-CCS tape, so secondary error code 10342 * is in byte 8. However, in SCSI-2, tape has CCS definition 10343 * so it's in byte 12. 10344 */ 10345 if (un->un_dp->type == ST_TYPE_EMULEX) { 10346 sensep->es_code = sensep->es_add_info[0]; 10347 } 10348 10349 ST_CDB(ST_DEVINFO, "st_decode_sense failed CDB", 10350 (caddr_t)&CDBP(pkt)->scc_cmd); 10351 10352 ST_SENSE(ST_DEVINFO, "st_decode_sense sense data", (caddr_t)sensep, 10353 sizeof (*sensep)); 10354 10355 /* for normal I/O check extract the resid values. */ 10356 if (bp != un->un_sbufp && bp != un->un_recov_buf) { 10357 if (sensep->es_valid) { 10358 resid = 10359 (sensep->es_info_1 << 24) | 10360 (sensep->es_info_2 << 16) | 10361 (sensep->es_info_3 << 8) | 10362 (sensep->es_info_4); 10363 /* If fixed block */ 10364 if (un->un_bsize) { 10365 resid *= un->un_bsize; 10366 } 10367 } else if (pkt->pkt_state & STATE_XFERRED_DATA) { 10368 resid = pkt->pkt_resid; 10369 } else { 10370 resid = bp->b_bcount; 10371 } 10372 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10373 "st_decode_sense (rw): xferred bit = %d, resid=%ld (%d), " 10374 "pkt_resid=%ld\n", pkt->pkt_state & STATE_XFERRED_DATA, 10375 resid, 10376 (sensep->es_info_1 << 24) | 10377 (sensep->es_info_2 << 16) | 10378 (sensep->es_info_3 << 8) | 10379 (sensep->es_info_4), 10380 pkt->pkt_resid); 10381 /* 10382 * The problem is, what should we believe? 10383 */ 10384 if (resid && (pkt->pkt_resid == 0)) { 10385 pkt->pkt_resid = resid; 10386 } 10387 } else { 10388 /* 10389 * If the command is SCMD_SPACE, we need to get the 10390 * residual as returned in the sense data, to adjust 10391 * our idea of current tape position correctly 10392 */ 10393 if ((sensep->es_valid) && 10394 (CDBP(pkt)->scc_cmd == SCMD_LOCATE) || 10395 (CDBP(pkt)->scc_cmd == SCMD_LOCATE_G4) || 10396 (CDBP(pkt)->scc_cmd == SCMD_SPACE) || 10397 (CDBP(pkt)->scc_cmd == SCMD_WRITE_FILE_MARK)) { 10398 resid = 10399 (sensep->es_info_1 << 24) | 10400 (sensep->es_info_2 << 16) | 10401 (sensep->es_info_3 << 8) | 10402 (sensep->es_info_4); 10403 bp->b_resid = resid; 10404 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10405 "st_decode_sense(other): resid=%ld\n", resid); 10406 } else { 10407 /* 10408 * If the special command is SCMD_READ, 10409 * the correct resid will be set later. 10410 */ 10411 if (attrib->get_cnt != NULL) { 10412 resid = attrib->get_cnt(pkt->pkt_cdbp); 10413 } else { 10414 resid = bp->b_bcount; 10415 } 10416 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10417 "st_decode_sense(special read): resid=%ld\n", 10418 resid); 10419 } 10420 } 10421 10422 if ((un->un_state >= ST_STATE_OPEN) && 10423 (DEBUGGING || st_error_level == SCSI_ERR_ALL)) { 10424 st_print_cdb(ST_DEVINFO, st_label, CE_NOTE, 10425 "Failed CDB", (char *)pkt->pkt_cdbp); 10426 st_clean_print(ST_DEVINFO, st_label, CE_CONT, 10427 "sense data", (char *)sensep, amt); 10428 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10429 "count 0x%lx resid 0x%lx pktresid 0x%lx\n", 10430 bp->b_bcount, resid, pkt->pkt_resid); 10431 } 10432 10433 switch (un->un_status = sensep->es_key) { 10434 case KEY_NO_SENSE: 10435 severity = SCSI_ERR_INFO; 10436 10437 /* 10438 * Erase, locate or rewind operation in progress, retry 10439 * ASC ASCQ 10440 * 00 18 Erase operation in progress 10441 * 00 19 Locate operation in progress 10442 * 00 1A Rewind operation in progress 10443 */ 10444 if (sensep->es_add_code == 0 && 10445 ((sensep->es_qual_code == 0x18) || 10446 (sensep->es_qual_code == 0x19) || 10447 (sensep->es_qual_code == 0x1a))) { 10448 rval = QUE_BUSY_COMMAND; 10449 break; 10450 } 10451 10452 goto common; 10453 10454 case KEY_RECOVERABLE_ERROR: 10455 severity = SCSI_ERR_RECOVERED; 10456 if ((sensep->es_class == CLASS_EXTENDED_SENSE) && 10457 (sensep->es_code == ST_DEFERRED_ERROR)) { 10458 if (un->un_dp->options & 10459 ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) { 10460 rval = QUE_LAST_COMMAND; 10461 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, 10462 severity, pos->lgclblkno, 10463 un->un_err_pos.lgclblkno, scsi_cmds, 10464 sensep); 10465 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10466 "Command will be retried\n"); 10467 } else { 10468 severity = SCSI_ERR_FATAL; 10469 rval = COMMAND_DONE_ERROR_RECOVERED; 10470 ST_DO_ERRSTATS(un, st_softerrs); 10471 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, 10472 severity, pos->lgclblkno, 10473 un->un_err_pos.lgclblkno, scsi_cmds, 10474 sensep); 10475 } 10476 break; 10477 } 10478 common: 10479 /* 10480 * XXX only want reads to be stopped by filemarks. 10481 * Don't want them to be stopped by EOT. EOT matters 10482 * only on write. 10483 */ 10484 if (sensep->es_filmk && !sensep->es_eom) { 10485 rval = COMMAND_DONE; 10486 } else if (sensep->es_eom) { 10487 rval = COMMAND_DONE; 10488 } else if (sensep->es_ili) { 10489 /* 10490 * Fun with variable length record devices: 10491 * for specifying larger blocks sizes than the 10492 * actual physical record size. 10493 */ 10494 if (un->un_bsize == 0 && resid > 0) { 10495 /* 10496 * XXX! Ugly. 10497 * The requested blocksize is > tape blocksize, 10498 * so this is ok, so we just return the 10499 * actual size xferred. 10500 */ 10501 pkt->pkt_resid = resid; 10502 rval = COMMAND_DONE; 10503 } else if (un->un_bsize == 0 && resid < 0) { 10504 /* 10505 * The requested blocksize is < tape blocksize, 10506 * so this is not ok, so we err with ENOMEM 10507 */ 10508 rval = COMMAND_DONE_ERROR_RECOVERED; 10509 st_bioerror(bp, ENOMEM); 10510 } else { 10511 ST_DO_ERRSTATS(un, st_softerrs); 10512 severity = SCSI_ERR_FATAL; 10513 rval = COMMAND_DONE_ERROR; 10514 st_bioerror(bp, EINVAL); 10515 un->un_running.pmode = invalid; 10516 } 10517 } else { 10518 /* 10519 * we hope and pray for this just being 10520 * something we can ignore (ie. a 10521 * truly recoverable soft error) 10522 */ 10523 rval = COMMAND_DONE; 10524 } 10525 if (sensep->es_filmk) { 10526 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10527 "filemark\n"); 10528 un->un_status = SUN_KEY_EOF; 10529 pos->eof = ST_EOF_PENDING; 10530 st_set_pe_flag(un); 10531 } 10532 10533 /* 10534 * ignore eom when reading, a fmk should terminate reading 10535 */ 10536 if ((sensep->es_eom) && 10537 (CDBP(pkt)->scc_cmd != SCMD_READ)) { 10538 if ((sensep->es_add_code == 0) && 10539 (sensep->es_qual_code == 4)) { 10540 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10541 "bot\n"); 10542 un->un_status = SUN_KEY_BOT; 10543 pos->eof = ST_NO_EOF; 10544 pos->lgclblkno = 0; 10545 pos->fileno = 0; 10546 pos->blkno = 0; 10547 if (pos->pmode != legacy) 10548 pos->pmode = legacy; 10549 } else { 10550 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10551 "eom\n"); 10552 un->un_status = SUN_KEY_EOT; 10553 pos->eof = ST_EOM; 10554 } 10555 st_set_pe_flag(un); 10556 } 10557 10558 break; 10559 10560 case KEY_ILLEGAL_REQUEST: 10561 10562 if (un->un_laststate >= ST_STATE_OPEN) { 10563 ST_DO_ERRSTATS(un, st_softerrs); 10564 severity = SCSI_ERR_FATAL; 10565 } else { 10566 severity = SCSI_ERR_INFO; 10567 } 10568 break; 10569 10570 case KEY_MEDIUM_ERROR: 10571 ST_DO_ERRSTATS(un, st_harderrs); 10572 severity = SCSI_ERR_FATAL; 10573 10574 /* 10575 * for (buffered) writes, a medium error must be fatal 10576 */ 10577 if (CDBP(pkt)->scc_cmd != SCMD_WRITE) { 10578 rval = COMMAND_DONE_ERROR_RECOVERED; 10579 } 10580 10581 check_keys: 10582 /* 10583 * attempt to process the keys in the presence of 10584 * other errors 10585 */ 10586 if (sensep->es_ili && rval != COMMAND_DONE_ERROR) { 10587 /* 10588 * Fun with variable length record devices: 10589 * for specifying larger blocks sizes than the 10590 * actual physical record size. 10591 */ 10592 if (un->un_bsize == 0 && resid > 0) { 10593 /* 10594 * XXX! Ugly 10595 */ 10596 pkt->pkt_resid = resid; 10597 } else if (un->un_bsize == 0 && resid < 0) { 10598 st_bioerror(bp, EINVAL); 10599 } else { 10600 severity = SCSI_ERR_FATAL; 10601 rval = COMMAND_DONE_ERROR; 10602 st_bioerror(bp, EINVAL); 10603 } 10604 } 10605 if (sensep->es_filmk) { 10606 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10607 "filemark\n"); 10608 un->un_status = SUN_KEY_EOF; 10609 pos->eof = ST_EOF_PENDING; 10610 st_set_pe_flag(un); 10611 } 10612 10613 /* 10614 * ignore eom when reading, a fmk should terminate reading 10615 */ 10616 if ((sensep->es_eom) && 10617 (CDBP(pkt)->scc_cmd != SCMD_READ)) { 10618 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "eom\n"); 10619 un->un_status = SUN_KEY_EOT; 10620 pos->eof = ST_EOM; 10621 st_set_pe_flag(un); 10622 } 10623 10624 break; 10625 10626 case KEY_VOLUME_OVERFLOW: 10627 ST_DO_ERRSTATS(un, st_softerrs); 10628 pos->eof = ST_EOM; 10629 severity = SCSI_ERR_FATAL; 10630 rval = COMMAND_DONE_ERROR; 10631 goto check_keys; 10632 10633 case KEY_HARDWARE_ERROR: 10634 ST_DO_ERRSTATS(un, st_harderrs); 10635 severity = SCSI_ERR_FATAL; 10636 rval = COMMAND_DONE_ERROR; 10637 if (un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) 10638 un->un_eject_tape_on_failure = st_check_asc_ascq(un); 10639 break; 10640 10641 case KEY_BLANK_CHECK: 10642 ST_DO_ERRSTATS(un, st_softerrs); 10643 severity = SCSI_ERR_INFO; 10644 10645 /* 10646 * if not a special request and some data was xferred then it 10647 * it is not an error yet 10648 */ 10649 if (bp != un->un_sbufp && (bp->b_flags & B_READ)) { 10650 /* 10651 * no error for read with or without data xferred 10652 */ 10653 un->un_status = SUN_KEY_EOT; 10654 pos->eof = ST_EOT; 10655 rval = COMMAND_DONE_ERROR; 10656 st_set_pe_flag(un); 10657 goto check_keys; 10658 } else if (bp != un->un_sbufp && 10659 (pkt->pkt_state & STATE_XFERRED_DATA)) { 10660 rval = COMMAND_DONE; 10661 } else { 10662 rval = COMMAND_DONE_ERROR_RECOVERED; 10663 } 10664 10665 if (un->un_laststate >= ST_STATE_OPEN) { 10666 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 10667 "blank check\n"); 10668 pos->eof = ST_EOM; 10669 } 10670 if ((CDBP(pkt)->scc_cmd == SCMD_LOCATE) || 10671 (CDBP(pkt)->scc_cmd == SCMD_LOCATE_G4) || 10672 (CDBP(pkt)->scc_cmd == SCMD_SPACE) && 10673 (un->un_dp->options & ST_KNOWS_EOD)) { 10674 /* 10675 * we were doing a fast forward by skipping 10676 * multiple fmk at the time 10677 */ 10678 st_bioerror(bp, EIO); 10679 severity = SCSI_ERR_RECOVERED; 10680 rval = COMMAND_DONE; 10681 } 10682 st_set_pe_flag(un); 10683 goto check_keys; 10684 10685 case KEY_WRITE_PROTECT: 10686 if (st_wrongtapetype(un)) { 10687 un->un_status = SUN_KEY_WRONGMEDIA; 10688 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10689 "wrong tape for writing- use DC6150 tape " 10690 "(or equivalent)\n"); 10691 severity = SCSI_ERR_UNKNOWN; 10692 } else { 10693 severity = SCSI_ERR_FATAL; 10694 } 10695 ST_DO_ERRSTATS(un, st_harderrs); 10696 rval = COMMAND_DONE_ERROR; 10697 st_bioerror(bp, EACCES); 10698 break; 10699 10700 case KEY_UNIT_ATTENTION: 10701 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10702 "KEY_UNIT_ATTENTION : un_state = %d\n", un->un_state); 10703 10704 un->un_unit_attention_flags = 1; 10705 /* 10706 * If we have detected a Bus Reset and the tape 10707 * drive has been reserved. 10708 */ 10709 if (ST_RQSENSE->es_add_code == 0x29) { 10710 rval = DEVICE_RESET; 10711 if ((un->un_rsvd_status & 10712 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 10713 ST_RESERVE) { 10714 un->un_rsvd_status |= ST_LOST_RESERVE; 10715 ST_DEBUG(ST_DEVINFO, st_label, CE_WARN, 10716 "st_decode_sense: Lost Reservation\n"); 10717 } 10718 } 10719 10720 /* 10721 * If this is a recovery command and retrable, retry. 10722 */ 10723 if (bp == un->un_recov_buf) { 10724 severity = SCSI_ERR_INFO; 10725 if (attrib->retriable && 10726 (int)un->un_retry_ct++ < st_retry_count) { 10727 rval = QUE_COMMAND; 10728 } else { 10729 rval = COMMAND_DONE_ERROR; 10730 } 10731 break; /* Don't set position invalid */ 10732 } 10733 if (un->un_state <= ST_STATE_OPENING) { 10734 /* 10735 * Look, the tape isn't open yet, now determine 10736 * if the cause is a BUS RESET, Save the file 10737 * and Block positions for the callers to 10738 * recover from the loss of position. 10739 */ 10740 severity = SCSI_ERR_INFO; 10741 if ((pos->pmode != invalid) && 10742 (rval == DEVICE_RESET) && 10743 (un->un_restore_pos != 1)) { 10744 un->un_save_fileno = pos->fileno; 10745 un->un_save_blkno = pos->blkno; 10746 un->un_restore_pos = 1; 10747 } 10748 10749 if (attrib->retriable && 10750 (int)un->un_retry_ct++ < st_retry_count) { 10751 rval = QUE_COMMAND; 10752 } else if (rval == DEVICE_RESET) { 10753 break; 10754 } else { 10755 rval = COMMAND_DONE_ERROR; 10756 } 10757 /* 10758 * Means it thinks the mode parameters have changed. 10759 * This is the result of a reset clearing settings or 10760 * another initiator changing what we set. 10761 */ 10762 } else if (ST_RQSENSE->es_add_code == 0x2a) { 10763 if (ST_RQSENSE->es_qual_code == 0x1) { 10764 /* Error recovery will modeselect and retry. */ 10765 rval = DEVICE_TAMPER; 10766 severity = SCSI_ERR_INFO; 10767 break; /* don't set position invalid */ 10768 } 10769 if (ST_RQSENSE->es_qual_code == 0x0 || 10770 ST_RQSENSE->es_qual_code == 0x2 || 10771 ST_RQSENSE->es_qual_code == 0x3 || 10772 ST_RQSENSE->es_qual_code == 0x4 || 10773 ST_RQSENSE->es_qual_code == 0x5 || 10774 ST_RQSENSE->es_qual_code == 0x6 || 10775 ST_RQSENSE->es_qual_code == 0x7) { 10776 rval = DEVICE_TAMPER; 10777 severity = SCSI_ERR_INFO; 10778 } 10779 } else if (ST_RQSENSE->es_add_code == 0x28 && 10780 ((ST_RQSENSE->es_qual_code == 0x0) || 10781 ST_RQSENSE->es_qual_code == 0x5)) { 10782 /* 10783 * Not Ready to Ready change, Media may have changed. 10784 */ 10785 rval = DEVICE_TAMPER; 10786 severity = SCSI_ERR_RETRYABLE; 10787 } else { 10788 if (rval != DEVICE_RESET) { 10789 rval = COMMAND_DONE_ERROR; 10790 } else { 10791 /* 10792 * Returning DEVICE_RESET will call 10793 * error recovery. 10794 */ 10795 severity = SCSI_ERR_INFO; 10796 break; /* don't set position invalid */ 10797 } 10798 /* 10799 * Check if it is an Unexpected Unit Attention. 10800 * If state is >= ST_STATE_OPEN, we have 10801 * already done the initialization . 10802 * In this case it is Fatal Error 10803 * since no further reading/writing 10804 * can be done with fileno set to < 0. 10805 */ 10806 if (un->un_state >= ST_STATE_OPEN) { 10807 ST_DO_ERRSTATS(un, st_harderrs); 10808 severity = SCSI_ERR_FATAL; 10809 } else { 10810 severity = SCSI_ERR_INFO; 10811 } 10812 } 10813 10814 pos->pmode = invalid; 10815 10816 break; 10817 10818 case KEY_NOT_READY: 10819 /* 10820 * If in process of getting ready retry. 10821 */ 10822 if (sensep->es_add_code == 0x04 && 10823 sensep->es_qual_code == 0x01 && 10824 un->un_retry_ct++ < st_retry_count) { 10825 rval = QUE_COMMAND; 10826 severity = SCSI_ERR_INFO; 10827 } else { 10828 /* give up */ 10829 rval = COMMAND_DONE_ERROR; 10830 severity = SCSI_ERR_FATAL; 10831 } 10832 10833 /* 10834 * If this was an error and after device opened 10835 * do error stats. 10836 */ 10837 if (rval == COMMAND_DONE_ERROR && 10838 un->un_state > ST_STATE_OPENING) { 10839 ST_DO_ERRSTATS(un, st_harderrs); 10840 } 10841 10842 if (ST_RQSENSE->es_add_code == 0x3a) { 10843 if (st_error_level >= SCSI_ERR_FATAL) 10844 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 10845 "Tape not inserted in drive\n"); 10846 un->un_mediastate = MTIO_EJECTED; 10847 cv_broadcast(&un->un_state_cv); 10848 } 10849 if ((un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) && 10850 (rval != QUE_COMMAND)) 10851 un->un_eject_tape_on_failure = st_check_asc_ascq(un); 10852 break; 10853 10854 case KEY_ABORTED_COMMAND: 10855 /* XXX Do drives return this when they see a lost light? */ 10856 /* Testing would say yes */ 10857 10858 if (un->un_retry_ct++ < st_retry_count) { 10859 rval = ATTEMPT_RETRY; 10860 severity = SCSI_ERR_RETRYABLE; 10861 goto check_keys; 10862 } 10863 /* 10864 * Probably a parity error... 10865 * if we retry here then this may cause data to be 10866 * written twice or data skipped during reading 10867 */ 10868 ST_DO_ERRSTATS(un, st_harderrs); 10869 severity = SCSI_ERR_FATAL; 10870 rval = COMMAND_DONE_ERROR; 10871 goto check_keys; 10872 10873 default: 10874 /* 10875 * Undecoded sense key. Try retries and hope 10876 * that will fix the problem. Otherwise, we're 10877 * dead. 10878 */ 10879 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10880 "Unhandled Sense Key '%s'\n", 10881 sense_keys[un->un_status]); 10882 ST_DO_ERRSTATS(un, st_harderrs); 10883 severity = SCSI_ERR_FATAL; 10884 rval = COMMAND_DONE_ERROR; 10885 goto check_keys; 10886 } 10887 10888 if ((!(pkt->pkt_flags & FLAG_SILENT) && 10889 un->un_state >= ST_STATE_OPEN) && (DEBUGGING || 10890 (un->un_laststate > ST_STATE_OPENING) && 10891 (severity >= st_error_level))) { 10892 10893 scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity, 10894 pos->lgclblkno, un->un_err_pos.lgclblkno, 10895 scsi_cmds, sensep); 10896 if (sensep->es_filmk) { 10897 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10898 "File Mark Detected\n"); 10899 } 10900 if (sensep->es_eom) { 10901 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10902 "End-of-Media Detected\n"); 10903 } 10904 if (sensep->es_ili) { 10905 scsi_log(ST_DEVINFO, st_label, CE_CONT, 10906 "Incorrect Length Indicator Set\n"); 10907 } 10908 } 10909 get_error = geterror(bp); 10910 if (((rval == COMMAND_DONE_ERROR) || 10911 (rval == COMMAND_DONE_ERROR_RECOVERED)) && 10912 ((get_error == EIO) || (get_error == 0))) { 10913 un->un_rqs_state |= (ST_RQS_ERROR | ST_RQS_VALID); 10914 bcopy(ST_RQSENSE, un->un_uscsi_rqs_buf, SENSE_LENGTH); 10915 if (un->un_rqs_state & ST_RQS_READ) { 10916 un->un_rqs_state &= ~(ST_RQS_READ); 10917 } else { 10918 un->un_rqs_state |= ST_RQS_OVR; 10919 } 10920 } 10921 10922 return (rval); 10923 } 10924 10925 10926 static int 10927 st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp) 10928 { 10929 int status = TRAN_ACCEPT; 10930 10931 mutex_enter(ST_MUTEX); 10932 10933 ST_FUNC(ST_DEVINFO, st_handle_intr_retry_lcmd); 10934 10935 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 10936 "st_handle_intr_rtr_lcmd(), un = 0x%p\n", (void *)un); 10937 10938 /* 10939 * Check to see if we hit the retry timeout. We check to make sure 10940 * this is the first one on the runq and make sure we have not 10941 * queued up any more, so this one has to be the last on the list 10942 * also. If it is not, we have to fail. If it is not the first, but 10943 * is the last we are in trouble anyway, as we are in the interrupt 10944 * context here. 10945 */ 10946 if (((int)un->un_retry_ct > st_retry_count) || 10947 ((un->un_runqf != bp) && (un->un_runql != bp))) { 10948 goto exit; 10949 } 10950 10951 if (un->un_throttle) { 10952 un->un_last_throttle = un->un_throttle; 10953 un->un_throttle = 0; 10954 } 10955 10956 /* 10957 * Here we know : bp is the first and last one on the runq 10958 * it is not necessary to put it back on the head of the 10959 * waitq and then move from waitq to runq. Save this queuing 10960 * and call scsi_transport. 10961 */ 10962 ST_CDB(ST_DEVINFO, "Retry lcmd CDB", (char *)BP_PKT(bp)->pkt_cdbp); 10963 10964 status = st_transport(un, BP_PKT(bp)); 10965 10966 if (status == TRAN_ACCEPT) { 10967 un->un_tran_retry_ct = 0; 10968 if (un->un_last_throttle) { 10969 un->un_throttle = un->un_last_throttle; 10970 } 10971 mutex_exit(ST_MUTEX); 10972 10973 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10974 "restart transport \n"); 10975 return (0); 10976 } 10977 10978 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 10979 mutex_exit(ST_MUTEX); 10980 10981 if (status == TRAN_BUSY) { 10982 if (st_handle_intr_busy(un, bp, ST_TRAN_BUSY_TIMEOUT) == 0) { 10983 return (0); 10984 } 10985 } 10986 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 10987 "restart transport rejected\n"); 10988 mutex_enter(ST_MUTEX); 10989 ST_DO_ERRSTATS(un, st_transerrs); 10990 if (un->un_last_throttle) { 10991 un->un_throttle = un->un_last_throttle; 10992 } 10993 exit: 10994 mutex_exit(ST_MUTEX); 10995 return (-1); 10996 } 10997 10998 static int 10999 st_wrongtapetype(struct scsi_tape *un) 11000 { 11001 11002 ST_FUNC(ST_DEVINFO, st_wrongtapetype); 11003 11004 ASSERT(mutex_owned(ST_MUTEX)); 11005 11006 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_wrongtapetype()\n"); 11007 11008 /* 11009 * Hack to handle 600A, 600XTD, 6150 && 660 vs. 300XL tapes... 11010 */ 11011 if (un->un_dp && (un->un_dp->options & ST_QIC) && un->un_mspl) { 11012 switch (un->un_dp->type) { 11013 case ST_TYPE_WANGTEK: 11014 case ST_TYPE_ARCHIVE: 11015 /* 11016 * If this really worked, we could go off of 11017 * the density codes set in the modesense 11018 * page. For this drive, 0x10 == QIC-120, 11019 * 0xf == QIC-150, and 0x5 should be for 11020 * both QIC-24 and, maybe, QIC-11. However, 11021 * the h/w doesn't do what the manual says 11022 * that it should, so we'll key off of 11023 * getting a WRITE PROTECT error AND wp *not* 11024 * set in the mode sense information. 11025 */ 11026 /* 11027 * XXX but we already know that status is 11028 * write protect, so don't check it again. 11029 */ 11030 11031 if (un->un_status == KEY_WRITE_PROTECT && 11032 un->un_mspl->wp == 0) { 11033 return (1); 11034 } 11035 break; 11036 default: 11037 break; 11038 } 11039 } 11040 return (0); 11041 } 11042 11043 static errstate 11044 st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt) 11045 { 11046 errstate action; 11047 11048 ST_FUNC(ST_DEVINFO, st_check_error); 11049 11050 ASSERT(mutex_owned(ST_MUTEX)); 11051 11052 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_error()\n"); 11053 11054 if (SCBP_C(pkt) == STATUS_RESERVATION_CONFLICT) { 11055 action = COMMAND_DONE_EACCES; 11056 un->un_rsvd_status |= ST_RESERVATION_CONFLICT; 11057 } else if (SCBP(pkt)->sts_busy) { 11058 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, "unit busy\n"); 11059 if ((int)un->un_retry_ct++ < st_retry_count) { 11060 action = QUE_BUSY_COMMAND; 11061 } else if ((un->un_rsvd_status & 11062 (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) { 11063 /* 11064 * If this is a command done before reserve is done 11065 * don't reset. 11066 */ 11067 action = COMMAND_DONE_ERROR; 11068 } else { 11069 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 11070 "unit busy too long\n"); 11071 (void) st_reset(un, RESET_ALL); 11072 action = COMMAND_DONE_ERROR; 11073 } 11074 } else if (SCBP(pkt)->sts_chk) { 11075 /* 11076 * we should only get here if the auto rqsense failed 11077 * thru a uscsi cmd without autorequest sense 11078 * so we just try again 11079 */ 11080 action = QUE_SENSE; 11081 } else { 11082 action = COMMAND_DONE; 11083 } 11084 return (action); 11085 } 11086 11087 static void 11088 st_calc_bnum(struct scsi_tape *un, struct buf *bp, struct scsi_pkt *pkt) 11089 { 11090 int nblks; 11091 long count; 11092 recov_info *ri = (recov_info *)pkt->pkt_private; 11093 cmd_attribute const *attrib; 11094 11095 ST_FUNC(ST_DEVINFO, st_calc_bnum); 11096 11097 ASSERT(mutex_owned(ST_MUTEX)); 11098 11099 if (ri->privatelen == sizeof (recov_info)) { 11100 attrib = ri->cmd_attrib; 11101 ASSERT(attrib->recov_pos_type == POS_EXPECTED); 11102 ASSERT(attrib->chg_tape_pos); 11103 } else { 11104 ri = NULL; 11105 attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 11106 } 11107 11108 count = bp->b_bcount - bp->b_resid; 11109 11110 /* If variable block mode */ 11111 if (un->un_bsize == 0) { 11112 nblks = ((count == 0) ? 0 : 1); 11113 un->un_kbytes_xferred += (count / ONE_K); 11114 } else { 11115 nblks = (count / un->un_bsize); 11116 un->un_kbytes_xferred += (nblks * un->un_bsize) / ONE_K; 11117 } 11118 11119 /* 11120 * If some command failed after this one started and it seems 11121 * to have finshed without error count the position. 11122 */ 11123 if (un->un_persistence && un->un_persist_errors) { 11124 ASSERT(un->un_pos.pmode != invalid); 11125 } 11126 11127 if (attrib->chg_tape_direction == DIR_FORW) { 11128 un->un_pos.blkno += nblks; 11129 un->un_pos.lgclblkno += nblks; 11130 } else if (attrib->chg_tape_direction == DIR_REVC) { 11131 un->un_pos.blkno -= nblks; 11132 un->un_pos.lgclblkno -= nblks; 11133 } else { 11134 ASSERT(0); 11135 } 11136 11137 /* recovery disabled */ 11138 if (ri == NULL) { 11139 un->un_running.pmode = invalid; 11140 return; 11141 } 11142 11143 /* 11144 * If we didn't just read a filemark. 11145 */ 11146 if (un->un_pos.eof != ST_EOF_PENDING) { 11147 ASSERT(nblks != 0); 11148 /* 11149 * If Previously calulated expected position does not match 11150 * debug the expected position. 11151 */ 11152 if ((ri->pos.pmode != invalid) && nblks && 11153 ((un->un_pos.blkno != ri->pos.blkno) || 11154 (un->un_pos.lgclblkno != ri->pos.lgclblkno))) { 11155 #ifdef STDEBUG 11156 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 11157 "Expected", &ri->pos); 11158 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 11159 "But Got", &un->un_pos); 11160 #endif 11161 un->un_running.pmode = invalid; 11162 } 11163 } else { 11164 ASSERT(nblks == 0); 11165 if (un->un_running.pmode != invalid) { 11166 /* 11167 * blkno and lgclblkno already counted in 11168 * st_add_recovery_info_to_pkt(). Since a block was not 11169 * read and a filemark was. 11170 */ 11171 if (attrib->chg_tape_direction == DIR_FORW) { 11172 un->un_running.fileno++; 11173 un->un_running.blkno = 0; 11174 } else if (attrib->chg_tape_direction == DIR_REVC) { 11175 un->un_running.fileno--; 11176 un->un_running.blkno = INF; 11177 } 11178 } 11179 } 11180 } 11181 11182 static void 11183 st_set_state(struct scsi_tape *un, struct buf *bp) 11184 { 11185 struct scsi_pkt *sp = BP_PKT(bp); 11186 struct uscsi_cmd *ucmd; 11187 11188 ST_FUNC(ST_DEVINFO, st_set_state); 11189 11190 ASSERT(mutex_owned(ST_MUTEX)); 11191 11192 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 11193 "st_set_state(): eof=%x fmneeded=%x pkt_resid=0x%lx (%ld)\n", 11194 un->un_pos.eof, un->un_fmneeded, sp->pkt_resid, sp->pkt_resid); 11195 11196 if ((bp != un->un_sbufp) && (bp != un->un_recov_buf)) { 11197 #ifdef STDEBUG 11198 if (DEBUGGING && sp->pkt_resid) { 11199 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11200 "pkt_resid %ld bcount %ld\n", 11201 sp->pkt_resid, bp->b_bcount); 11202 } 11203 #endif 11204 bp->b_resid = sp->pkt_resid; 11205 st_calc_bnum(un, bp, sp); 11206 if (bp->b_flags & B_READ) { 11207 un->un_lastop = ST_OP_READ; 11208 un->un_fmneeded = 0; 11209 } else { 11210 un->un_lastop = ST_OP_WRITE; 11211 if (un->un_dp->options & ST_REEL) { 11212 un->un_fmneeded = 2; 11213 } else { 11214 un->un_fmneeded = 1; 11215 } 11216 } 11217 /* 11218 * all is honky dory at this point, so let's 11219 * readjust the throttle, to increase speed, if we 11220 * have not throttled down. 11221 */ 11222 if (un->un_throttle) { 11223 un->un_throttle = un->un_max_throttle; 11224 } 11225 } else { 11226 optype new_lastop; 11227 uchar_t cmd = (uchar_t)(intptr_t)bp->b_forw; 11228 11229 un->un_lastop = ST_OP_CTL; 11230 11231 switch (cmd) { 11232 case SCMD_WRITE: 11233 case SCMD_WRITE_G4: 11234 bp->b_resid = sp->pkt_resid; 11235 new_lastop = ST_OP_WRITE; 11236 st_calc_bnum(un, bp, sp); 11237 if (un->un_dp->options & ST_REEL) { 11238 un->un_fmneeded = 2; 11239 } else { 11240 un->un_fmneeded = 1; 11241 } 11242 break; 11243 case SCMD_READ: 11244 case SCMD_READ_G4: 11245 bp->b_resid = sp->pkt_resid; 11246 new_lastop = ST_OP_READ; 11247 st_calc_bnum(un, bp, sp); 11248 un->un_fmneeded = 0; 11249 break; 11250 case SCMD_WRITE_FILE_MARK_G4: 11251 case SCMD_WRITE_FILE_MARK: 11252 { 11253 int fmdone; 11254 11255 if (un->un_pos.eof != ST_EOM) { 11256 un->un_pos.eof = ST_NO_EOF; 11257 } 11258 fmdone = (bp->b_bcount - bp->b_resid); 11259 if (fmdone > 0) { 11260 un->un_lastop = new_lastop = ST_OP_WEOF; 11261 un->un_pos.lgclblkno += fmdone; 11262 un->un_pos.fileno += fmdone; 11263 un->un_pos.blkno = 0; 11264 } else { 11265 new_lastop = ST_OP_CTL; 11266 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 11267 "Flushed buffer\n"); 11268 } 11269 if (fmdone > un->un_fmneeded) { 11270 un->un_fmneeded = 0; 11271 } else { 11272 un->un_fmneeded -= fmdone; 11273 } 11274 break; 11275 } 11276 case SCMD_REWIND: 11277 un->un_pos.eof = ST_NO_EOF; 11278 un->un_pos.fileno = 0; 11279 un->un_pos.blkno = 0; 11280 un->un_pos.lgclblkno = 0; 11281 if (un->un_pos.pmode != legacy) 11282 un->un_pos.pmode = legacy; 11283 new_lastop = ST_OP_CTL; 11284 un->un_restore_pos = 0; 11285 break; 11286 11287 case SCMD_SPACE: 11288 case SCMD_SPACE_G4: 11289 { 11290 int64_t count; 11291 int64_t resid; 11292 int64_t done; 11293 cmd_attribute const *attrib; 11294 recov_info *ri = (recov_info *)sp->pkt_private; 11295 11296 if (ri->privatelen == sizeof (recov_info)) { 11297 attrib = ri->cmd_attrib; 11298 } else { 11299 attrib = 11300 st_lookup_cmd_attribute(sp->pkt_cdbp[0]); 11301 } 11302 11303 resid = (int64_t)SPACE_CNT(bp->b_resid); 11304 count = (int64_t)attrib->get_cnt(sp->pkt_cdbp); 11305 11306 if (count >= 0) { 11307 done = (count - resid); 11308 } else { 11309 done = ((-count) - resid); 11310 } 11311 if (done > 0) { 11312 un->un_lastop = new_lastop = ST_OP_CTL; 11313 } else { 11314 new_lastop = ST_OP_CTL; 11315 } 11316 11317 ST_SPAC(ST_DEVINFO, st_label, SCSI_DEBUG, 11318 "space cmd: cdb[1] = %s\n" 11319 "space data: = 0x%lx\n" 11320 "space count: = %"PRId64"\n" 11321 "space resid: = %"PRId64"\n" 11322 "spaces done: = %"PRId64"\n" 11323 "fileno before = %d\n" 11324 "blkno before = %d\n", 11325 space_strs[sp->pkt_cdbp[1] & 7], 11326 bp->b_bcount, 11327 count, resid, done, 11328 un->un_pos.fileno, un->un_pos.blkno); 11329 11330 switch (sp->pkt_cdbp[1]) { 11331 case SPACE_TYPE(SP_FLM): 11332 /* Space file forward */ 11333 if (count >= 0) { 11334 if (un->un_pos.eof <= ST_EOF) { 11335 un->un_pos.eof = ST_NO_EOF; 11336 } 11337 un->un_pos.fileno += done; 11338 un->un_pos.blkno = 0; 11339 break; 11340 } 11341 /* Space file backward */ 11342 if (done > un->un_pos.fileno) { 11343 un->un_pos.fileno = 0; 11344 un->un_pos.blkno = 0; 11345 } else { 11346 un->un_pos.fileno -= done; 11347 un->un_pos.blkno = INF; 11348 un->un_running.pmode = invalid; 11349 } 11350 break; 11351 case SPACE_TYPE(SP_BLK): 11352 /* Space block forward */ 11353 if (count >= 0) { 11354 un->un_pos.blkno += done; 11355 break; 11356 } 11357 /* Space block backward */ 11358 if (un->un_pos.eof >= ST_EOF_PENDING) { 11359 /* 11360 * we stepped back into 11361 * a previous file; we are not 11362 * making an effort to pretend that 11363 * we are still in the current file 11364 * ie. logical == physical position 11365 * and leave it to st_ioctl to correct 11366 */ 11367 if (done > un->un_pos.blkno) { 11368 un->un_pos.blkno = 0; 11369 } else { 11370 un->un_pos.fileno--; 11371 un->un_pos.blkno = INF; 11372 un->un_running.pmode = invalid; 11373 } 11374 } else { 11375 un->un_pos.blkno -= done; 11376 } 11377 break; 11378 case SPACE_TYPE(SP_SQFLM): 11379 un->un_pos.pmode = logical; 11380 un->un_pos.blkno = 0; 11381 un->un_lastop = new_lastop = ST_OP_CTL; 11382 break; 11383 case SPACE_TYPE(SP_EOD): 11384 un->un_pos.pmode = logical; 11385 un->un_pos.eof = ST_EOM; 11386 un->un_status = KEY_BLANK_CHECK; 11387 break; 11388 default: 11389 un->un_pos.pmode = invalid; 11390 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 11391 "Unsupported space cmd: %s\n", 11392 space_strs[sp->pkt_cdbp[1] & 7]); 11393 11394 un->un_lastop = new_lastop = ST_OP_CTL; 11395 } 11396 11397 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11398 "after_space rs %"PRId64" fil %d blk %d\n", 11399 resid, un->un_pos.fileno, un->un_pos.blkno); 11400 11401 break; 11402 } 11403 case SCMD_LOAD: 11404 if ((bp->b_bcount & (LD_LOAD | LD_EOT)) == LD_LOAD) { 11405 un->un_pos.fileno = 0; 11406 if (un->un_pos.pmode != legacy) 11407 un->un_pos.pmode = legacy; 11408 } else { 11409 un->un_state = ST_STATE_OFFLINE; 11410 un->un_pos.pmode = invalid; 11411 } 11412 un->un_density_known = 0; 11413 un->un_pos.eof = ST_NO_EOF; 11414 un->un_pos.blkno = 0; 11415 un->un_lastop = new_lastop = ST_OP_CTL; 11416 break; 11417 case SCMD_ERASE: 11418 un->un_pos.eof = ST_NO_EOF; 11419 un->un_pos.blkno = 0; 11420 un->un_pos.fileno = 0; 11421 un->un_pos.lgclblkno = 0; 11422 if (un->un_pos.pmode != legacy) 11423 un->un_pos.pmode = legacy; 11424 new_lastop = ST_OP_CTL; 11425 break; 11426 case SCMD_RESERVE: 11427 un->un_rsvd_status |= ST_RESERVE; 11428 un->un_rsvd_status &= 11429 ~(ST_RELEASE | ST_LOST_RESERVE | 11430 ST_RESERVATION_CONFLICT | ST_INITIATED_RESET); 11431 new_lastop = un->un_lastop; 11432 break; 11433 case SCMD_RELEASE: 11434 un->un_rsvd_status |= ST_RELEASE; 11435 un->un_rsvd_status &= 11436 ~(ST_RESERVE | ST_LOST_RESERVE | 11437 ST_RESERVATION_CONFLICT | ST_INITIATED_RESET); 11438 new_lastop = ST_OP_CTL; 11439 break; 11440 case SCMD_PERSISTENT_RESERVE_IN: 11441 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11442 "PGR_IN command\n"); 11443 break; 11444 case SCMD_PERSISTENT_RESERVE_OUT: 11445 switch (sp->pkt_cdbp[1] & ST_SA_MASK) { 11446 case ST_SA_SCSI3_RESERVE: 11447 case ST_SA_SCSI3_PREEMPT: 11448 case ST_SA_SCSI3_PREEMPTANDABORT: 11449 un->un_rsvd_status |= 11450 ST_APPLICATION_RESERVATIONS; 11451 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11452 "PGR Reserve and set: entering" 11453 " ST_APPLICATION_RESERVATIONS mode"); 11454 break; 11455 case ST_SA_SCSI3_RELEASE: 11456 case ST_SA_SCSI3_CLEAR: 11457 un->un_rsvd_status &= 11458 ~ST_APPLICATION_RESERVATIONS; 11459 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 11460 "PGR Release and reset: exiting" 11461 " ST_APPLICATION_RESERVATIONS mode"); 11462 break; 11463 } 11464 break; 11465 case SCMD_TEST_UNIT_READY: 11466 case SCMD_READ_BLKLIM: 11467 case SCMD_REQUEST_SENSE: 11468 case SCMD_INQUIRY: 11469 case SCMD_RECOVER_BUF: 11470 case SCMD_MODE_SELECT: 11471 case SCMD_MODE_SENSE: 11472 case SCMD_DOORLOCK: 11473 case SCMD_READ_BUFFER: 11474 case SCMD_REPORT_DENSITIES: 11475 case SCMD_LOG_SELECT_G1: 11476 case SCMD_LOG_SENSE_G1: 11477 case SCMD_REPORT_LUNS: 11478 case SCMD_READ_ATTRIBUTE: 11479 case SCMD_WRITE_ATTRIBUTE: 11480 case SCMD_SVC_ACTION_IN_G5: 11481 new_lastop = ST_OP_CTL; 11482 break; 11483 case SCMD_READ_POSITION: 11484 new_lastop = ST_OP_CTL; 11485 /* 11486 * Only if the buf used was un_sbufp. 11487 * Among other things the prevents read positions used 11488 * as part of error recovery from messing up our 11489 * current position as they will use un_recov_buf. 11490 */ 11491 if (USCSI_CMD(bp)) { 11492 (void) st_get_read_pos(un, bp); 11493 } 11494 break; 11495 case SCMD_LOCATE: 11496 case SCMD_LOCATE_G4: 11497 /* Locate makes position mode no longer legacy */ 11498 un->un_lastop = new_lastop = ST_OP_CTL; 11499 break; 11500 default: 11501 /* 11502 * Unknown command, If was USCSI and USCSI_SILENT 11503 * flag was not set, set position to unknown. 11504 */ 11505 if ((((ucmd = BP_UCMD(bp)) != NULL) && 11506 (ucmd->uscsi_flags & USCSI_SILENT) == 0)) { 11507 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 11508 "unknown cmd 0x%X caused loss of state\n", 11509 cmd); 11510 } else { 11511 break; 11512 } 11513 /* FALLTHROUGH */ 11514 case SCMD_WRITE_BUFFER: /* Writes new firmware to device */ 11515 un->un_pos.pmode = invalid; 11516 un->un_lastop = new_lastop = ST_OP_CTL; 11517 break; 11518 } 11519 11520 /* new_lastop should have been changed */ 11521 ASSERT(new_lastop != ST_OP_NIL); 11522 11523 /* If un_lastop should copy new_lastop */ 11524 if (((un->un_lastop == ST_OP_WRITE) || 11525 (un->un_lastop == ST_OP_WEOF)) && 11526 new_lastop != ST_OP_CTL) { 11527 un->un_lastop = new_lastop; 11528 } 11529 } 11530 11531 /* 11532 * In the st driver we have a logical and physical file position. 11533 * Under BSD behavior, when you get a zero read, the logical position 11534 * is before the filemark but after the last record of the file. 11535 * The physical position is after the filemark. MTIOCGET should always 11536 * return the logical file position. 11537 * 11538 * The next read gives a silent skip to the next file. 11539 * Under SVR4, the logical file position remains before the filemark 11540 * until the file is closed or a space operation is performed. 11541 * Hence set err_resid and err_file before changing fileno if case 11542 * BSD Behaviour. 11543 */ 11544 un->un_err_resid = bp->b_resid; 11545 COPY_POS(&un->un_err_pos, &un->un_pos); 11546 un->un_retry_ct = 0; 11547 11548 11549 /* 11550 * If we've seen a filemark via the last read operation 11551 * advance the file counter, but mark things such that 11552 * the next read operation gets a zero count. We have 11553 * to put this here to handle the case of sitting right 11554 * at the end of a tape file having seen the file mark, 11555 * but the tape is closed and then re-opened without 11556 * any further i/o. That is, the position information 11557 * must be updated before a close. 11558 */ 11559 11560 if (un->un_lastop == ST_OP_READ && un->un_pos.eof == ST_EOF_PENDING) { 11561 /* 11562 * If we're a 1/2" tape, and we get a filemark 11563 * right on block 0, *AND* we were not in the 11564 * first file on the tape, and we've hit logical EOM. 11565 * We'll mark the state so that later we do the 11566 * right thing (in st_close(), st_strategy() or 11567 * st_ioctl()). 11568 * 11569 */ 11570 if ((un->un_dp->options & ST_REEL) && 11571 !(un->un_dp->options & ST_READ_IGNORE_EOFS) && 11572 un->un_pos.blkno == 0 && un->un_pos.fileno > 0) { 11573 un->un_pos.eof = ST_EOT_PENDING; 11574 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11575 "eot pending\n"); 11576 un->un_pos.fileno++; 11577 un->un_pos.blkno = 0; 11578 } else if (BSD_BEHAVIOR) { 11579 /* 11580 * If the read of the filemark was a side effect 11581 * of reading some blocks (i.e., data was actually 11582 * read), then the EOF mark is pending and the 11583 * bump into the next file awaits the next read 11584 * operation (which will return a zero count), or 11585 * a close or a space operation, else the bump 11586 * into the next file occurs now. 11587 */ 11588 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11589 "resid=%lx, bcount=%lx\n", 11590 bp->b_resid, bp->b_bcount); 11591 11592 if (bp->b_resid != bp->b_bcount) { 11593 un->un_pos.eof = ST_EOF; 11594 } else { 11595 un->un_silent_skip = 1; 11596 un->un_pos.eof = ST_NO_EOF; 11597 un->un_pos.fileno++; 11598 un->un_pos.lgclblkno++; 11599 un->un_save_blkno = un->un_pos.blkno; 11600 un->un_pos.blkno = 0; 11601 } 11602 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11603 "eof of file %d, eof=%d\n", 11604 un->un_pos.fileno, un->un_pos.eof); 11605 } else if (SVR4_BEHAVIOR) { 11606 /* 11607 * If the read of the filemark was a side effect 11608 * of reading some blocks (i.e., data was actually 11609 * read), then the next read should return 0 11610 */ 11611 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11612 "resid=%lx, bcount=%lx\n", 11613 bp->b_resid, bp->b_bcount); 11614 if (bp->b_resid == bp->b_bcount) { 11615 un->un_pos.eof = ST_EOF; 11616 } 11617 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 11618 "eof of file=%d, eof=%d\n", 11619 un->un_pos.fileno, un->un_pos.eof); 11620 } 11621 } 11622 } 11623 11624 /* 11625 * set the correct un_errno, to take corner cases into consideration 11626 */ 11627 static void 11628 st_set_pe_errno(struct scsi_tape *un) 11629 { 11630 ST_FUNC(ST_DEVINFO, st_set_pe_errno); 11631 11632 ASSERT(mutex_owned(ST_MUTEX)); 11633 11634 /* if errno is already set, don't reset it */ 11635 if (un->un_errno) 11636 return; 11637 11638 /* here un_errno == 0 */ 11639 /* 11640 * if the last transfer before flushing all the 11641 * waiting I/O's, was 0 (resid = count), then we 11642 * want to give the user an error on all the rest, 11643 * so here. If there was a transfer, we set the 11644 * resid and counts to 0, and let it drop through, 11645 * giving a zero return. the next I/O will then 11646 * give an error. 11647 */ 11648 if (un->un_last_resid == un->un_last_count) { 11649 switch (un->un_pos.eof) { 11650 case ST_EOM: 11651 un->un_errno = ENOMEM; 11652 break; 11653 case ST_EOT: 11654 case ST_EOF: 11655 un->un_errno = EIO; 11656 break; 11657 } 11658 } else { 11659 /* 11660 * we know they did not have a zero, so make 11661 * sure they get one 11662 */ 11663 un->un_last_resid = un->un_last_count = 0; 11664 } 11665 } 11666 11667 11668 /* 11669 * send in a marker pkt to terminate flushing of commands by BBA (via 11670 * flush-on-errors) property. The HBA will always return TRAN_ACCEPT 11671 */ 11672 static void 11673 st_hba_unflush(struct scsi_tape *un) 11674 { 11675 ST_FUNC(ST_DEVINFO, st_hba_unflush); 11676 11677 ASSERT(mutex_owned(ST_MUTEX)); 11678 11679 if (!un->un_flush_on_errors) 11680 return; 11681 11682 #ifdef FLUSH_ON_ERRORS 11683 11684 if (!un->un_mkr_pkt) { 11685 un->un_mkr_pkt = scsi_init_pkt(ROUTE, NULL, (struct buf *)NULL, 11686 NULL, 0, 0, 0, SLEEP_FUNC, NULL); 11687 11688 /* we slept, so it must be there */ 11689 pkt->pkt_flags |= FLAG_FLUSH_MARKER; 11690 } 11691 11692 st_transport(un, un->un_mkr_pkt); 11693 #endif 11694 } 11695 11696 static char * 11697 st_print_scsi_cmd(char cmd) 11698 { 11699 char tmp[64]; 11700 char *cpnt; 11701 11702 cpnt = scsi_cmd_name(cmd, scsi_cmds, tmp); 11703 /* tmp goes out of scope on return and caller sees garbage */ 11704 if (cpnt == tmp) { 11705 cpnt = "Unknown Command"; 11706 } 11707 return (cpnt); 11708 } 11709 11710 static void 11711 st_print_cdb(dev_info_t *dip, char *label, uint_t level, 11712 char *title, char *cdb) 11713 { 11714 int len = scsi_cdb_size[CDB_GROUPID(cdb[0])]; 11715 char buf[256]; 11716 struct scsi_tape *un; 11717 int instance = ddi_get_instance(dip); 11718 11719 un = ddi_get_soft_state(st_state, instance); 11720 11721 ST_FUNC(dip, st_print_cdb); 11722 11723 #ifdef STDEBUG 11724 if ((st_debug & 0x180) == 0x100) { 11725 scsi_log(dip, label, level, "node %s cmd %s\n", 11726 st_dev_name(un->un_dev), st_print_scsi_cmd(*cdb)); 11727 return; 11728 } 11729 #endif 11730 (void) sprintf(buf, "%s for cmd(%s)", title, st_print_scsi_cmd(*cdb)); 11731 st_clean_print(dip, label, level, buf, cdb, len); 11732 } 11733 11734 static void 11735 st_clean_print(dev_info_t *dev, char *label, uint_t level, 11736 char *title, char *data, int len) 11737 { 11738 int i; 11739 int c; 11740 char *format; 11741 char buf[256]; 11742 uchar_t byte; 11743 11744 ST_FUNC(dev, st_clean_print); 11745 11746 11747 (void) sprintf(buf, "%s:\n", title); 11748 scsi_log(dev, label, level, "%s", buf); 11749 level = CE_CONT; 11750 for (i = 0; i < len; ) { 11751 buf[0] = 0; 11752 for (c = 0; c < 8 && i < len; c++, i++) { 11753 byte = (uchar_t)data[i]; 11754 if (byte < 0x10) 11755 format = "0x0%x "; 11756 else 11757 format = "0x%x "; 11758 (void) sprintf(&buf[(int)strlen(buf)], format, byte); 11759 } 11760 (void) sprintf(&buf[(int)strlen(buf)], "\n"); 11761 11762 scsi_log(dev, label, level, "%s\n", buf); 11763 } 11764 } 11765 11766 /* 11767 * Conditionally enabled debugging 11768 */ 11769 #ifdef STDEBUG 11770 static void 11771 st_debug_cmds(struct scsi_tape *un, int com, int count, int wait) 11772 { 11773 char tmpbuf[64]; 11774 11775 ST_FUNC(ST_DEVINFO, st_debug_cmds); 11776 11777 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 11778 "cmd=%s count=0x%x (%d) %ssync\n", 11779 scsi_cmd_name(com, scsi_cmds, tmpbuf), 11780 count, count, 11781 wait == ASYNC_CMD ? "a" : ""); 11782 } 11783 11784 /* 11785 * Returns pointer to name of minor node name of device 'dev'. 11786 */ 11787 static char * 11788 st_dev_name(dev_t dev) 11789 { 11790 struct scsi_tape *un; 11791 const char density[] = { 'l', 'm', 'h', 'c' }; 11792 static char name[32]; 11793 minor_t minor; 11794 int instance; 11795 int nprt = 0; 11796 11797 minor = getminor(dev); 11798 instance = ((minor & 0xff80) >> 5) | (minor & 3); 11799 un = ddi_get_soft_state(st_state, instance); 11800 if (un) { 11801 ST_FUNC(ST_DEVINFO, st_dev_name); 11802 } 11803 11804 name[nprt] = density[(minor & MT_DENSITY_MASK) >> 3]; 11805 11806 if (minor & MT_BSD) { 11807 name[++nprt] = 'b'; 11808 } 11809 11810 if (minor & MT_NOREWIND) { 11811 name[++nprt] = 'n'; 11812 } 11813 11814 /* NULL terminator */ 11815 name[++nprt] = 0; 11816 11817 return (name); 11818 } 11819 #endif /* STDEBUG */ 11820 11821 /* 11822 * Soft error reporting, so far unique to each drive 11823 * 11824 * Currently supported: exabyte and DAT soft error reporting 11825 */ 11826 static int 11827 st_report_exabyte_soft_errors(dev_t dev, int flag) 11828 { 11829 uchar_t *sensep; 11830 int amt; 11831 int rval = 0; 11832 char cdb[CDB_GROUP0], *c = cdb; 11833 struct uscsi_cmd *com; 11834 11835 GET_SOFT_STATE(dev); 11836 11837 ST_FUNC(ST_DEVINFO, st_report_exabyte_soft_errors); 11838 11839 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 11840 "st_report_exabyte_soft_errors(dev = 0x%lx, flag = %d)\n", 11841 dev, flag); 11842 11843 ASSERT(mutex_owned(ST_MUTEX)); 11844 11845 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 11846 sensep = kmem_zalloc(TAPE_SENSE_LENGTH, KM_SLEEP); 11847 11848 *c++ = SCMD_REQUEST_SENSE; 11849 *c++ = 0; 11850 *c++ = 0; 11851 *c++ = 0; 11852 *c++ = TAPE_SENSE_LENGTH; 11853 /* 11854 * set CLRCNT (byte 5, bit 7 which clears the error counts) 11855 */ 11856 *c = (char)0x80; 11857 11858 com->uscsi_cdb = cdb; 11859 com->uscsi_cdblen = CDB_GROUP0; 11860 com->uscsi_bufaddr = (caddr_t)sensep; 11861 com->uscsi_buflen = TAPE_SENSE_LENGTH; 11862 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 11863 com->uscsi_timeout = un->un_dp->non_motion_timeout; 11864 11865 rval = st_uscsi_cmd(un, com, FKIOCTL); 11866 if (rval || com->uscsi_status) { 11867 goto done; 11868 } 11869 11870 /* 11871 * was there enough data? 11872 */ 11873 amt = (int)TAPE_SENSE_LENGTH - com->uscsi_resid; 11874 11875 if ((amt >= 19) && un->un_kbytes_xferred) { 11876 uint_t count, error_rate; 11877 uint_t rate; 11878 11879 if (sensep[21] & CLN) { 11880 scsi_log(ST_DEVINFO, st_label, CE_WARN, 11881 "Periodic head cleaning required"); 11882 } 11883 if (un->un_kbytes_xferred < (EXABYTE_MIN_TRANSFER/ONE_K)) { 11884 goto done; 11885 } 11886 /* 11887 * check if soft error reporting needs to be done. 11888 */ 11889 count = sensep[16] << 16 | sensep[17] << 8 | sensep[18]; 11890 count &= 0xffffff; 11891 error_rate = (count * 100)/un->un_kbytes_xferred; 11892 11893 #ifdef STDEBUG 11894 if (st_soft_error_report_debug) { 11895 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 11896 "Exabyte Soft Error Report:\n"); 11897 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11898 "read/write error counter: %d\n", count); 11899 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11900 "number of bytes transferred: %dK\n", 11901 un->un_kbytes_xferred); 11902 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11903 "error_rate: %d%%\n", error_rate); 11904 11905 if (amt >= 22) { 11906 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11907 "unit sense: 0x%b 0x%b 0x%b\n", 11908 sensep[19], SENSE_19_BITS, 11909 sensep[20], SENSE_20_BITS, 11910 sensep[21], SENSE_21_BITS); 11911 } 11912 if (amt >= 27) { 11913 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11914 "tracking retry counter: %d\n", 11915 sensep[26]); 11916 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11917 "read/write retry counter: %d\n", 11918 sensep[27]); 11919 } 11920 } 11921 #endif 11922 11923 if (flag & FWRITE) { 11924 rate = EXABYTE_WRITE_ERROR_THRESHOLD; 11925 } else { 11926 rate = EXABYTE_READ_ERROR_THRESHOLD; 11927 } 11928 if (error_rate >= rate) { 11929 scsi_log(ST_DEVINFO, st_label, CE_WARN, 11930 "Soft error rate (%d%%) during %s was too high", 11931 error_rate, 11932 ((flag & FWRITE) ? wrg_str : rdg_str)); 11933 scsi_log(ST_DEVINFO, st_label, CE_CONT, 11934 "Please, replace tape cartridge\n"); 11935 } 11936 } 11937 11938 done: 11939 kmem_free(com, sizeof (*com)); 11940 kmem_free(sensep, TAPE_SENSE_LENGTH); 11941 11942 if (rval != 0) { 11943 scsi_log(ST_DEVINFO, st_label, CE_WARN, 11944 "exabyte soft error reporting failed\n"); 11945 } 11946 return (rval); 11947 } 11948 11949 /* 11950 * this is very specific to Archive 4mm dat 11951 */ 11952 #define ONE_GIG (ONE_K * ONE_K * ONE_K) 11953 11954 static int 11955 st_report_dat_soft_errors(dev_t dev, int flag) 11956 { 11957 uchar_t *sensep; 11958 int amt, i; 11959 int rval = 0; 11960 char cdb[CDB_GROUP1], *c = cdb; 11961 struct uscsi_cmd *com; 11962 11963 GET_SOFT_STATE(dev); 11964 11965 ST_FUNC(ST_DEVINFO, st_report_dat_soft_errors); 11966 11967 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 11968 "st_report_dat_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag); 11969 11970 ASSERT(mutex_owned(ST_MUTEX)); 11971 11972 com = kmem_zalloc(sizeof (*com), KM_SLEEP); 11973 sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP); 11974 11975 *c++ = SCMD_LOG_SENSE_G1; 11976 *c++ = 0; 11977 *c++ = (flag & FWRITE) ? 0x42 : 0x43; 11978 *c++ = 0; 11979 *c++ = 0; 11980 *c++ = 0; 11981 *c++ = 2; 11982 *c++ = 0; 11983 *c++ = (char)LOG_SENSE_LENGTH; 11984 *c = 0; 11985 com->uscsi_cdb = cdb; 11986 com->uscsi_cdblen = CDB_GROUP1; 11987 com->uscsi_bufaddr = (caddr_t)sensep; 11988 com->uscsi_buflen = LOG_SENSE_LENGTH; 11989 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 11990 com->uscsi_timeout = un->un_dp->non_motion_timeout; 11991 rval = st_uscsi_cmd(un, com, FKIOCTL); 11992 if (rval) { 11993 scsi_log(ST_DEVINFO, st_label, CE_WARN, 11994 "DAT soft error reporting failed\n"); 11995 } 11996 if (rval || com->uscsi_status) { 11997 goto done; 11998 } 11999 12000 /* 12001 * was there enough data? 12002 */ 12003 amt = (int)LOG_SENSE_LENGTH - com->uscsi_resid; 12004 12005 if ((amt >= MIN_LOG_SENSE_LENGTH) && un->un_kbytes_xferred) { 12006 int total, retries, param_code; 12007 12008 total = -1; 12009 retries = -1; 12010 amt = sensep[3] + 4; 12011 12012 12013 #ifdef STDEBUG 12014 if (st_soft_error_report_debug) { 12015 (void) printf("logsense:"); 12016 for (i = 0; i < MIN_LOG_SENSE_LENGTH; i++) { 12017 if (i % 16 == 0) { 12018 (void) printf("\t\n"); 12019 } 12020 (void) printf(" %x", sensep[i]); 12021 } 12022 (void) printf("\n"); 12023 } 12024 #endif 12025 12026 /* 12027 * parse the param_codes 12028 */ 12029 if (sensep[0] == 2 || sensep[0] == 3) { 12030 for (i = 4; i < amt; i++) { 12031 param_code = (sensep[i++] << 8); 12032 param_code += sensep[i++]; 12033 i++; /* skip control byte */ 12034 if (param_code == 5) { 12035 if (sensep[i++] == 4) { 12036 total = (sensep[i++] << 24); 12037 total += (sensep[i++] << 16); 12038 total += (sensep[i++] << 8); 12039 total += sensep[i]; 12040 } 12041 } else if (param_code == 0x8007) { 12042 if (sensep[i++] == 2) { 12043 retries = sensep[i++] << 8; 12044 retries += sensep[i]; 12045 } 12046 } else { 12047 i += sensep[i]; 12048 } 12049 } 12050 } 12051 12052 /* 12053 * if the log sense returned valid numbers then determine 12054 * the read and write error thresholds based on the amount of 12055 * data transferred 12056 */ 12057 12058 if (total > 0 && retries > 0) { 12059 short normal_retries = 0; 12060 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 12061 "total xferred (%s) =%x, retries=%x\n", 12062 ((flag & FWRITE) ? wrg_str : rdg_str), 12063 total, retries); 12064 12065 if (flag & FWRITE) { 12066 if (total <= 12067 WRITE_SOFT_ERROR_WARNING_THRESHOLD) { 12068 normal_retries = 12069 DAT_SMALL_WRITE_ERROR_THRESHOLD; 12070 } else { 12071 normal_retries = 12072 DAT_LARGE_WRITE_ERROR_THRESHOLD; 12073 } 12074 } else { 12075 if (total <= 12076 READ_SOFT_ERROR_WARNING_THRESHOLD) { 12077 normal_retries = 12078 DAT_SMALL_READ_ERROR_THRESHOLD; 12079 } else { 12080 normal_retries = 12081 DAT_LARGE_READ_ERROR_THRESHOLD; 12082 } 12083 } 12084 12085 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 12086 "normal retries=%d\n", normal_retries); 12087 12088 if (retries >= normal_retries) { 12089 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12090 "Soft error rate (retries = %d) during " 12091 "%s was too high", retries, 12092 ((flag & FWRITE) ? wrg_str : rdg_str)); 12093 scsi_log(ST_DEVINFO, st_label, CE_CONT, 12094 "Periodic head cleaning required " 12095 "and/or replace tape cartridge\n"); 12096 } 12097 12098 } else if (total == -1 || retries == -1) { 12099 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12100 "log sense parameter code does not make sense\n"); 12101 } 12102 } 12103 12104 /* 12105 * reset all values 12106 */ 12107 c = cdb; 12108 *c++ = SCMD_LOG_SELECT_G1; 12109 *c++ = 2; /* this resets all values */ 12110 *c++ = (char)0xc0; 12111 *c++ = 0; 12112 *c++ = 0; 12113 *c++ = 0; 12114 *c++ = 0; 12115 *c++ = 0; 12116 *c++ = 0; 12117 *c = 0; 12118 com->uscsi_bufaddr = NULL; 12119 com->uscsi_buflen = 0; 12120 com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT; 12121 rval = st_uscsi_cmd(un, com, FKIOCTL); 12122 if (rval) { 12123 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12124 "DAT soft error reset failed\n"); 12125 } 12126 done: 12127 kmem_free(com, sizeof (*com)); 12128 kmem_free(sensep, LOG_SENSE_LENGTH); 12129 return (rval); 12130 } 12131 12132 static int 12133 st_report_soft_errors(dev_t dev, int flag) 12134 { 12135 GET_SOFT_STATE(dev); 12136 12137 ST_FUNC(ST_DEVINFO, st_report_soft_errors); 12138 12139 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12140 "st_report_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag); 12141 12142 ASSERT(mutex_owned(ST_MUTEX)); 12143 12144 switch (un->un_dp->type) { 12145 case ST_TYPE_EXB8500: 12146 case ST_TYPE_EXABYTE: 12147 return (st_report_exabyte_soft_errors(dev, flag)); 12148 /*NOTREACHED*/ 12149 case ST_TYPE_PYTHON: 12150 return (st_report_dat_soft_errors(dev, flag)); 12151 /*NOTREACHED*/ 12152 default: 12153 un->un_dp->options &= ~ST_SOFT_ERROR_REPORTING; 12154 return (-1); 12155 } 12156 } 12157 12158 /* 12159 * persistent error routines 12160 */ 12161 12162 /* 12163 * enable persistent errors, and set the throttle appropriately, checking 12164 * for flush-on-errors capability 12165 */ 12166 static void 12167 st_turn_pe_on(struct scsi_tape *un) 12168 { 12169 ST_FUNC(ST_DEVINFO, st_turn_pe_on); 12170 12171 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_on\n"); 12172 ASSERT(mutex_owned(ST_MUTEX)); 12173 12174 un->un_persistence = 1; 12175 12176 /* 12177 * only use flush-on-errors if auto-request-sense and untagged-qing are 12178 * enabled. This will simplify the error handling for request senses 12179 */ 12180 12181 if (un->un_arq_enabled && un->un_untagged_qing) { 12182 uchar_t f_o_e; 12183 12184 mutex_exit(ST_MUTEX); 12185 f_o_e = (scsi_ifsetcap(ROUTE, "flush-on-errors", 1, 1) == 1) ? 12186 1 : 0; 12187 mutex_enter(ST_MUTEX); 12188 12189 un->un_flush_on_errors = f_o_e; 12190 } else { 12191 un->un_flush_on_errors = 0; 12192 } 12193 12194 if (un->un_flush_on_errors) 12195 un->un_max_throttle = (uchar_t)st_max_throttle; 12196 else 12197 un->un_max_throttle = 1; 12198 12199 if (un->un_dp->options & ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) 12200 un->un_max_throttle = 1; 12201 12202 /* this will send a marker pkt */ 12203 st_clear_pe(un); 12204 } 12205 12206 /* 12207 * This turns persistent errors permanently off 12208 */ 12209 static void 12210 st_turn_pe_off(struct scsi_tape *un) 12211 { 12212 ST_FUNC(ST_DEVINFO, st_turn_pe_off); 12213 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_off\n"); 12214 ASSERT(mutex_owned(ST_MUTEX)); 12215 12216 /* turn it off for good */ 12217 un->un_persistence = 0; 12218 12219 /* this will send a marker pkt */ 12220 st_clear_pe(un); 12221 12222 /* turn off flush on error capability, if enabled */ 12223 if (un->un_flush_on_errors) { 12224 mutex_exit(ST_MUTEX); 12225 (void) scsi_ifsetcap(ROUTE, "flush-on-errors", 0, 1); 12226 mutex_enter(ST_MUTEX); 12227 } 12228 12229 12230 un->un_flush_on_errors = 0; 12231 } 12232 12233 /* 12234 * This clear persistent errors, allowing more commands through, and also 12235 * sending a marker packet. 12236 */ 12237 static void 12238 st_clear_pe(struct scsi_tape *un) 12239 { 12240 ST_FUNC(ST_DEVINFO, st_clear_pe); 12241 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_clear\n"); 12242 ASSERT(mutex_owned(ST_MUTEX)); 12243 12244 un->un_persist_errors = 0; 12245 un->un_throttle = un->un_last_throttle = 1; 12246 un->un_errno = 0; 12247 st_hba_unflush(un); 12248 } 12249 12250 /* 12251 * This will flag persistent errors, shutting everything down, if the 12252 * application had enabled persistent errors via MTIOCPERSISTENT 12253 */ 12254 static void 12255 st_set_pe_flag(struct scsi_tape *un) 12256 { 12257 ST_FUNC(ST_DEVINFO, st_set_pe_flag); 12258 ASSERT(mutex_owned(ST_MUTEX)); 12259 12260 if (un->un_persistence) { 12261 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_flag\n"); 12262 un->un_persist_errors = 1; 12263 un->un_throttle = un->un_last_throttle = 0; 12264 cv_broadcast(&un->un_sbuf_cv); 12265 } 12266 } 12267 12268 static int 12269 st_do_reserve(struct scsi_tape *un) 12270 { 12271 int rval; 12272 12273 ST_FUNC(ST_DEVINFO, st_do_reserve); 12274 12275 /* 12276 * Issue a Throw-Away reserve command to clear the 12277 * check condition. 12278 * If the current behaviour of reserve/release is to 12279 * hold reservation across opens , and if a Bus reset 12280 * has been issued between opens then this command 12281 * would set the ST_LOST_RESERVE flags in rsvd_status. 12282 * In this case return an EACCES so that user knows that 12283 * reservation has been lost in between opens. 12284 * If this error is not returned and we continue with 12285 * successful open , then user may think position of the 12286 * tape is still the same but inreality we would rewind the 12287 * tape and continue from BOT. 12288 */ 12289 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12290 if (rval) { 12291 if ((un->un_rsvd_status & ST_LOST_RESERVE_BETWEEN_OPENS) == 12292 ST_LOST_RESERVE_BETWEEN_OPENS) { 12293 un->un_rsvd_status &= ~(ST_LOST_RESERVE | ST_RESERVE); 12294 un->un_errno = EACCES; 12295 return (EACCES); 12296 } 12297 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12298 } 12299 if (rval == 0) { 12300 un->un_rsvd_status |= ST_INIT_RESERVE; 12301 } 12302 12303 return (rval); 12304 } 12305 12306 static int 12307 st_check_cdb_for_need_to_reserve(struct scsi_tape *un, uchar_t *cdb) 12308 { 12309 int rval; 12310 cmd_attribute const *attrib; 12311 12312 ST_FUNC(ST_DEVINFO, st_check_cdb_for_need_to_reserve); 12313 12314 /* 12315 * If already reserved no need to do it again. 12316 * Also if Reserve and Release are disabled Just return. 12317 */ 12318 if ((un->un_rsvd_status & (ST_APPLICATION_RESERVATIONS)) || 12319 ((un->un_rsvd_status & (ST_RESERVE | ST_LOST_RESERVE)) == 12320 ST_RESERVE) || (un->un_dp->options & ST_NO_RESERVE_RELEASE)) { 12321 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12322 "st_check_cdb_for_need_to_reserve() reserve unneeded %s", 12323 st_print_scsi_cmd((uchar_t)cdb[0])); 12324 return (0); 12325 } 12326 12327 /* See if command is on the list */ 12328 attrib = st_lookup_cmd_attribute(cdb[0]); 12329 12330 if (attrib == NULL) { 12331 rval = 1; /* Not found, when in doubt reserve */ 12332 } else if ((attrib->requires_reserve) != 0) { 12333 rval = 1; 12334 } else if ((attrib->reserve_byte) != 0) { 12335 /* 12336 * cmd is on list. 12337 * if byte is zero always allowed. 12338 */ 12339 rval = 1; 12340 } else if (((cdb[attrib->reserve_byte]) & 12341 (attrib->reserve_mask)) != 0) { 12342 rval = 1; 12343 } else { 12344 rval = 0; 12345 } 12346 12347 if (rval) { 12348 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12349 "Command %s requires reservation", 12350 st_print_scsi_cmd(cdb[0])); 12351 12352 rval = st_do_reserve(un); 12353 } 12354 12355 return (rval); 12356 } 12357 12358 static int 12359 st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd, int cnt) 12360 { 12361 int rval; 12362 cmd_attribute const *attrib; 12363 12364 ST_FUNC(ST_DEVINFO, st_check_cmd_for_need_to_reserve); 12365 12366 if ((un->un_rsvd_status & (ST_APPLICATION_RESERVATIONS)) || 12367 ((un->un_rsvd_status & (ST_RESERVE | ST_LOST_RESERVE)) == 12368 ST_RESERVE) || (un->un_dp->options & ST_NO_RESERVE_RELEASE)) { 12369 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12370 "st_check_cmd_for_need_to_reserve() reserve unneeded %s", 12371 st_print_scsi_cmd(cmd)); 12372 return (0); 12373 } 12374 12375 /* search for this command on the list */ 12376 attrib = st_lookup_cmd_attribute(cmd); 12377 12378 if (attrib == NULL) { 12379 rval = 1; /* Not found, when in doubt reserve */ 12380 } else if ((attrib->requires_reserve) != 0) { 12381 rval = 1; 12382 } else if ((attrib->reserve_byte) != 0) { 12383 /* 12384 * cmd is on list. 12385 * if byte is zero always allowed. 12386 */ 12387 rval = 1; 12388 } else if (((attrib->reserve_mask) & cnt) != 0) { 12389 rval = 1; 12390 } else { 12391 rval = 0; 12392 } 12393 12394 if (rval) { 12395 ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE, 12396 "Cmd %s requires reservation", st_print_scsi_cmd(cmd)); 12397 12398 rval = st_do_reserve(un); 12399 } 12400 12401 return (rval); 12402 } 12403 12404 static int 12405 st_reserve_release(struct scsi_tape *un, int cmd, ubufunc_t ubf) 12406 { 12407 struct uscsi_cmd uscsi_cmd; 12408 int rval; 12409 char cdb[CDB_GROUP0]; 12410 struct scsi_arq_status stat; 12411 12412 12413 12414 ST_FUNC(ST_DEVINFO, st_reserve_release); 12415 12416 ASSERT(mutex_owned(ST_MUTEX)); 12417 12418 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12419 "st_reserve_release: %s \n", 12420 (cmd == ST_RELEASE)? "Releasing":"Reserving"); 12421 12422 bzero(&cdb, CDB_GROUP0); 12423 if (cmd == ST_RELEASE) { 12424 cdb[0] = SCMD_RELEASE; 12425 } else { 12426 cdb[0] = SCMD_RESERVE; 12427 } 12428 bzero(&uscsi_cmd, sizeof (struct uscsi_cmd)); 12429 uscsi_cmd.uscsi_flags = USCSI_WRITE | USCSI_RQENABLE; 12430 uscsi_cmd.uscsi_cdb = cdb; 12431 uscsi_cmd.uscsi_cdblen = CDB_GROUP0; 12432 uscsi_cmd.uscsi_timeout = un->un_dp->non_motion_timeout; 12433 uscsi_cmd.uscsi_rqbuf = (caddr_t)&stat; 12434 uscsi_cmd.uscsi_rqlen = sizeof (stat); 12435 12436 rval = ubf(un, &uscsi_cmd, FKIOCTL); 12437 12438 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12439 "st_reserve_release: rval(1)=%d\n", rval); 12440 12441 if (rval) { 12442 if (uscsi_cmd.uscsi_status == STATUS_RESERVATION_CONFLICT) { 12443 rval = EACCES; 12444 } 12445 /* 12446 * dynamically turn off reserve/release support 12447 * in case of drives which do not support 12448 * reserve/release command(ATAPI drives). 12449 */ 12450 if (un->un_status == KEY_ILLEGAL_REQUEST) { 12451 if (un->un_dp->options & ST_NO_RESERVE_RELEASE) { 12452 un->un_dp->options |= ST_NO_RESERVE_RELEASE; 12453 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12454 "Tape unit does not support " 12455 "reserve/release \n"); 12456 } 12457 rval = 0; 12458 } 12459 } 12460 return (rval); 12461 } 12462 12463 static int 12464 st_take_ownership(struct scsi_tape *un) 12465 { 12466 int rval; 12467 12468 ST_FUNC(ST_DEVINFO, st_take_ownership); 12469 12470 ASSERT(mutex_owned(ST_MUTEX)); 12471 12472 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 12473 "st_take_ownership: Entering ...\n"); 12474 12475 12476 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12477 /* 12478 * XXX -> Should reset be done only if we get EACCES. 12479 * . 12480 */ 12481 if (rval) { 12482 if (st_reset(un, RESET_LUN) == 0) { 12483 return (EIO); 12484 } 12485 un->un_rsvd_status &= 12486 ~(ST_LOST_RESERVE | ST_RESERVATION_CONFLICT); 12487 12488 mutex_exit(ST_MUTEX); 12489 delay(drv_usectohz(ST_RESERVATION_DELAY)); 12490 mutex_enter(ST_MUTEX); 12491 /* 12492 * remove the check condition. 12493 */ 12494 (void) st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12495 rval = st_reserve_release(un, ST_RESERVE, st_uscsi_cmd); 12496 if (rval != 0) { 12497 if ((st_reserve_release(un, ST_RESERVE, st_uscsi_cmd)) 12498 != 0) { 12499 rval = (un->un_rsvd_status & 12500 ST_RESERVATION_CONFLICT) ? EACCES : EIO; 12501 return (rval); 12502 } 12503 } 12504 /* 12505 * Set tape state to ST_STATE_OFFLINE , in case if 12506 * the user wants to continue and start using 12507 * the tape. 12508 */ 12509 un->un_state = ST_STATE_OFFLINE; 12510 un->un_rsvd_status |= ST_INIT_RESERVE; 12511 } 12512 return (rval); 12513 } 12514 12515 static int 12516 st_create_errstats(struct scsi_tape *un, int instance) 12517 { 12518 char kstatname[KSTAT_STRLEN]; 12519 12520 ST_FUNC(ST_DEVINFO, st_create_errstats); 12521 12522 /* 12523 * Create device error kstats 12524 */ 12525 12526 if (un->un_errstats == (kstat_t *)0) { 12527 (void) sprintf(kstatname, "st%d,err", instance); 12528 un->un_errstats = kstat_create("sterr", instance, kstatname, 12529 "device_error", KSTAT_TYPE_NAMED, 12530 sizeof (struct st_errstats) / sizeof (kstat_named_t), 12531 KSTAT_FLAG_PERSISTENT); 12532 12533 if (un->un_errstats) { 12534 struct st_errstats *stp; 12535 12536 stp = (struct st_errstats *)un->un_errstats->ks_data; 12537 kstat_named_init(&stp->st_softerrs, "Soft Errors", 12538 KSTAT_DATA_ULONG); 12539 kstat_named_init(&stp->st_harderrs, "Hard Errors", 12540 KSTAT_DATA_ULONG); 12541 kstat_named_init(&stp->st_transerrs, "Transport Errors", 12542 KSTAT_DATA_ULONG); 12543 kstat_named_init(&stp->st_vid, "Vendor", 12544 KSTAT_DATA_CHAR); 12545 kstat_named_init(&stp->st_pid, "Product", 12546 KSTAT_DATA_CHAR); 12547 kstat_named_init(&stp->st_revision, "Revision", 12548 KSTAT_DATA_CHAR); 12549 kstat_named_init(&stp->st_serial, "Serial No", 12550 KSTAT_DATA_CHAR); 12551 un->un_errstats->ks_private = un; 12552 un->un_errstats->ks_update = nulldev; 12553 kstat_install(un->un_errstats); 12554 /* 12555 * Fill in the static data 12556 */ 12557 (void) strncpy(&stp->st_vid.value.c[0], 12558 ST_INQUIRY->inq_vid, 8); 12559 /* 12560 * XXX: Emulex MT-02 (and emulators) predates 12561 * SCSI-1 and has no vid & pid inquiry data. 12562 */ 12563 if (ST_INQUIRY->inq_len != 0) { 12564 (void) strncpy(&stp->st_pid.value.c[0], 12565 ST_INQUIRY->inq_pid, 16); 12566 (void) strncpy(&stp->st_revision.value.c[0], 12567 ST_INQUIRY->inq_revision, 4); 12568 (void) strncpy(&stp->st_serial.value.c[0], 12569 ST_INQUIRY->inq_serial, 12); 12570 } 12571 } 12572 } 12573 return (0); 12574 } 12575 12576 static int 12577 st_validate_tapemarks(struct scsi_tape *un, ubufunc_t ubf, tapepos_t *pos) 12578 { 12579 int rval; 12580 bufunc_t bf = (ubf == st_uscsi_rcmd) ? st_rcmd : st_cmd; 12581 12582 ST_FUNC(ST_DEVINFO, st_validate_tapemarks); 12583 12584 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 12585 ASSERT(mutex_owned(ST_MUTEX)); 12586 12587 /* Can't restore an invalid position */ 12588 if (pos->pmode == invalid) { 12589 return (4); 12590 } 12591 12592 /* 12593 * Assumtions: 12594 * If a position was read and is in logical position mode. 12595 * If a drive supports read position it supports locate. 12596 * If the read position type is not NO_POS. even though 12597 * a read position make not have been attemped yet. 12598 * 12599 * The drive can locate to the position. 12600 */ 12601 if (pos->pmode == logical || un->un_read_pos_type != NO_POS) { 12602 /* 12603 * If position mode is logical or legacy mode try 12604 * to locate there as it is faster. 12605 * If it fails try the old way. 12606 */ 12607 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 12608 "Restoring tape position to lgclblkbo=0x%"PRIx64"....", 12609 pos->lgclblkno); 12610 12611 if (st_logical_block_locate(un, st_uscsi_cmd, &un->un_pos, 12612 pos->lgclblkno, pos->partition) == 0) { 12613 /* Assume we are there copy rest of position back */ 12614 if (un->un_pos.lgclblkno == pos->lgclblkno) { 12615 COPY_POS(&un->un_pos, pos); 12616 } 12617 return (0); 12618 } 12619 12620 /* 12621 * If logical block locate failed to restore a logical 12622 * position, can't recover. 12623 */ 12624 if (pos->pmode == logical) { 12625 return (-1); 12626 } 12627 } 12628 12629 12630 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 12631 "Restoring tape position at fileno=%x, blkno=%x....", 12632 pos->fileno, pos->blkno); 12633 12634 /* 12635 * Rewind ? Oh yeah, Fidelity has got the STK F/W changed 12636 * so as not to rewind tape on RESETS: Gee, Has life ever 12637 * been simple in tape land ? 12638 */ 12639 rval = bf(un, SCMD_REWIND, 0, SYNC_CMD); 12640 if (rval) { 12641 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12642 "Failed to restore the last file and block position: In" 12643 " this state, Tape will be loaded at BOT during next open"); 12644 un->un_pos.pmode = invalid; 12645 return (rval); 12646 } 12647 12648 /* If the position was as the result of back space file */ 12649 if (pos->blkno > (INF / 2)) { 12650 /* Go one extra file forward */ 12651 pos->fileno++; 12652 /* Figure how many blocks to back into the previous file */ 12653 pos->blkno = -(INF - pos->blkno); 12654 } 12655 12656 /* Go to requested fileno */ 12657 if (pos->fileno) { 12658 rval = st_cmd(un, SCMD_SPACE, Fmk(pos->fileno), SYNC_CMD); 12659 if (rval) { 12660 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12661 "Failed to restore the last file position: In this " 12662 " state, Tape will be loaded at BOT during next" 12663 " open %d", __LINE__); 12664 un->un_pos.pmode = invalid; 12665 pos->pmode = invalid; 12666 return (rval); 12667 } 12668 } 12669 12670 /* 12671 * If backing into a file we already did an extra file forward. 12672 * Now we have to back over the filemark to get to the end of 12673 * the previous file. The blkno has been ajusted to a negative 12674 * value so we will get to the expected location. 12675 */ 12676 if (pos->blkno) { 12677 rval = bf(un, SCMD_SPACE, Fmk(-1), SYNC_CMD); 12678 if (rval) { 12679 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12680 "Failed to restore the last file position: In this " 12681 " state, Tape will be loaded at BOT during next" 12682 " open %d", __LINE__); 12683 un->un_pos.pmode = invalid; 12684 pos->pmode = invalid; 12685 return (rval); 12686 } 12687 } 12688 12689 /* 12690 * The position mode, block and fileno should be correct, 12691 * This updates eof and logical position information. 12692 */ 12693 un->un_pos.eof = pos->eof; 12694 un->un_pos.lgclblkno = pos->lgclblkno; 12695 12696 return (0); 12697 } 12698 12699 /* 12700 * check sense key, ASC, ASCQ in order to determine if the tape needs 12701 * to be ejected 12702 */ 12703 12704 static int 12705 st_check_asc_ascq(struct scsi_tape *un) 12706 { 12707 struct scsi_extended_sense *sensep = ST_RQSENSE; 12708 struct tape_failure_code *code; 12709 12710 ST_FUNC(ST_DEVINFO, st_check_asc_ascq); 12711 12712 for (code = st_tape_failure_code; code->key != 0xff; code++) { 12713 if ((code->key == sensep->es_key) && 12714 (code->add_code == sensep->es_add_code) && 12715 (code->qual_code == sensep->es_qual_code)) 12716 return (1); 12717 } 12718 return (0); 12719 } 12720 12721 /* 12722 * st_logpage_supported() sends a Log Sense command with 12723 * page code = 0 = Supported Log Pages Page to the device, 12724 * to see whether the page 'page' is supported. 12725 * Return values are: 12726 * -1 if the Log Sense command fails 12727 * 0 if page is not supported 12728 * 1 if page is supported 12729 */ 12730 12731 static int 12732 st_logpage_supported(struct scsi_tape *un, uchar_t page) 12733 { 12734 uchar_t *sp, *sensep; 12735 unsigned length; 12736 struct uscsi_cmd *com; 12737 int rval; 12738 char cdb[CDB_GROUP1] = { 12739 SCMD_LOG_SENSE_G1, 12740 0, 12741 SUPPORTED_LOG_PAGES_PAGE, 12742 0, 12743 0, 12744 0, 12745 0, 12746 0, 12747 (char)LOG_SENSE_LENGTH, 12748 0 12749 }; 12750 12751 ST_FUNC(ST_DEVINFO, st_logpage_supported); 12752 12753 ASSERT(mutex_owned(ST_MUTEX)); 12754 12755 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 12756 sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP); 12757 12758 com->uscsi_cdb = cdb; 12759 com->uscsi_cdblen = CDB_GROUP1; 12760 com->uscsi_bufaddr = (caddr_t)sensep; 12761 com->uscsi_buflen = LOG_SENSE_LENGTH; 12762 com->uscsi_flags = 12763 USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 12764 com->uscsi_timeout = un->un_dp->non_motion_timeout; 12765 rval = st_uscsi_cmd(un, com, FKIOCTL); 12766 if (rval || com->uscsi_status) { 12767 /* uscsi-command failed */ 12768 rval = -1; 12769 } else { 12770 12771 sp = sensep + 3; 12772 12773 for (length = *sp++; length > 0; length--, sp++) { 12774 12775 if (*sp == page) { 12776 rval = 1; 12777 break; 12778 } 12779 } 12780 } 12781 kmem_free(com, sizeof (struct uscsi_cmd)); 12782 kmem_free(sensep, LOG_SENSE_LENGTH); 12783 return (rval); 12784 } 12785 12786 12787 /* 12788 * st_check_clean_bit() gets the status of the tape's cleaning bit. 12789 * 12790 * If the device does support the TapeAlert log page, then the cleaning bit 12791 * information will be read from this page. Otherwise we will see if one of 12792 * ST_CLN_TYPE_1, ST_CLN_TYPE_2 or ST_CLN_TYPE_3 is set in the properties of 12793 * the device, which means, that we can get the cleaning bit information via 12794 * a RequestSense command. 12795 * If both methods of getting cleaning bit information are not supported 12796 * st_check_clean_bit() will return with 0. Otherwise st_check_clean_bit() 12797 * returns with 12798 * - MTF_TAPE_CLN_SUPPORTED if cleaning bit is not set or 12799 * - MTF_TAPE_CLN_SUPPORTED | MTF_TAPE_HEAD_DIRTY if cleaning bit is set. 12800 * If the call to st_uscsi_cmd() to do the Log Sense or the Request Sense 12801 * command fails, or if the amount of Request Sense data is not enough, then 12802 * st_check_clean_bit() returns with -1. 12803 */ 12804 12805 static int 12806 st_check_clean_bit(struct scsi_tape *un) 12807 { 12808 int rval = 0; 12809 12810 ST_FUNC(ST_DEVINFO, st_check_clean_bit); 12811 12812 ASSERT(mutex_owned(ST_MUTEX)); 12813 12814 if (un->un_HeadClean & TAPE_ALERT_NOT_SUPPORTED) { 12815 return (rval); 12816 } 12817 12818 if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) { 12819 12820 rval = st_logpage_supported(un, TAPE_SEQUENTIAL_PAGE); 12821 if (rval == 1) { 12822 12823 un->un_HeadClean |= TAPE_SEQUENTIAL_SUPPORTED; 12824 } 12825 12826 rval = st_logpage_supported(un, TAPE_ALERT_PAGE); 12827 if (rval == 1) { 12828 12829 un->un_HeadClean |= TAPE_ALERT_SUPPORTED; 12830 } 12831 12832 if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) { 12833 12834 un->un_HeadClean = TAPE_ALERT_NOT_SUPPORTED; 12835 } 12836 } 12837 12838 rval = 0; 12839 12840 if (un->un_HeadClean & TAPE_SEQUENTIAL_SUPPORTED) { 12841 12842 rval = st_check_sequential_clean_bit(un); 12843 } 12844 12845 if ((rval <= 0) && (un->un_HeadClean & TAPE_ALERT_SUPPORTED)) { 12846 12847 rval = st_check_alert_flags(un); 12848 } 12849 12850 if ((rval <= 0) && (un->un_dp->options & ST_CLN_MASK)) { 12851 12852 rval = st_check_sense_clean_bit(un); 12853 } 12854 12855 if (rval < 0) { 12856 return (rval); 12857 } 12858 12859 /* 12860 * If found a supported means to check need to clean. 12861 */ 12862 if (rval & MTF_TAPE_CLN_SUPPORTED) { 12863 12864 /* 12865 * head needs to be cleaned. 12866 */ 12867 if (rval & MTF_TAPE_HEAD_DIRTY) { 12868 12869 /* 12870 * Print log message only first time 12871 * found needing cleaned. 12872 */ 12873 if ((un->un_HeadClean & TAPE_PREVIOUSLY_DIRTY) == 0) { 12874 12875 scsi_log(ST_DEVINFO, st_label, CE_WARN, 12876 "Periodic head cleaning required"); 12877 12878 un->un_HeadClean |= TAPE_PREVIOUSLY_DIRTY; 12879 } 12880 12881 } else { 12882 12883 un->un_HeadClean &= ~TAPE_PREVIOUSLY_DIRTY; 12884 } 12885 } 12886 12887 return (rval); 12888 } 12889 12890 12891 static int 12892 st_check_sequential_clean_bit(struct scsi_tape *un) 12893 { 12894 int rval; 12895 int ix; 12896 ushort_t parameter; 12897 struct uscsi_cmd *cmd; 12898 struct log_sequential_page *sp; 12899 struct log_sequential_page_parameter *prm; 12900 char cdb[CDB_GROUP1] = { 12901 SCMD_LOG_SENSE_G1, 12902 0, 12903 TAPE_SEQUENTIAL_PAGE | CURRENT_CUMULATIVE_VALUES, 12904 0, 12905 0, 12906 0, 12907 0, 12908 (char)(sizeof (struct log_sequential_page) >> 8), 12909 (char)(sizeof (struct log_sequential_page)), 12910 0 12911 }; 12912 12913 ST_FUNC(ST_DEVINFO, st_check_sequential_clean_bit); 12914 12915 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 12916 sp = kmem_zalloc(sizeof (struct log_sequential_page), KM_SLEEP); 12917 12918 cmd->uscsi_flags = 12919 USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 12920 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 12921 cmd->uscsi_cdb = cdb; 12922 cmd->uscsi_cdblen = CDB_GROUP1; 12923 cmd->uscsi_bufaddr = (caddr_t)sp; 12924 cmd->uscsi_buflen = sizeof (struct log_sequential_page); 12925 12926 rval = st_uscsi_cmd(un, cmd, FKIOCTL); 12927 12928 if (rval || cmd->uscsi_status || cmd->uscsi_resid) { 12929 12930 rval = -1; 12931 12932 } else if (sp->log_page.code != TAPE_SEQUENTIAL_PAGE) { 12933 12934 rval = -1; 12935 } 12936 12937 prm = &sp->param[0]; 12938 12939 for (ix = 0; rval == 0 && ix < TAPE_SEQUENTIAL_PAGE_PARA; ix++) { 12940 12941 if (prm->log_param.length == 0) { 12942 break; 12943 } 12944 12945 parameter = (((prm->log_param.pc_hi << 8) & 0xff00) + 12946 (prm->log_param.pc_lo & 0xff)); 12947 12948 if (parameter == SEQUENTIAL_NEED_CLN) { 12949 12950 rval = MTF_TAPE_CLN_SUPPORTED; 12951 if (prm->param_value[prm->log_param.length - 1]) { 12952 12953 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 12954 "sequential log says head dirty\n"); 12955 rval |= MTF_TAPE_HEAD_DIRTY; 12956 } 12957 } 12958 prm = (struct log_sequential_page_parameter *) 12959 &prm->param_value[prm->log_param.length]; 12960 } 12961 12962 kmem_free(cmd, sizeof (struct uscsi_cmd)); 12963 kmem_free(sp, sizeof (struct log_sequential_page)); 12964 12965 return (rval); 12966 } 12967 12968 12969 static int 12970 st_check_alert_flags(struct scsi_tape *un) 12971 { 12972 struct st_tape_alert *ta; 12973 struct uscsi_cmd *com; 12974 unsigned ix, length; 12975 int rval; 12976 tape_alert_flags flag; 12977 char cdb[CDB_GROUP1] = { 12978 SCMD_LOG_SENSE_G1, 12979 0, 12980 TAPE_ALERT_PAGE | CURRENT_THRESHOLD_VALUES, 12981 0, 12982 0, 12983 0, 12984 0, 12985 (char)(sizeof (struct st_tape_alert) >> 8), 12986 (char)(sizeof (struct st_tape_alert)), 12987 0 12988 }; 12989 12990 ST_FUNC(ST_DEVINFO, st_check_alert_clean_bit); 12991 12992 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 12993 ta = kmem_zalloc(sizeof (struct st_tape_alert), KM_SLEEP); 12994 12995 com->uscsi_cdb = cdb; 12996 com->uscsi_cdblen = CDB_GROUP1; 12997 com->uscsi_bufaddr = (caddr_t)ta; 12998 com->uscsi_buflen = sizeof (struct st_tape_alert); 12999 com->uscsi_flags = 13000 USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 13001 com->uscsi_timeout = un->un_dp->non_motion_timeout; 13002 13003 rval = st_uscsi_cmd(un, com, FKIOCTL); 13004 13005 if (rval || com->uscsi_status || com->uscsi_resid) { 13006 13007 rval = -1; /* uscsi-command failed */ 13008 13009 } else if (ta->log_page.code != TAPE_ALERT_PAGE) { 13010 13011 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13012 "Not Alert Log Page returned 0x%X\n", ta->log_page.code); 13013 rval = -1; 13014 } 13015 13016 length = (ta->log_page.length_hi << 8) + ta->log_page.length_lo; 13017 13018 13019 if (length != TAPE_ALERT_PARAMETER_LENGTH) { 13020 13021 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13022 "TapeAlert length %d\n", length); 13023 } 13024 13025 13026 for (ix = 0; ix < TAPE_ALERT_MAX_PARA; ix++) { 13027 13028 /* 13029 * if rval is bad before the first pass don't bother 13030 */ 13031 if (ix == 0 && rval != 0) { 13032 13033 break; 13034 } 13035 13036 flag = ((ta->param[ix].log_param.pc_hi << 8) + 13037 ta->param[ix].log_param.pc_lo); 13038 13039 if ((ta->param[ix].param_value & 1) == 0) { 13040 continue; 13041 } 13042 /* 13043 * check to see if current parameter is of interest. 13044 * CLEAN_FOR_ERRORS is vendor specific to 9840 9940 stk's. 13045 */ 13046 if ((flag == TAF_CLEAN_NOW) || 13047 (flag == TAF_CLEAN_PERIODIC) || 13048 ((flag == CLEAN_FOR_ERRORS) && 13049 (un->un_dp->type == ST_TYPE_STK9840))) { 13050 13051 rval = MTF_TAPE_CLN_SUPPORTED; 13052 13053 13054 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13055 "alert_page drive needs clean %d\n", flag); 13056 un->un_HeadClean |= TAPE_ALERT_STILL_DIRTY; 13057 rval |= MTF_TAPE_HEAD_DIRTY; 13058 13059 } else if (flag == TAF_CLEANING_MEDIA) { 13060 13061 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13062 "alert_page drive was cleaned\n"); 13063 un->un_HeadClean &= ~TAPE_ALERT_STILL_DIRTY; 13064 } 13065 13066 } 13067 13068 /* 13069 * Report it as dirty till we see it cleaned 13070 */ 13071 if (un->un_HeadClean & TAPE_ALERT_STILL_DIRTY) { 13072 13073 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13074 "alert_page still dirty\n"); 13075 rval |= MTF_TAPE_HEAD_DIRTY; 13076 } 13077 13078 kmem_free(com, sizeof (struct uscsi_cmd)); 13079 kmem_free(ta, sizeof (struct st_tape_alert)); 13080 13081 return (rval); 13082 } 13083 13084 13085 static int 13086 st_check_sense_clean_bit(struct scsi_tape *un) 13087 { 13088 uchar_t *sensep; 13089 char cdb[CDB_GROUP0]; 13090 struct uscsi_cmd *com; 13091 ushort_t byte_pos; 13092 uchar_t bit_mask; 13093 unsigned length; 13094 int index; 13095 int rval; 13096 13097 ST_FUNC(ST_DEVINFO, st_check_sense_clean_bit); 13098 13099 /* 13100 * Since this tape does not support Tape Alert, 13101 * we now try to get the cleanbit status via 13102 * Request Sense. 13103 */ 13104 13105 if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_1) { 13106 13107 index = 0; 13108 13109 } else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_2) { 13110 13111 index = 1; 13112 13113 } else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_3) { 13114 13115 index = 2; 13116 13117 } else { 13118 13119 return (-1); 13120 } 13121 13122 byte_pos = st_cln_bit_position[index].cln_bit_byte; 13123 bit_mask = st_cln_bit_position[index].cln_bit_mask; 13124 length = byte_pos + 1; 13125 13126 com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13127 sensep = kmem_zalloc(length, KM_SLEEP); 13128 13129 cdb[0] = SCMD_REQUEST_SENSE; 13130 cdb[1] = 0; 13131 cdb[2] = 0; 13132 cdb[3] = 0; 13133 cdb[4] = (char)length; 13134 cdb[5] = 0; 13135 13136 com->uscsi_cdb = cdb; 13137 com->uscsi_cdblen = CDB_GROUP0; 13138 com->uscsi_bufaddr = (caddr_t)sensep; 13139 com->uscsi_buflen = length; 13140 com->uscsi_flags = 13141 USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ; 13142 com->uscsi_timeout = un->un_dp->non_motion_timeout; 13143 13144 rval = st_uscsi_cmd(un, com, FKIOCTL); 13145 13146 if (rval || com->uscsi_status || com->uscsi_resid) { 13147 13148 rval = -1; 13149 13150 } else { 13151 13152 rval = MTF_TAPE_CLN_SUPPORTED; 13153 if ((sensep[byte_pos] & bit_mask) == bit_mask) { 13154 13155 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13156 "sense data says head dirty\n"); 13157 rval |= MTF_TAPE_HEAD_DIRTY; 13158 } 13159 } 13160 13161 kmem_free(com, sizeof (struct uscsi_cmd)); 13162 kmem_free(sensep, length); 13163 return (rval); 13164 } 13165 13166 /* 13167 * st_clear_unit_attention 13168 * 13169 * run test unit ready's to clear out outstanding 13170 * unit attentions. 13171 * returns zero for SUCCESS or the errno from st_cmd call 13172 */ 13173 static int 13174 st_clear_unit_attentions(dev_t dev_instance, int max_trys) 13175 { 13176 int i = 0; 13177 int rval; 13178 13179 GET_SOFT_STATE(dev_instance); 13180 ST_FUNC(ST_DEVINFO, st_clear_unit_attentions); 13181 13182 do { 13183 rval = st_cmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 13184 } while ((rval != 0) && (rval != ENXIO) && (++i < max_trys)); 13185 return (rval); 13186 } 13187 13188 static void 13189 st_calculate_timeouts(struct scsi_tape *un) 13190 { 13191 ST_FUNC(ST_DEVINFO, st_calculate_timeouts); 13192 13193 if (un->un_dp->non_motion_timeout == 0) { 13194 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13195 un->un_dp->non_motion_timeout = 13196 st_io_time * st_long_timeout_x; 13197 } else { 13198 un->un_dp->non_motion_timeout = (ushort_t)st_io_time; 13199 } 13200 } 13201 13202 if (un->un_dp->io_timeout == 0) { 13203 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13204 un->un_dp->io_timeout = st_io_time * st_long_timeout_x; 13205 } else { 13206 un->un_dp->io_timeout = (ushort_t)st_io_time; 13207 } 13208 } 13209 13210 if (un->un_dp->rewind_timeout == 0) { 13211 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13212 un->un_dp->rewind_timeout = 13213 st_space_time * st_long_timeout_x; 13214 } else { 13215 un->un_dp->rewind_timeout = (ushort_t)st_space_time; 13216 } 13217 } 13218 13219 if (un->un_dp->space_timeout == 0) { 13220 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13221 un->un_dp->space_timeout = 13222 st_space_time * st_long_timeout_x; 13223 } else { 13224 un->un_dp->space_timeout = (ushort_t)st_space_time; 13225 } 13226 } 13227 13228 if (un->un_dp->load_timeout == 0) { 13229 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13230 un->un_dp->load_timeout = 13231 st_space_time * st_long_timeout_x; 13232 } else { 13233 un->un_dp->load_timeout = (ushort_t)st_space_time; 13234 } 13235 } 13236 13237 if (un->un_dp->unload_timeout == 0) { 13238 if (un->un_dp->options & ST_LONG_TIMEOUTS) { 13239 un->un_dp->unload_timeout = 13240 st_space_time * st_long_timeout_x; 13241 } else { 13242 un->un_dp->unload_timeout = (ushort_t)st_space_time; 13243 } 13244 } 13245 13246 if (un->un_dp->erase_timeout == 0) { 13247 if (un->un_dp->options & ST_LONG_ERASE) { 13248 un->un_dp->erase_timeout = 13249 st_space_time * st_long_space_time_x; 13250 } else { 13251 un->un_dp->erase_timeout = (ushort_t)st_space_time; 13252 } 13253 } 13254 } 13255 13256 13257 static writablity 13258 st_is_not_wormable(struct scsi_tape *un) 13259 { 13260 ST_FUNC(ST_DEVINFO, st_is_not_wormable); 13261 return (RDWR); 13262 } 13263 13264 static writablity 13265 st_is_hp_dat_tape_worm(struct scsi_tape *un) 13266 { 13267 writablity wrt; 13268 13269 ST_FUNC(ST_DEVINFO, st_is_hp_dat_tape_worm); 13270 13271 /* Mode sense should be current */ 13272 if (un->un_mspl->media_type == 1) { 13273 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13274 "Drive has WORM media loaded\n"); 13275 wrt = WORM; 13276 } else { 13277 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13278 "Drive has non WORM media loaded\n"); 13279 wrt = RDWR; 13280 } 13281 return (wrt); 13282 } 13283 13284 #define HP_DAT_INQUIRY 0x4A 13285 static writablity 13286 st_is_hp_dat_worm(struct scsi_tape *un) 13287 { 13288 char *buf; 13289 int result; 13290 writablity wrt; 13291 13292 ST_FUNC(ST_DEVINFO, st_is_hp_dat_worm); 13293 13294 buf = kmem_zalloc(HP_DAT_INQUIRY, KM_SLEEP); 13295 13296 result = st_get_special_inquiry(un, HP_DAT_INQUIRY, buf, 0); 13297 13298 if (result != 0) { 13299 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13300 "Read Standard Inquiry for WORM support failed"); 13301 wrt = FAILED; 13302 } else if ((buf[40] & 1) == 0) { 13303 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13304 "Drive is NOT WORMable\n"); 13305 /* This drive doesn't support it so don't check again */ 13306 un->un_dp->options &= ~ST_WORMABLE; 13307 wrt = RDWR; 13308 un->un_wormable = st_is_not_wormable; 13309 } else { 13310 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13311 "Drive supports WORM version %d\n", buf[40] >> 1); 13312 un->un_wormable = st_is_hp_dat_tape_worm; 13313 wrt = un->un_wormable(un); 13314 } 13315 13316 kmem_free(buf, HP_DAT_INQUIRY); 13317 13318 /* 13319 * If drive doesn't support it no point in checking further. 13320 */ 13321 return (wrt); 13322 } 13323 13324 static writablity 13325 st_is_hp_lto_tape_worm(struct scsi_tape *un) 13326 { 13327 writablity wrt; 13328 13329 ST_FUNC(ST_DEVINFO, st_is_hp_lto_tape_worm); 13330 13331 /* Mode sense should be current */ 13332 switch (un->un_mspl->media_type) { 13333 case 0x00: 13334 switch (un->un_mspl->density) { 13335 case 0x40: 13336 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13337 "Drive has standard Gen I media loaded\n"); 13338 break; 13339 case 0x42: 13340 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13341 "Drive has standard Gen II media loaded\n"); 13342 break; 13343 case 0x44: 13344 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13345 "Drive has standard Gen III media loaded\n"); 13346 break; 13347 case 0x46: 13348 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13349 "Drive has standard Gen IV media loaded\n"); 13350 break; 13351 default: 13352 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13353 "Drive has standard unknown 0x%X media loaded\n", 13354 un->un_mspl->density); 13355 } 13356 wrt = RDWR; 13357 break; 13358 case 0x01: 13359 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13360 "Drive has WORM medium loaded\n"); 13361 wrt = WORM; 13362 break; 13363 case 0x80: 13364 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13365 "Drive has CD-ROM emulation medium loaded\n"); 13366 wrt = WORM; 13367 break; 13368 default: 13369 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13370 "Drive has an unexpected medium type 0x%X loaded\n", 13371 un->un_mspl->media_type); 13372 wrt = RDWR; 13373 } 13374 13375 return (wrt); 13376 } 13377 13378 #define LTO_REQ_INQUIRY 44 13379 static writablity 13380 st_is_hp_lto_worm(struct scsi_tape *un) 13381 { 13382 char *buf; 13383 int result; 13384 writablity wrt; 13385 13386 ST_FUNC(ST_DEVINFO, st_is_hp_lto_worm); 13387 13388 buf = kmem_zalloc(LTO_REQ_INQUIRY, KM_SLEEP); 13389 13390 result = st_get_special_inquiry(un, LTO_REQ_INQUIRY, buf, 0); 13391 13392 if (result != 0) { 13393 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13394 "Read Standard Inquiry for WORM support failed"); 13395 wrt = FAILED; 13396 } else if ((buf[40] & 1) == 0) { 13397 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13398 "Drive is NOT WORMable\n"); 13399 /* This drive doesn't support it so don't check again */ 13400 un->un_dp->options &= ~ST_WORMABLE; 13401 wrt = RDWR; 13402 un->un_wormable = st_is_not_wormable; 13403 } else { 13404 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13405 "Drive supports WORM version %d\n", buf[40] >> 1); 13406 un->un_wormable = st_is_hp_lto_tape_worm; 13407 wrt = un->un_wormable(un); 13408 } 13409 13410 kmem_free(buf, LTO_REQ_INQUIRY); 13411 13412 /* 13413 * If drive doesn't support it no point in checking further. 13414 */ 13415 return (wrt); 13416 } 13417 13418 static writablity 13419 st_is_t10_worm_device(struct scsi_tape *un) 13420 { 13421 writablity wrt; 13422 13423 ST_FUNC(ST_DEVINFO, st_is_t10_worm_device); 13424 13425 if (un->un_mspl->media_type == 0x3c) { 13426 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13427 "Drive has WORM media loaded\n"); 13428 wrt = WORM; 13429 } else { 13430 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13431 "Drive has non WORM media loaded\n"); 13432 wrt = RDWR; 13433 } 13434 return (wrt); 13435 } 13436 13437 #define SEQ_CAP_PAGE (char)0xb0 13438 static writablity 13439 st_is_t10_worm(struct scsi_tape *un) 13440 { 13441 char *buf; 13442 int result; 13443 writablity wrt; 13444 13445 ST_FUNC(ST_DEVINFO, st_is_t10_worm); 13446 13447 buf = kmem_zalloc(6, KM_SLEEP); 13448 13449 result = st_get_special_inquiry(un, 6, buf, SEQ_CAP_PAGE); 13450 13451 if (result != 0) { 13452 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13453 "Read Vitial Inquiry for Sequental Capability" 13454 " WORM support failed %x", result); 13455 wrt = FAILED; 13456 } else if ((buf[4] & 1) == 0) { 13457 ASSERT(buf[1] == SEQ_CAP_PAGE); 13458 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13459 "Drive is NOT WORMable\n"); 13460 /* This drive doesn't support it so don't check again */ 13461 un->un_dp->options &= ~ST_WORMABLE; 13462 wrt = RDWR; 13463 un->un_wormable = st_is_not_wormable; 13464 } else { 13465 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13466 "Drive supports WORM\n"); 13467 un->un_wormable = st_is_t10_worm_device; 13468 wrt = un->un_wormable(un); 13469 } 13470 13471 kmem_free(buf, 6); 13472 13473 return (wrt); 13474 } 13475 13476 13477 #define STK_REQ_SENSE 26 13478 13479 static writablity 13480 st_is_stk_worm(struct scsi_tape *un) 13481 { 13482 char cdb[CDB_GROUP0] = {SCMD_REQUEST_SENSE, 0, 0, 0, STK_REQ_SENSE, 0}; 13483 struct scsi_extended_sense *sense; 13484 struct uscsi_cmd *cmd; 13485 char *buf; 13486 int result; 13487 writablity wrt; 13488 13489 ST_FUNC(ST_DEVINFO, st_is_stk_worm); 13490 13491 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13492 buf = kmem_alloc(STK_REQ_SENSE, KM_SLEEP); 13493 sense = (struct scsi_extended_sense *)buf; 13494 13495 cmd->uscsi_flags = USCSI_READ; 13496 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 13497 cmd->uscsi_cdb = &cdb[0]; 13498 cmd->uscsi_bufaddr = buf; 13499 cmd->uscsi_buflen = STK_REQ_SENSE; 13500 cmd->uscsi_cdblen = CDB_GROUP0; 13501 cmd->uscsi_rqlen = 0; 13502 cmd->uscsi_rqbuf = NULL; 13503 13504 result = st_uscsi_cmd(un, cmd, FKIOCTL); 13505 13506 if (result != 0 || cmd->uscsi_status != 0) { 13507 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13508 "Request Sense for WORM failed"); 13509 wrt = RDWR; 13510 } else if (sense->es_add_len + 8 < 24) { 13511 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13512 "Drive didn't send enough sense data for WORM byte %d\n", 13513 sense->es_add_len + 8); 13514 wrt = RDWR; 13515 un->un_wormable = st_is_not_wormable; 13516 } else if ((buf[24]) & 0x02) { 13517 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13518 "Drive has WORM tape loaded\n"); 13519 wrt = WORM; 13520 un->un_wormable = st_is_stk_worm; 13521 } else { 13522 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13523 "Drive has normal tape loaded\n"); 13524 wrt = RDWR; 13525 un->un_wormable = st_is_stk_worm; 13526 } 13527 13528 kmem_free(buf, STK_REQ_SENSE); 13529 kmem_free(cmd, sizeof (struct uscsi_cmd)); 13530 return (wrt); 13531 } 13532 13533 #define DLT_INQ_SZ 44 13534 13535 static writablity 13536 st_is_dlt_tape_worm(struct scsi_tape *un) 13537 { 13538 caddr_t buf; 13539 int result; 13540 writablity wrt; 13541 13542 ST_FUNC(ST_DEVINFO, st_is_dlt_tape_worm); 13543 13544 buf = kmem_alloc(DLT_INQ_SZ, KM_SLEEP); 13545 13546 /* Read Attribute Media Type */ 13547 13548 result = st_read_attributes(un, 0x0408, buf, 10, st_uscsi_cmd); 13549 13550 /* 13551 * If this quantum drive is attached via an HBA that cannot 13552 * support thr read attributes command return error in the 13553 * hope that someday they will support the t10 method. 13554 */ 13555 if (result == EINVAL && un->un_max_cdb_sz < CDB_GROUP4) { 13556 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 13557 "Read Attribute Command for WORM Media detection is not " 13558 "supported on the HBA that this drive is attached to."); 13559 wrt = RDWR; 13560 un->un_wormable = st_is_not_wormable; 13561 goto out; 13562 } 13563 13564 if (result != 0) { 13565 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13566 "Read Attribute Command for WORM Media returned 0x%x", 13567 result); 13568 wrt = RDWR; 13569 un->un_dp->options &= ~ST_WORMABLE; 13570 goto out; 13571 } 13572 13573 if ((uchar_t)buf[9] == 0x80) { 13574 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13575 "Drive media is WORM\n"); 13576 wrt = WORM; 13577 } else { 13578 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13579 "Drive media is not WORM Media 0x%x\n", (uchar_t)buf[9]); 13580 wrt = RDWR; 13581 } 13582 13583 out: 13584 kmem_free(buf, DLT_INQ_SZ); 13585 return (wrt); 13586 } 13587 13588 static writablity 13589 st_is_dlt_worm(struct scsi_tape *un) 13590 { 13591 caddr_t buf; 13592 int result; 13593 writablity wrt; 13594 13595 ST_FUNC(ST_DEVINFO, st_is_dlt_worm); 13596 13597 buf = kmem_alloc(DLT_INQ_SZ, KM_SLEEP); 13598 13599 result = st_get_special_inquiry(un, DLT_INQ_SZ, buf, 0xC0); 13600 13601 if (result != 0) { 13602 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13603 "Read Vendor Specific Inquiry for WORM support failed"); 13604 wrt = RDWR; 13605 goto out; 13606 } 13607 13608 if ((buf[2] & 1) == 0) { 13609 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13610 "Drive is not WORMable\n"); 13611 wrt = RDWR; 13612 un->un_dp->options &= ~ST_WORMABLE; 13613 un->un_wormable = st_is_not_wormable; 13614 goto out; 13615 } else { 13616 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13617 "Drive is WORMable\n"); 13618 un->un_wormable = st_is_dlt_tape_worm; 13619 wrt = un->un_wormable(un); 13620 } 13621 out: 13622 kmem_free(buf, DLT_INQ_SZ); 13623 13624 return (wrt); 13625 } 13626 13627 typedef struct { 13628 struct modeheader_seq header; 13629 #if defined(_BIT_FIELDS_LTOH) /* X86 */ 13630 uchar_t pagecode :6, 13631 :2; 13632 uchar_t page_len; 13633 uchar_t syslogalive :2, 13634 device :1, 13635 abs :1, 13636 ulpbot :1, 13637 prth :1, 13638 ponej :1, 13639 ait :1; 13640 uchar_t span; 13641 13642 uchar_t :6, 13643 worm :1, 13644 mic :1; 13645 uchar_t worm_cap :1, 13646 :7; 13647 uint32_t :32; 13648 #else /* SPARC */ 13649 uchar_t :2, 13650 pagecode :6; 13651 uchar_t page_len; 13652 uchar_t ait :1, 13653 device :1, 13654 abs :1, 13655 ulpbot :1, 13656 prth :1, 13657 ponej :1, 13658 syslogalive :2; 13659 uchar_t span; 13660 uchar_t mic :1, 13661 worm :1, 13662 :6; 13663 uchar_t :7, 13664 worm_cap :1; 13665 uint32_t :32; 13666 #endif 13667 }ait_dev_con; 13668 13669 #define AIT_DEV_PAGE 0x31 13670 static writablity 13671 st_is_sony_worm(struct scsi_tape *un) 13672 { 13673 int result; 13674 writablity wrt; 13675 ait_dev_con *ait_conf; 13676 13677 ST_FUNC(ST_DEVINFO, st_is_sony_worm); 13678 13679 ait_conf = kmem_zalloc(sizeof (ait_dev_con), KM_SLEEP); 13680 13681 result = st_gen_mode_sense(un, st_uscsi_cmd, AIT_DEV_PAGE, 13682 (struct seq_mode *)ait_conf, sizeof (ait_dev_con)); 13683 13684 if (result == 0) { 13685 13686 if (ait_conf->pagecode != AIT_DEV_PAGE) { 13687 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13688 "returned page 0x%x not 0x%x AIT_DEV_PAGE\n", 13689 ait_conf->pagecode, AIT_DEV_PAGE); 13690 wrt = RDWR; 13691 un->un_wormable = st_is_not_wormable; 13692 13693 } else if (ait_conf->worm_cap) { 13694 13695 un->un_wormable = st_is_sony_worm; 13696 13697 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13698 "Drives is WORMable\n"); 13699 if (ait_conf->worm) { 13700 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13701 "Media is WORM\n"); 13702 wrt = WORM; 13703 } else { 13704 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13705 "Media is not WORM\n"); 13706 wrt = RDWR; 13707 } 13708 13709 } else { 13710 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13711 "Drives not is WORMable\n"); 13712 wrt = RDWR; 13713 /* No further checking required */ 13714 un->un_dp->options &= ~ST_WORMABLE; 13715 } 13716 13717 } else { 13718 13719 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13720 "AIT device config mode sense page read command failed" 13721 " result = %d ", result); 13722 wrt = FAILED; 13723 un->un_wormable = st_is_not_wormable; 13724 } 13725 13726 kmem_free(ait_conf, sizeof (ait_dev_con)); 13727 return (wrt); 13728 } 13729 13730 static writablity 13731 st_is_drive_worm(struct scsi_tape *un) 13732 { 13733 writablity wrt; 13734 13735 ST_FUNC(ST_DEVINFO, st_is_sony_worm); 13736 13737 switch (un->un_dp->type) { 13738 case MT_ISDLT: 13739 wrt = st_is_dlt_worm(un); 13740 break; 13741 13742 case MT_ISSTK9840: 13743 wrt = st_is_stk_worm(un); 13744 break; 13745 13746 case MT_IS8MM: 13747 case MT_ISAIT: 13748 wrt = st_is_sony_worm(un); 13749 break; 13750 13751 case MT_LTO: 13752 if (strncmp("HP ", un->un_dp->vid, 3) == 0) { 13753 wrt = st_is_hp_lto_worm(un); 13754 } else { 13755 wrt = st_is_t10_worm(un); 13756 } 13757 break; 13758 13759 case MT_ISDAT: 13760 if (strncmp("HP ", un->un_dp->vid, 3) == 0) { 13761 wrt = st_is_hp_dat_worm(un); 13762 } else { 13763 wrt = st_is_t10_worm(un); 13764 } 13765 break; 13766 13767 default: 13768 wrt = FAILED; 13769 break; 13770 } 13771 13772 /* 13773 * If any of the above failed try the t10 standard method. 13774 */ 13775 if (wrt == FAILED) { 13776 wrt = st_is_t10_worm(un); 13777 } 13778 13779 /* 13780 * Unknown method for detecting WORM media. 13781 */ 13782 if (wrt == FAILED) { 13783 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13784 "Unknown method for WORM media detection\n"); 13785 wrt = RDWR; 13786 un->un_dp->options &= ~ST_WORMABLE; 13787 } 13788 13789 return (wrt); 13790 } 13791 13792 static int 13793 st_read_attributes(struct scsi_tape *un, uint16_t attribute, void *pnt, 13794 size_t size, ubufunc_t bufunc) 13795 { 13796 char cdb[CDB_GROUP4]; 13797 int result; 13798 struct uscsi_cmd *cmd; 13799 caddr_t buf = (caddr_t)pnt; 13800 13801 ST_FUNC(ST_DEVINFO, st_read_attributes); 13802 13803 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13804 13805 cdb[0] = (char)SCMD_READ_ATTRIBUTE; 13806 cdb[1] = 0; 13807 cdb[2] = 0; 13808 cdb[3] = 0; 13809 cdb[4] = 0; 13810 cdb[5] = 0; 13811 cdb[6] = 0; 13812 cdb[7] = 0; 13813 cdb[8] = (char)(attribute >> 8); 13814 cdb[9] = (char)(attribute); 13815 cdb[10] = (char)(size >> 24); 13816 cdb[11] = (char)(size >> 16); 13817 cdb[12] = (char)(size >> 8); 13818 cdb[13] = (char)(size); 13819 cdb[14] = 0; 13820 cdb[15] = 0; 13821 13822 13823 cmd->uscsi_flags = USCSI_READ | USCSI_DIAGNOSE; 13824 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 13825 cmd->uscsi_cdb = &cdb[0]; 13826 cmd->uscsi_bufaddr = (caddr_t)buf; 13827 cmd->uscsi_buflen = size; 13828 cmd->uscsi_cdblen = sizeof (cdb); 13829 13830 result = bufunc(un, cmd, FKIOCTL); 13831 13832 if (result != 0 || cmd->uscsi_status != 0) { 13833 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 13834 "st_read_attribute failed: result %d status %d\n", 13835 result, cmd->uscsi_status); 13836 /* 13837 * If this returns invalid operation code don't try again. 13838 */ 13839 if (un->un_sd->sd_sense->es_key == KEY_ILLEGAL_REQUEST && 13840 un->un_sd->sd_sense->es_add_code == 0x20) { 13841 result = ENOTTY; 13842 } else if (result == 0) { 13843 result = EIO; 13844 } 13845 13846 } else { 13847 13848 /* 13849 * The attribute retured should match the attribute requested. 13850 */ 13851 if (buf[4] != cdb[8] || buf[5] != cdb[9]) { 13852 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 13853 "st_read_attribute got wrong data back expected " 13854 "0x%x got 0x%x\n", attribute, buf[6] << 8 | buf[7]); 13855 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 13856 "bad? data", buf, size); 13857 result = EIO; 13858 } 13859 } 13860 13861 kmem_free(cmd, sizeof (struct uscsi_cmd)); 13862 13863 return (result); 13864 } 13865 13866 static int 13867 st_get_special_inquiry(struct scsi_tape *un, uchar_t size, caddr_t dest, 13868 uchar_t page) 13869 { 13870 char cdb[CDB_GROUP0]; 13871 struct scsi_extended_sense *sense; 13872 struct uscsi_cmd *cmd; 13873 int result; 13874 13875 ST_FUNC(ST_DEVINFO, st_get_special_inquiry); 13876 13877 cdb[0] = SCMD_INQUIRY; 13878 cdb[1] = page ? 1 : 0; 13879 cdb[2] = page; 13880 cdb[3] = 0; 13881 cdb[4] = size; 13882 cdb[5] = 0; 13883 13884 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 13885 sense = kmem_alloc(sizeof (struct scsi_extended_sense), KM_SLEEP); 13886 13887 cmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE; 13888 cmd->uscsi_timeout = un->un_dp->non_motion_timeout; 13889 cmd->uscsi_cdb = &cdb[0]; 13890 cmd->uscsi_bufaddr = dest; 13891 cmd->uscsi_buflen = size; 13892 cmd->uscsi_cdblen = CDB_GROUP0; 13893 cmd->uscsi_rqlen = sizeof (struct scsi_extended_sense); 13894 cmd->uscsi_rqbuf = (caddr_t)sense; 13895 13896 result = st_uscsi_cmd(un, cmd, FKIOCTL); 13897 13898 if (result != 0 || cmd->uscsi_status != 0) { 13899 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 13900 "st_get_special_inquiry() failed for page %x", page); 13901 if (result == 0) { 13902 result = EIO; 13903 } 13904 } 13905 13906 kmem_free(sense, sizeof (struct scsi_extended_sense)); 13907 kmem_free(cmd, sizeof (struct uscsi_cmd)); 13908 13909 return (result); 13910 } 13911 13912 13913 static int 13914 st_update_block_pos(struct scsi_tape *un, bufunc_t bf, int post_space) 13915 { 13916 int rval = ENOTTY; 13917 uchar_t status = un->un_status; 13918 posmode previous_pmode = un->un_running.pmode; 13919 13920 ST_FUNC(ST_DEVINFO, st_update_block_pos); 13921 13922 while (un->un_read_pos_type != NO_POS) { 13923 rval = bf(un, SCMD_READ_POSITION, 32, SYNC_CMD); 13924 13925 /* 13926 * If read position command returned good status 13927 * Parse the data to see if the position can be interpreted. 13928 */ 13929 if ((rval == 0) && 13930 ((rval = st_interpret_read_pos(un, &un->un_pos, 13931 un->un_read_pos_type, 32, (caddr_t)un->un_read_pos_data, 13932 post_space)) == 0)) { 13933 /* 13934 * Update the running position as well if un_pos was 13935 * ok. But only if recovery is enabled. 13936 */ 13937 if (st_recov_sz != sizeof (recov_info)) { 13938 break; 13939 } 13940 rval = st_interpret_read_pos(un, &un->un_running, 13941 un->un_read_pos_type, 32, 13942 (caddr_t)un->un_read_pos_data, post_space); 13943 un->un_status = status; 13944 break; 13945 } else if (un->un_status == KEY_UNIT_ATTENTION) { 13946 un->un_running.pmode = previous_pmode; 13947 continue; 13948 } else if (un->un_status != KEY_ILLEGAL_REQUEST) { 13949 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 13950 "st_update_block_pos() read position cmd 0x%x" 13951 " returned 0x%x un_status = %d", 13952 un->un_read_pos_type, rval, un->un_status); 13953 /* ENOTTY means it read garbage. try something else. */ 13954 if (rval == ENOTTY) { 13955 rval = EIO; /* so ENOTTY is not final rval */ 13956 } else { 13957 break; 13958 } 13959 } else { 13960 ST_DEBUG4(ST_DEVINFO, st_label, CE_NOTE, 13961 "st_update_block_pos() read position cmd %x" 13962 " returned %x", un->un_read_pos_type, rval); 13963 un->un_running.pmode = previous_pmode; 13964 } 13965 13966 switch (un->un_read_pos_type) { 13967 case SHORT_POS: 13968 un->un_read_pos_type = NO_POS; 13969 break; 13970 13971 case LONG_POS: 13972 un->un_read_pos_type = EXT_POS; 13973 break; 13974 13975 case EXT_POS: 13976 un->un_read_pos_type = SHORT_POS; 13977 break; 13978 13979 default: 13980 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 13981 "Unexpected read position type 0x%x", 13982 un->un_read_pos_type); 13983 } 13984 un->un_status = KEY_NO_SENSE; 13985 } 13986 13987 return (rval); 13988 } 13989 13990 static int 13991 st_get_read_pos(struct scsi_tape *un, buf_t *bp) 13992 { 13993 int result; 13994 size_t d_sz; 13995 caddr_t pos_info; 13996 struct uscsi_cmd *cmd = (struct uscsi_cmd *)bp->b_back; 13997 13998 ST_FUNC(ST_DEVINFO, st_get_read_pos); 13999 14000 if (cmd->uscsi_bufaddr == NULL || cmd->uscsi_buflen <= 0) { 14001 return (0); 14002 } 14003 14004 if (bp_mapin_common(bp, VM_NOSLEEP) == NULL) { 14005 14006 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14007 "bp_mapin_common() failed"); 14008 14009 return (EIO); 14010 } 14011 14012 pos_info = bp->b_un.b_addr; 14013 d_sz = bp->b_bcount - bp->b_resid; 14014 14015 #ifdef STDEBUG 14016 if ((st_debug & 0x7) > 2) { 14017 st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG, 14018 "st_get_read_pos() position info", 14019 pos_info, bp->b_bcount); 14020 } 14021 #endif 14022 14023 result = st_interpret_read_pos(un, &un->un_pos, cmd->uscsi_cdb[1], 14024 d_sz, pos_info, 0); 14025 14026 COPY_POS(&un->un_running, &un->un_pos); 14027 14028 bp_mapout(bp); 14029 14030 return (result); 14031 } 14032 14033 #if defined(_BIG_ENDIAN) 14034 14035 #define FIX_ENDIAN16(x) 14036 #define FIX_ENDIAN32(x) 14037 #define FIX_ENDIAN64(x) 14038 14039 #elif defined(_LITTLE_ENDIAN) 14040 14041 static void 14042 st_swap16(uint16_t *val) 14043 { 14044 uint16_t tmp; 14045 14046 tmp = (*val >> 8) & 0xff; 14047 tmp |= (*val << 8) & 0xff00; 14048 14049 *val = tmp; 14050 } 14051 14052 static void 14053 st_swap32(uint32_t *val) 14054 { 14055 uint32_t tmp; 14056 14057 tmp = (*val >> 24) & 0xff; 14058 tmp |= (*val >> 8) & 0xff00; 14059 tmp |= (*val << 8) & 0xff0000; 14060 tmp |= (*val << 24) & 0xff000000; 14061 14062 *val = tmp; 14063 } 14064 14065 static void 14066 st_swap64(uint64_t *val) 14067 { 14068 uint32_t low; 14069 uint32_t high; 14070 14071 low = (uint32_t)(*val); 14072 high = (uint32_t)(*val >> 32); 14073 14074 st_swap32(&low); 14075 st_swap32(&high); 14076 14077 *val = high; 14078 *val |= ((uint64_t)low << 32); 14079 } 14080 14081 #define FIX_ENDIAN16(x) st_swap16(x) 14082 #define FIX_ENDIAN32(x) st_swap32(x) 14083 #define FIX_ENDIAN64(x) st_swap64(x) 14084 #endif 14085 14086 /* 14087 * st_interpret_read_pos() 14088 * 14089 * Returns: 14090 * 0 If secsessful. 14091 * EIO If read postion responce data was unuseable or invalid. 14092 * ERANGE If the position of the drive is too large for the read_p_type. 14093 * ENOTTY If the responce data looks invalid for the read position type. 14094 */ 14095 14096 static int 14097 st_interpret_read_pos(struct scsi_tape const *un, tapepos_t *dest, 14098 read_p_types type, size_t data_sz, const caddr_t responce, int post_space) 14099 { 14100 int rval = 0; 14101 int flag = 0; 14102 tapepos_t org; 14103 14104 ST_FUNC(ST_DEVINFO, st_interpret_read_pos); 14105 14106 /* 14107 * We expect the position value to change after a space command. 14108 * So if post_space is set we don't print out what has changed. 14109 */ 14110 if ((dest != &un->un_pos) && (post_space == 0) && 14111 (st_recov_sz == sizeof (recov_info))) { 14112 COPY_POS(&org, dest); 14113 flag = 1; 14114 } 14115 14116 /* 14117 * See what kind of read position was requested. 14118 */ 14119 switch (type) { 14120 14121 case SHORT_POS: /* Short data format */ 14122 { 14123 tape_position_t *pos_info = (tape_position_t *)responce; 14124 uint32_t value; 14125 14126 /* If reserved fields are non zero don't use the data */ 14127 if (pos_info->reserved0 || pos_info->reserved1 || 14128 pos_info->reserved2[0] || pos_info->reserved2[1] || 14129 pos_info->reserved3) { 14130 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14131 "Invalid Read Short Position Data returned\n"); 14132 rval = EIO; 14133 break; 14134 } 14135 /* 14136 * Position is to large to use this type of read position. 14137 */ 14138 if (pos_info->posi_err == 1) { 14139 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14140 "Drive reported position error\n"); 14141 rval = ERANGE; 14142 break; 14143 } 14144 /* 14145 * If your at the begining of partition and end at the same 14146 * time it's very small partition or bad data. 14147 */ 14148 if (pos_info->begin_of_part && pos_info->end_of_part) { 14149 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14150 "SHORT_POS returned begin and end of" 14151 " partition\n"); 14152 rval = EIO; 14153 break; 14154 } 14155 14156 if (pos_info->blk_posi_unkwn == 0) { 14157 14158 value = pos_info->host_block; 14159 FIX_ENDIAN32(&value); 14160 14161 /* 14162 * If the tape is rewound the host blcok should be 0. 14163 */ 14164 if ((pos_info->begin_of_part == 1) && 14165 (value != 0)) { 14166 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14167 "SHORT_POS returned begin of partition" 14168 " but host block was 0x%x\n", value); 14169 rval = EIO; 14170 break; 14171 } 14172 14173 if (dest->lgclblkno != value) { 14174 if (flag) 14175 flag++; 14176 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14177 "SHORT_POS current logical 0x%"PRIx64" read" 14178 " 0x%x\n", dest->lgclblkno, value); 14179 } 14180 14181 dest->lgclblkno = (uint64_t)value; 14182 14183 /* 14184 * If the begining of partition is true and the 14185 * block number is zero we will beleive that it is 14186 * rewound. Promote the pmode to legacy. 14187 */ 14188 if ((pos_info->begin_of_part == 1) && 14189 (value == 0)) { 14190 dest->blkno = 0; 14191 dest->fileno = 0; 14192 if (dest->pmode != legacy) 14193 dest->pmode = legacy; 14194 /* 14195 * otherwise if the pmode was invalid, 14196 * promote it to logical. 14197 */ 14198 } else if (dest->pmode == invalid) { 14199 dest->pmode = logical; 14200 } 14201 14202 if (dest->partition != pos_info->partition_number) { 14203 if (flag) 14204 flag++; 14205 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14206 "SHORT_POS current partition %d read %d\n", 14207 dest->partition, 14208 pos_info->partition_number); 14209 } 14210 14211 dest->partition = pos_info->partition_number; 14212 14213 } else { 14214 dest->pmode = invalid; 14215 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14216 "Tape drive reported block position as unknown\n"); 14217 } 14218 break; 14219 } 14220 14221 case LONG_POS: /* Long data format */ 14222 { 14223 uint64_t value; 14224 tape_position_long_t *long_pos_info = 14225 (tape_position_long_t *)responce; 14226 14227 /* If reserved fields are non zero don't use the data */ 14228 if ((long_pos_info->reserved0) || 14229 (long_pos_info->reserved1) || 14230 (long_pos_info->reserved2)) { 14231 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14232 "Invalid Read Long Position Data returned\n"); 14233 rval = ENOTTY; 14234 break; 14235 } 14236 14237 /* Is position Valid */ 14238 if (long_pos_info->blk_posi_unkwn == 0) { 14239 uint32_t part; 14240 14241 value = long_pos_info->block_number; 14242 FIX_ENDIAN64(&value); 14243 14244 /* 14245 * If it says we are at the begining of partition 14246 * the block value better be 0. 14247 */ 14248 if ((long_pos_info->begin_of_part == 1) && 14249 (value != 0)) { 14250 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14251 "LONG_POS returned begin of partition but" 14252 " block number was 0x%"PRIx64"\n", value); 14253 rval = ENOTTY; 14254 break; 14255 } 14256 /* 14257 * Can't be at the start and the end of the partition 14258 * at the same time if the partition is larger the 0. 14259 */ 14260 if (long_pos_info->begin_of_part && 14261 long_pos_info->end_of_part) { 14262 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14263 "LONG_POS returned begin and end of" 14264 " partition\n"); 14265 rval = ENOTTY; 14266 break; 14267 } 14268 14269 /* 14270 * If the logical block number is not what we expected. 14271 */ 14272 if (dest->lgclblkno != value) { 14273 if (flag) 14274 flag++; 14275 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14276 "LONG_POS current logical 0x%"PRIx64 14277 " read 0x%"PRIx64"\n", 14278 dest->lgclblkno, value); 14279 } 14280 dest->lgclblkno = value; 14281 14282 /* 14283 * If the begining of partition is true and the 14284 * block number is zero we will beleive that it is 14285 * rewound. Promote the pmode to legacy. 14286 */ 14287 if ((long_pos_info->begin_of_part == 1) && 14288 (long_pos_info->block_number == 0)) { 14289 dest->blkno = 0; 14290 dest->fileno = 0; 14291 if (dest->pmode != legacy) 14292 dest->pmode = legacy; 14293 /* 14294 * otherwise if the pmode was invalid, 14295 * promote it to logical. 14296 */ 14297 } else if (dest->pmode == invalid) { 14298 dest->pmode = logical; 14299 } 14300 14301 part = long_pos_info->partition; 14302 FIX_ENDIAN32(&part); 14303 if (dest->partition != part) { 14304 if (flag) 14305 flag++; 14306 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14307 "LONG_POS current partition %d" 14308 " read %d\n", dest->partition, part); 14309 } 14310 dest->partition = part; 14311 } else { 14312 /* 14313 * If the drive doesn't know location, 14314 * we don't either. 14315 */ 14316 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14317 "Tape drive reported block position as unknown\n"); 14318 dest->pmode = invalid; 14319 } 14320 14321 /* Is file position valid */ 14322 if (long_pos_info->mrk_posi_unkwn == 0) { 14323 value = long_pos_info->file_number; 14324 FIX_ENDIAN64(&value); 14325 /* 14326 * If it says we are at the begining of partition 14327 * the block value better be 0. 14328 */ 14329 if ((long_pos_info->begin_of_part == 1) && 14330 (value != 0)) { 14331 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14332 "LONG_POS returned begin of partition but" 14333 " block number was 0x%"PRIx64"\n", value); 14334 rval = ENOTTY; 14335 break; 14336 } 14337 if (((dest->pmode == legacy) || 14338 (dest->pmode == logical)) && 14339 (dest->fileno != value)) { 14340 if (flag) 14341 flag++; 14342 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14343 "LONG_POS fileno 0x%"PRIx64 14344 " not un_pos %x\n", value, 14345 dest->fileno); 14346 } else if (dest->pmode == invalid) { 14347 dest->pmode = logical; 14348 } 14349 dest->fileno = (int32_t)value; 14350 } else { 14351 /* 14352 * If the drive doesn't know its position, 14353 * we don't either. 14354 */ 14355 dest->pmode = invalid; 14356 } 14357 if (dest->pmode != invalid && long_pos_info->end_of_part) { 14358 dest->eof = ST_EOT; 14359 } 14360 14361 break; 14362 } 14363 14364 case EXT_POS: /* Extended data format */ 14365 { 14366 uint64_t value; 14367 uint16_t len; 14368 tape_position_ext_t *ext_pos_info = 14369 (tape_position_ext_t *)responce; 14370 14371 /* Make sure that there is enough data there */ 14372 if (data_sz < 16) { 14373 break; 14374 } 14375 14376 /* If reserved fields are non zero don't use the data */ 14377 if (ext_pos_info->reserved0 || ext_pos_info->reserved1) { 14378 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14379 "EXT_POS reserved fields not zero\n"); 14380 rval = ENOTTY; 14381 break; 14382 } 14383 14384 /* 14385 * In the unlikely event of overflowing 64 bits of position. 14386 */ 14387 if (ext_pos_info->posi_err != 0) { 14388 rval = ERANGE; 14389 break; 14390 } 14391 14392 len = ext_pos_info->parameter_len; 14393 FIX_ENDIAN16(&len); 14394 14395 if (len != 0x1c) { 14396 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14397 "EXT_POS parameter_len should be 0x1c was 0x%x\n", 14398 len); 14399 rval = ENOTTY; 14400 break; 14401 } 14402 14403 /* Is block position information valid */ 14404 if (ext_pos_info->blk_posi_unkwn == 0) { 14405 14406 value = ext_pos_info->host_block; 14407 FIX_ENDIAN64(&value); 14408 if ((ext_pos_info->begin_of_part == 1) && 14409 (value != 0)) { 14410 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14411 "EXT_POS returned begining of partition but" 14412 " the host block was 0x%"PRIx64"\n", value); 14413 rval = ENOTTY; 14414 break; 14415 } 14416 14417 if (dest->lgclblkno != value) { 14418 if (flag) 14419 flag++; 14420 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14421 "EXT_POS current logical 0x%"PRIx64 14422 " read 0x%"PRIx64"\n", 14423 dest->lgclblkno, value); 14424 } 14425 dest->lgclblkno = value; 14426 14427 /* 14428 * If the begining of partition is true and the 14429 * block number is zero we will beleive that it is 14430 * rewound. Promote the pmode to legacy. 14431 */ 14432 if ((ext_pos_info->begin_of_part == 1) && 14433 (ext_pos_info->host_block == 0)) { 14434 dest->blkno = 0; 14435 dest->fileno = 0; 14436 if (dest->pmode != legacy) { 14437 dest->pmode = legacy; 14438 } 14439 /* 14440 * otherwise if the pmode was invalid, 14441 * promote it to logical. 14442 */ 14443 } else if (dest->pmode == invalid) { 14444 dest->pmode = logical; 14445 } 14446 14447 if (dest->partition != ext_pos_info->partition) { 14448 if (flag) 14449 flag++; 14450 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 14451 "EXT_POS current partition %d read %d\n", 14452 dest->partition, 14453 ext_pos_info->partition); 14454 } 14455 dest->partition = ext_pos_info->partition; 14456 14457 } else { 14458 dest->pmode = invalid; 14459 } 14460 break; 14461 } 14462 14463 default: 14464 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 14465 "Got unexpected SCMD_READ_POSITION type %d\n", type); 14466 rval = EIO; 14467 } 14468 14469 if ((flag > 1) && (rval == 0)) { 14470 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 14471 "position read in", &org); 14472 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 14473 "position read out", dest); 14474 } 14475 14476 return (rval); 14477 } 14478 14479 static int 14480 st_logical_block_locate(struct scsi_tape *un, ubufunc_t ubf, tapepos_t *pos, 14481 uint64_t lblk, uchar_t partition) 14482 { 14483 int rval; 14484 char cdb[CDB_GROUP4]; 14485 struct uscsi_cmd *cmd; 14486 struct scsi_extended_sense sense; 14487 bufunc_t bf = (ubf == st_uscsi_cmd) ? st_cmd : st_rcmd; 14488 14489 ST_FUNC(ST_DEVINFO, st_logical_block_locate); 14490 /* 14491 * WTF Not sure what to do when doing recovery and not wanting 14492 * to update un_pos 14493 */ 14494 14495 cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 14496 14497 if (lblk <= INT32_MAX) { 14498 cmd->uscsi_cdblen = CDB_GROUP1; 14499 cdb[0] = SCMD_LOCATE; 14500 cdb[1] = pos->partition == partition ? 0 : 2; 14501 cdb[2] = 0; 14502 cdb[3] = (char)(lblk >> 24); 14503 cdb[4] = (char)(lblk >> 16); 14504 cdb[5] = (char)(lblk >> 8); 14505 cdb[6] = (char)(lblk); 14506 cdb[7] = 0; 14507 cdb[8] = partition; 14508 cdb[9] = 0; 14509 } else { 14510 /* 14511 * If the drive doesn't give a 64 bit read position data 14512 * it is unlikely it will accept 64 bit locates. 14513 */ 14514 if (un->un_read_pos_type != LONG_POS) { 14515 kmem_free(cmd, sizeof (struct uscsi_cmd)); 14516 return (ERANGE); 14517 } 14518 cmd->uscsi_cdblen = CDB_GROUP4; 14519 cdb[0] = (char)SCMD_LOCATE_G4; 14520 cdb[1] = pos->partition == partition ? 0 : 2; 14521 cdb[2] = 0; 14522 cdb[3] = partition; 14523 cdb[4] = (char)(lblk >> 56); 14524 cdb[5] = (char)(lblk >> 48); 14525 cdb[6] = (char)(lblk >> 40); 14526 cdb[7] = (char)(lblk >> 32); 14527 cdb[8] = (char)(lblk >> 24); 14528 cdb[9] = (char)(lblk >> 16); 14529 cdb[10] = (char)(lblk >> 8); 14530 cdb[11] = (char)(lblk); 14531 cdb[12] = 0; 14532 cdb[13] = 0; 14533 cdb[14] = 0; 14534 cdb[15] = 0; 14535 } 14536 14537 14538 cmd->uscsi_flags = USCSI_WRITE | USCSI_DIAGNOSE | USCSI_RQENABLE; 14539 cmd->uscsi_rqbuf = (caddr_t)&sense; 14540 cmd->uscsi_rqlen = sizeof (sense); 14541 cmd->uscsi_timeout = un->un_dp->space_timeout; 14542 cmd->uscsi_cdb = cdb; 14543 14544 rval = ubf(un, cmd, FKIOCTL); 14545 14546 pos->pmode = logical; 14547 pos->eof = ST_NO_EOF; 14548 14549 if (lblk > INT32_MAX) { 14550 /* 14551 * XXX This is a work around till we handle Descriptor format 14552 * sense data. Since we are sending a command where the standard 14553 * sense data can not correctly represent a correct residual in 14554 * 4 bytes. 14555 */ 14556 if (un->un_status == KEY_ILLEGAL_REQUEST) { 14557 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14558 "Big LOCATE ILLEGAL_REQUEST: rval = %d\n", rval); 14559 /* Doesn't like big locate command */ 14560 un->un_status = 0; 14561 rval = ERANGE; 14562 } else if ((un->un_pos.pmode == invalid) || (rval != 0)) { 14563 /* Aborted big locate command */ 14564 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14565 "Big LOCATE resulted in invalid pos: rval = %d\n", 14566 rval); 14567 un->un_status = 0; 14568 rval = EIO; 14569 } else if (st_update_block_pos(un, bf, 1)) { 14570 /* read position failed */ 14571 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14572 "Big LOCATE and read pos: rval = %d\n", rval); 14573 rval = EIO; 14574 } else if (lblk > un->un_pos.lgclblkno) { 14575 /* read position worked but position was not expected */ 14576 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14577 "Big LOCATE and recover read less then desired 0x%" 14578 PRIx64"\n", un->un_pos.lgclblkno); 14579 un->un_err_resid = lblk - un->un_pos.lgclblkno; 14580 un->un_status = KEY_BLANK_CHECK; 14581 rval = ESPIPE; 14582 } else if (lblk == un->un_pos.lgclblkno) { 14583 /* read position was what was expected */ 14584 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14585 "Big LOCATE and recover seems to have worked\n"); 14586 un->un_err_resid = 0; 14587 rval = 0; 14588 } else { 14589 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 14590 "BIGLOCATE end up going backwards"); 14591 un->un_err_resid = lblk; 14592 rval = EIO; 14593 } 14594 14595 } else if (rval == 0) { 14596 /* Worked as requested */ 14597 pos->lgclblkno = lblk; 14598 14599 } else if (((cmd->uscsi_status & STATUS_MASK) == STATUS_CHECK) && 14600 (cmd->uscsi_resid != 0)) { 14601 /* Got part way there but wasn't enough blocks on tape */ 14602 pos->lgclblkno = lblk - cmd->uscsi_resid; 14603 un->un_err_resid = cmd->uscsi_resid; 14604 un->un_status = KEY_BLANK_CHECK; 14605 rval = ESPIPE; 14606 14607 } else if (st_update_block_pos(un, bf, 1) == 0) { 14608 /* Got part way there but drive didn't tell what we missed by */ 14609 un->un_err_resid = lblk - pos->lgclblkno; 14610 un->un_status = KEY_BLANK_CHECK; 14611 rval = ESPIPE; 14612 14613 } else { 14614 scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG, 14615 "Failed LOCATE and recover pos: rval = %d status = %d\n", 14616 rval, cmd->uscsi_status); 14617 un->un_err_resid = lblk; 14618 un->un_status = KEY_ILLEGAL_REQUEST; 14619 pos->pmode = invalid; 14620 rval = EIO; 14621 } 14622 14623 kmem_free(cmd, sizeof (struct uscsi_cmd)); 14624 14625 return (rval); 14626 } 14627 14628 static int 14629 st_mtfsf_ioctl(struct scsi_tape *un, int files) 14630 { 14631 int rval; 14632 14633 ST_FUNC(ST_DEVINFO, st_mtfsf_ioctl); 14634 14635 14636 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 14637 "st_mtfsf_ioctl: count=%x, eof=%x\n", files, un->un_pos.eof); 14638 #if 0 14639 if ((IN_EOF(un->un_pos)) && (files == 1)) { 14640 un->un_pos.fileno++; 14641 un->un_pos.blkno = 0; 14642 return (0); 14643 } 14644 #endif 14645 /* pmode == invalid already handled */ 14646 if (un->un_pos.pmode == legacy) { 14647 /* 14648 * forward space over filemark 14649 * 14650 * For ASF we allow a count of 0 on fsf which means 14651 * we just want to go to beginning of current file. 14652 * Equivalent to "nbsf(0)" or "bsf(1) + fsf". 14653 * Allow stepping over double fmk with reel 14654 */ 14655 if ((un->un_pos.eof >= ST_EOT) && 14656 (files > 0) && 14657 ((un->un_dp->options & ST_REEL) == 0)) { 14658 /* we're at EOM */ 14659 un->un_err_resid = files; 14660 un->un_status = KEY_BLANK_CHECK; 14661 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14662 "st_mtfsf_ioctl: EIO : MTFSF at EOM"); 14663 return (EIO); 14664 } 14665 14666 /* 14667 * physical tape position may not be what we've been 14668 * telling the user; adjust the request accordingly 14669 */ 14670 if (IN_EOF(un->un_pos)) { 14671 un->un_pos.fileno++; 14672 un->un_pos.blkno = 0; 14673 /* 14674 * For positive direction case, we're now covered. 14675 * For zero or negative direction, we're covered 14676 * (almost) 14677 */ 14678 files--; 14679 } 14680 14681 } 14682 14683 if (st_check_density_or_wfm(un->un_dev, 1, B_READ, STEPBACK)) { 14684 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14685 "st_mtfsf_ioctl: EIO : MTFSF density/wfm failed"); 14686 return (EIO); 14687 } 14688 14689 14690 /* 14691 * Forward space file marks. 14692 * We leave ourselves at block zero 14693 * of the target file number. 14694 */ 14695 if (files < 0) { 14696 rval = st_backward_space_files(un, -files, 0); 14697 } else { 14698 rval = st_forward_space_files(un, files); 14699 } 14700 14701 return (rval); 14702 } 14703 14704 static int 14705 st_forward_space_files(struct scsi_tape *un, int count) 14706 { 14707 int rval; 14708 14709 ST_FUNC(ST_DEVINFO, st_forward_space_files); 14710 14711 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 14712 "fspace: count=%x, eof=%x\n", count, un->un_pos.eof); 14713 14714 ASSERT(count >= 0); 14715 ASSERT(un->un_pos.pmode != invalid); 14716 14717 /* 14718 * A space with a count of zero means take me to the start of file. 14719 */ 14720 if (count == 0) { 14721 14722 /* Hay look were already there */ 14723 if (un->un_pos.pmode == legacy && un->un_pos.blkno == 0) { 14724 un->un_err_resid = 0; 14725 COPY_POS(&un->un_err_pos, &un->un_pos); 14726 return (0); 14727 } 14728 14729 /* 14730 * Well we are in the first file. 14731 * A rewind will get to the start. 14732 */ 14733 if (un->un_pos.pmode == legacy && un->un_pos.fileno == 0) { 14734 rval = st_cmd(un, SCMD_REWIND, 0, SYNC_CMD); 14735 14736 /* 14737 * Can we backspace to get there? 14738 * This should work in logical mode. 14739 */ 14740 } else if (un->un_dp->options & ST_BSF) { 14741 rval = st_space_to_begining_of_file(un); 14742 14743 /* 14744 * Can't back space but current file number is known, 14745 * So rewind and space from the begining of the partition. 14746 */ 14747 } else if (un->un_pos.pmode == legacy) { 14748 rval = st_scenic_route_to_begining_of_file(un, 14749 un->un_pos.fileno); 14750 14751 /* 14752 * pmode is logical and ST_BSF is not set. 14753 * The LONG_POS read position contains the fileno. 14754 * If the read position works, rewind and space. 14755 */ 14756 } else if (un->un_read_pos_type == LONG_POS) { 14757 rval = st_cmd(un, SCMD_READ_POSITION, 0, SYNC_CMD); 14758 if (rval) { 14759 /* 14760 * We didn't get the file position from the 14761 * read position command. 14762 * We are going to trust the drive to backspace 14763 * and then position after the filemark. 14764 */ 14765 rval = st_space_to_begining_of_file(un); 14766 } 14767 rval = st_interpret_read_pos(un, &un->un_pos, LONG_POS, 14768 32, (caddr_t)un->un_read_pos_data, 0); 14769 if ((rval) && (un->un_pos.pmode == invalid)) { 14770 rval = st_space_to_begining_of_file(un); 14771 } else { 14772 rval = st_scenic_route_to_begining_of_file(un, 14773 un->un_pos.fileno); 14774 } 14775 } else { 14776 rval = EIO; 14777 } 14778 /* 14779 * If something didn't work we are lost 14780 */ 14781 if (rval != 0) { 14782 un->un_pos.pmode = invalid; 14783 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14784 "st_mtioctop : EIO : fspace pmode invalid"); 14785 14786 rval = EIO; 14787 } 14788 14789 } else { 14790 rval = st_space_fmks(un, count); 14791 } 14792 14793 if (rval != EIO && count < 0) { 14794 /* 14795 * we came here with a count < 0; we now need 14796 * to skip back to end up before the filemark 14797 */ 14798 rval = st_backward_space_files(un, 1, 1); 14799 } 14800 14801 return (rval); 14802 } 14803 14804 static int 14805 st_scenic_route_to_begining_of_file(struct scsi_tape *un, int32_t fileno) 14806 { 14807 int rval; 14808 14809 ST_FUNC(ST_DEVINFO, st_scenic_route_to_begining_of_file); 14810 14811 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 14812 rval = EIO; 14813 } else if (st_cmd(un, SCMD_SPACE, Fmk(fileno), SYNC_CMD)) { 14814 rval = EIO; 14815 } 14816 14817 return (rval); 14818 } 14819 14820 static int 14821 st_space_to_begining_of_file(struct scsi_tape *un) 14822 { 14823 int rval; 14824 14825 ST_FUNC(ST_DEVINFO, st_space_to_begining_of_file); 14826 14827 /* 14828 * Back space of the file at the begining of the file. 14829 */ 14830 rval = st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD); 14831 if (rval) { 14832 rval = EIO; 14833 return (rval); 14834 } 14835 14836 /* 14837 * Other interesting answers might be crashed BOT which isn't bad. 14838 */ 14839 if (un->un_status == SUN_KEY_BOT) { 14840 return (rval); 14841 } 14842 14843 un->un_running.pmode = invalid; 14844 14845 /* 14846 * Now we are on the BOP side of the filemark. Forward space to 14847 * the EOM side and we are at the begining of the file. 14848 */ 14849 rval = st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD); 14850 if (rval) { 14851 rval = EIO; 14852 } 14853 14854 return (rval); 14855 } 14856 14857 static int 14858 st_mtfsr_ioctl(struct scsi_tape *un, int count) 14859 { 14860 14861 ST_FUNC(ST_DEVINFO, st_mtfsr_ioctl); 14862 14863 /* 14864 * forward space to inter-record gap 14865 * 14866 */ 14867 14868 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 14869 "st_ioctl_fsr: count=%x, eof=%x\n", count, un->un_pos.eof); 14870 14871 if (un->un_pos.pmode == legacy) { 14872 /* 14873 * If were are at end of tape and count is forward. 14874 * Return blank check. 14875 */ 14876 if ((un->un_pos.eof >= ST_EOT) && (count > 0)) { 14877 /* we're at EOM */ 14878 un->un_err_resid = count; 14879 un->un_status = KEY_BLANK_CHECK; 14880 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14881 "st_mtfsr_ioctl: EIO : MTFSR eof > ST_EOT"); 14882 return (EIO); 14883 } 14884 14885 /* 14886 * If count is zero there is nothing to do. 14887 */ 14888 if (count == 0) { 14889 un->un_err_pos.fileno = un->un_pos.fileno; 14890 un->un_err_pos.blkno = un->un_pos.blkno; 14891 un->un_err_resid = 0; 14892 if (IN_EOF(un->un_pos) && SVR4_BEHAVIOR) { 14893 un->un_status = SUN_KEY_EOF; 14894 } 14895 return (0); 14896 } 14897 14898 /* 14899 * physical tape position may not be what we've been 14900 * telling the user; adjust the position accordingly 14901 */ 14902 if (IN_EOF(un->un_pos)) { 14903 daddr_t blkno = un->un_pos.blkno; 14904 int fileno = un->un_pos.fileno; 14905 14906 optype lastop = un->un_lastop; 14907 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD) 14908 == -1) { 14909 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14910 "st_mtfsr_ioctl:EIO:MTFSR count && IN_EOF"); 14911 return (EIO); 14912 } 14913 14914 un->un_pos.blkno = blkno; 14915 un->un_pos.fileno = fileno; 14916 un->un_lastop = lastop; 14917 } 14918 } 14919 14920 if (st_check_density_or_wfm(un->un_dev, 1, B_READ, STEPBACK)) { 14921 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14922 "st_mtfsr_ioctl: EIO : MTFSR st_check_den"); 14923 return (EIO); 14924 } 14925 14926 return (st_space_records(un, count)); 14927 } 14928 14929 static int 14930 st_space_records(struct scsi_tape *un, int count) 14931 { 14932 int dblk; 14933 int rval = 0; 14934 14935 ST_FUNC(ST_DEVINFO, st_space_records); 14936 14937 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 14938 "st_space_records: count=%x, eof=%x\n", count, un->un_pos.eof); 14939 14940 if (un->un_pos.pmode == logical) { 14941 rval = st_cmd(un, SCMD_SPACE, Blk(count), SYNC_CMD); 14942 if (rval != 0) { 14943 rval = EIO; 14944 } 14945 return (rval); 14946 } 14947 14948 dblk = un->un_pos.blkno + count; 14949 14950 /* Already there */ 14951 if (dblk == un->un_pos.blkno) { 14952 un->un_err_resid = 0; 14953 COPY_POS(&un->un_err_pos, &un->un_pos); 14954 return (0); 14955 } 14956 14957 /* 14958 * If the destination block is forward 14959 * or the drive will backspace records. 14960 */ 14961 if (un->un_pos.blkno < dblk || (un->un_dp->options & ST_BSR)) { 14962 /* 14963 * If we're spacing forward, or the device can 14964 * backspace records, we can just use the SPACE 14965 * command. 14966 */ 14967 dblk -= un->un_pos.blkno; 14968 if (st_cmd(un, SCMD_SPACE, Blk(dblk), SYNC_CMD)) { 14969 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14970 "st_space_records:EIO:space_records can't spc"); 14971 rval = EIO; 14972 } else if (un->un_pos.eof >= ST_EOF_PENDING) { 14973 /* 14974 * check if we hit BOT/EOT 14975 */ 14976 if (dblk < 0 && un->un_pos.eof == ST_EOM) { 14977 un->un_status = SUN_KEY_BOT; 14978 un->un_pos.eof = ST_NO_EOF; 14979 } else if (dblk < 0 && 14980 un->un_pos.eof == ST_EOF_PENDING) { 14981 int residue = un->un_err_resid; 14982 /* 14983 * we skipped over a filemark 14984 * and need to go forward again 14985 */ 14986 if (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD)) { 14987 ST_DEBUG2(ST_DEVINFO, st_label, 14988 SCSI_DEBUG, "st_space_records: EIO" 14989 " : can't space #2"); 14990 rval = EIO; 14991 } 14992 un->un_err_resid = residue; 14993 } 14994 if (rval == 0) { 14995 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 14996 "st_space_records: EIO : space_rec rval" 14997 " == 0"); 14998 rval = EIO; 14999 } 15000 } 15001 } else { 15002 /* 15003 * else we rewind, space forward across filemarks to 15004 * the desired file, and then space records to the 15005 * desired block. 15006 */ 15007 15008 int dfile = un->un_pos.fileno; /* save current file */ 15009 15010 if (dblk < 0) { 15011 /* 15012 * Wups - we're backing up over a filemark 15013 */ 15014 if (un->un_pos.blkno != 0 && 15015 (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 15016 st_cmd(un, SCMD_SPACE, Fmk(dfile), SYNC_CMD))) { 15017 un->un_pos.pmode = invalid; 15018 } 15019 un->un_err_resid = -dblk; 15020 if (un->un_pos.fileno == 0 && un->un_pos.blkno == 0) { 15021 un->un_status = SUN_KEY_BOT; 15022 un->un_pos.eof = ST_NO_EOF; 15023 } else if (un->un_pos.fileno > 0) { 15024 un->un_status = SUN_KEY_EOF; 15025 un->un_pos.eof = ST_NO_EOF; 15026 } 15027 COPY_POS(&un->un_err_pos, &un->un_pos); 15028 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15029 "st_space_records:EIO:space_records : dblk < 0"); 15030 rval = EIO; 15031 } else if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD) || 15032 st_cmd(un, SCMD_SPACE, Fmk(dfile), SYNC_CMD) || 15033 st_cmd(un, SCMD_SPACE, Blk(dblk), SYNC_CMD)) { 15034 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15035 "st_space_records: EIO :space_records : rewind " 15036 "and space failed"); 15037 un->un_pos.pmode = invalid; 15038 rval = EIO; 15039 } 15040 } 15041 15042 return (rval); 15043 } 15044 15045 static int 15046 st_mtbsf_ioctl(struct scsi_tape *un, int files) 15047 { 15048 ST_FUNC(ST_DEVINFO, st_mtbsf_ioctl); 15049 15050 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15051 "st_mtbsf_ioctl: count=%x, eof=%x\n", files, un->un_pos.eof); 15052 /* 15053 * backward space of file filemark (1/2" and 8mm) 15054 * tape position will end on the beginning of tape side 15055 * of the desired file mark 15056 */ 15057 if ((un->un_dp->options & ST_BSF) == 0) { 15058 return (ENOTTY); 15059 } 15060 15061 if (un->un_pos.pmode == legacy) { 15062 15063 /* 15064 * If a negative count (which implies a forward space op) 15065 * is specified, and we're at logical or physical eot, 15066 * bounce the request. 15067 */ 15068 15069 if (un->un_pos.eof >= ST_EOT && files < 0) { 15070 un->un_err_resid = files; 15071 un->un_status = SUN_KEY_EOT; 15072 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15073 "st_ioctl_mt_bsf : EIO : MTBSF : eof > ST_EOF"); 15074 return (EIO); 15075 } 15076 /* 15077 * physical tape position may not be what we've been 15078 * telling the user; adjust the request accordingly 15079 */ 15080 if (IN_EOF(un->un_pos)) { 15081 un->un_pos.fileno++; 15082 un->un_pos.blkno = 0; 15083 files++; 15084 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15085 "st_mtbsf_ioctl in eof: count=%d, op=%x\n", 15086 files, MTBSF); 15087 15088 } 15089 } 15090 15091 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 15092 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15093 "st_ioctl : EIO : MTBSF : check den wfm"); 15094 return (EIO); 15095 } 15096 15097 if (files <= 0) { 15098 /* 15099 * for a negative count, we need to step forward 15100 * first and then step back again 15101 */ 15102 files = -files + 1; 15103 return (st_forward_space_files(un, files)); 15104 } 15105 return (st_backward_space_files(un, files, 1)); 15106 } 15107 15108 static int 15109 st_backward_space_files(struct scsi_tape *un, int count, int infront) 15110 { 15111 int end_fileno; 15112 int skip_cnt; 15113 int rval = 0; 15114 15115 ST_FUNC(ST_DEVINFO, st_backward_space_files); 15116 15117 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15118 "st_backward_space_files: count=%x eof=%x\n", 15119 count, un->un_pos.eof); 15120 /* 15121 * Backspace files (MTNBSF): infront == 0 15122 * 15123 * For tapes that can backspace, backspace 15124 * count+1 filemarks and then run forward over 15125 * a filemark 15126 * 15127 * For tapes that can't backspace, 15128 * calculate desired filenumber 15129 * (un->un_pos.fileno - count), rewind, 15130 * and then space forward this amount 15131 * 15132 * Backspace filemarks (MTBSF) infront == 1 15133 * 15134 * For tapes that can backspace, backspace count 15135 * filemarks 15136 * 15137 * For tapes that can't backspace, calculate 15138 * desired filenumber (un->un_pos.fileno - count), 15139 * add 1, rewind, space forward this amount, 15140 * and mark state as ST_EOF_PENDING appropriately. 15141 */ 15142 15143 if (un->un_pos.pmode == logical) { 15144 15145 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15146 "st_backward_space_files: mt_op=%x count=%x" 15147 "lgclblkno=%"PRIx64"\n", infront?MTBSF:MTNBSF, count, 15148 un->un_pos.lgclblkno); 15149 15150 15151 /* In case a drive that won't back space gets in logical mode */ 15152 if ((un->un_dp->options & ST_BSF) == 0) { 15153 rval = EIO; 15154 return (rval); 15155 } 15156 if (st_cmd(un, SCMD_SPACE, Fmk(-count), SYNC_CMD)) { 15157 rval = EIO; 15158 return (rval); 15159 } 15160 if ((infront != 0) && 15161 (st_cmd(un, SCMD_SPACE, Fmk(1), SYNC_CMD))) { 15162 rval = EIO; 15163 return (rval); 15164 } 15165 return (rval); 15166 } 15167 15168 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15169 "st_backward_space_files: mt_op=%x count=%x fileno=%x blkno=%x\n", 15170 infront?MTBSF:MTNBSF, count, un->un_pos.fileno, un->un_pos.blkno); 15171 15172 15173 15174 /* 15175 * Handle the simple case of BOT 15176 * playing a role in these cmds. 15177 * We do this by calculating the 15178 * ending file number. If the ending 15179 * file is < BOT, rewind and set an 15180 * error and mark resid appropriately. 15181 * If we're backspacing a file (not a 15182 * filemark) and the target file is 15183 * the first file on the tape, just 15184 * rewind. 15185 */ 15186 15187 /* figure expected destination of this SPACE command */ 15188 end_fileno = un->un_pos.fileno - count; 15189 15190 /* 15191 * Would the end effect of this SPACE be the same as rewinding? 15192 * If so just rewind instead. 15193 */ 15194 if ((infront != 0) && (end_fileno < 0) || 15195 (infront == 0) && (end_fileno <= 0)) { 15196 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 15197 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15198 "st_backward_space_files: EIO : " 15199 "rewind in lou of BSF failed\n"); 15200 rval = EIO; 15201 } 15202 if (end_fileno < 0) { 15203 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15204 "st_backward_space_files: EIO : " 15205 "back space file greater then fileno\n"); 15206 rval = EIO; 15207 un->un_err_resid = -end_fileno; 15208 un->un_status = SUN_KEY_BOT; 15209 } 15210 return (rval); 15211 } 15212 15213 if (un->un_dp->options & ST_BSF) { 15214 skip_cnt = 1 - infront; 15215 /* 15216 * If we are going to end up at the beginning 15217 * of the file, we have to space one extra file 15218 * first, and then space forward later. 15219 */ 15220 end_fileno = -(count + skip_cnt); 15221 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 15222 "skip_cnt=%x, tmp=%x\n", skip_cnt, end_fileno); 15223 if (st_cmd(un, SCMD_SPACE, Fmk(end_fileno), SYNC_CMD)) { 15224 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15225 "st_backward_space_files:EIO:back space fm failed"); 15226 rval = EIO; 15227 } 15228 } else { 15229 if (st_cmd(un, SCMD_REWIND, 0, SYNC_CMD)) { 15230 rval = EIO; 15231 } else { 15232 skip_cnt = end_fileno + infront; 15233 } 15234 } 15235 15236 /* 15237 * If we have to space forward, do so... 15238 */ 15239 ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, 15240 "space forward skip_cnt=%x, rval=%x\n", skip_cnt, rval); 15241 15242 if (rval == 0 && skip_cnt) { 15243 if (st_cmd(un, SCMD_SPACE, Fmk(skip_cnt), SYNC_CMD)) { 15244 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15245 "st_backward_space_files:EIO:space fm skip count"); 15246 rval = EIO; 15247 } else if (infront) { 15248 /* 15249 * If we had to space forward, and we're 15250 * not a tape that can backspace, mark state 15251 * as if we'd just seen a filemark during a 15252 * a read. 15253 */ 15254 if ((un->un_dp->options & ST_BSF) == 0) { 15255 un->un_pos.eof = ST_EOF_PENDING; 15256 un->un_pos.fileno -= 1; 15257 un->un_pos.blkno = INF; 15258 un->un_running.pmode = invalid; 15259 } 15260 } 15261 } 15262 15263 if (rval != 0) { 15264 un->un_pos.pmode = invalid; 15265 } 15266 15267 return (rval); 15268 } 15269 15270 static int 15271 st_mtnbsf_ioctl(struct scsi_tape *un, int count) 15272 { 15273 int rval; 15274 15275 ST_FUNC(ST_DEVINFO, st_mtnbsf_ioctl); 15276 15277 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15278 "nbsf: count=%x, eof=%x\n", count, un->un_pos.eof); 15279 15280 if (un->un_pos.pmode == legacy) { 15281 /* 15282 * backward space file to beginning of file 15283 * 15284 * If a negative count (which implies a forward space op) 15285 * is specified, and we're at logical or physical eot, 15286 * bounce the request. 15287 */ 15288 15289 if (un->un_pos.eof >= ST_EOT && count < 0) { 15290 un->un_err_resid = count; 15291 un->un_status = SUN_KEY_EOT; 15292 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15293 "st_ioctl : EIO : > EOT and count < 0"); 15294 return (EIO); 15295 } 15296 /* 15297 * physical tape position may not be what we've been 15298 * telling the user; adjust the request accordingly 15299 */ 15300 if (IN_EOF(un->un_pos)) { 15301 un->un_pos.fileno++; 15302 un->un_pos.blkno = 0; 15303 count++; 15304 } 15305 } 15306 15307 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 15308 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15309 "st_ioctl : EIO : MTNBSF check den and wfm"); 15310 return (EIO); 15311 } 15312 15313 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15314 "mtnbsf: count=%x, eof=%x\n", count, un->un_pos.eof); 15315 15316 if (count <= 0) { 15317 rval = st_forward_space_files(un, -count); 15318 } else { 15319 rval = st_backward_space_files(un, count, 0); 15320 } 15321 return (rval); 15322 } 15323 15324 static int 15325 st_mtbsr_ioctl(struct scsi_tape *un, int num) 15326 { 15327 ST_FUNC(ST_DEVINFO, st_mtbsr_ioctl); 15328 15329 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15330 "bsr: count=%x, eof=%x\n", num, un->un_pos.eof); 15331 15332 if (un->un_pos.pmode == legacy) { 15333 /* 15334 * backward space into inter-record gap 15335 * 15336 * If a negative count (which implies a forward space op) 15337 * is specified, and we're at logical or physical eot, 15338 * bounce the request. 15339 */ 15340 if (un->un_pos.eof >= ST_EOT && num < 0) { 15341 un->un_err_resid = num; 15342 un->un_status = SUN_KEY_EOT; 15343 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15344 "st_ioctl : EIO : MTBSR > EOT"); 15345 return (EIO); 15346 } 15347 15348 if (num == 0) { 15349 COPY_POS(&un->un_err_pos, &un->un_pos); 15350 un->un_err_resid = 0; 15351 if (IN_EOF(un->un_pos) && SVR4_BEHAVIOR) { 15352 un->un_status = SUN_KEY_EOF; 15353 } 15354 return (0); 15355 } 15356 15357 /* 15358 * physical tape position may not be what we've been 15359 * telling the user; adjust the position accordingly. 15360 * bsr can not skip filemarks and continue to skip records 15361 * therefore if we are logically before the filemark but 15362 * physically at the EOT side of the filemark, we need to step 15363 * back; this allows fsr N where N > number of blocks in file 15364 * followed by bsr 1 to position at the beginning of last block 15365 */ 15366 if (IN_EOF(un->un_pos)) { 15367 tapepos_t save; 15368 optype lastop = un->un_lastop; 15369 15370 COPY_POS(&save, &un->un_pos); 15371 if (st_cmd(un, SCMD_SPACE, Fmk(-1), SYNC_CMD) == -1) { 15372 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15373 "st_mtbsr_ioctl: EIO : MTBSR can't space"); 15374 return (EIO); 15375 } 15376 15377 COPY_POS(&un->un_pos, &save); 15378 un->un_lastop = lastop; 15379 } 15380 } 15381 15382 un->un_pos.eof = ST_NO_EOF; 15383 15384 if (st_check_density_or_wfm(un->un_dev, 1, 0, STEPBACK)) { 15385 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15386 "st_ioctl : EIO : MTBSR : can't set density or wfm"); 15387 return (EIO); 15388 } 15389 15390 num = -num; 15391 return (st_space_records(un, num)); 15392 } 15393 15394 static int 15395 st_mtfsfm_ioctl(struct scsi_tape *un, int cnt) 15396 { 15397 int rval; 15398 15399 ST_FUNC(ST_DEVINFO, st_mtfsfm_ioctl); 15400 15401 rval = st_cmd(un, SCMD_SPACE, SPACE(SP_SQFLM, cnt), SYNC_CMD); 15402 if (rval == 0) { 15403 un->un_pos.pmode = logical; 15404 } else if ((un->un_status == KEY_ILLEGAL_REQUEST) && 15405 (un->un_sd->sd_sense->es_add_code == 0x24)) { 15406 /* 15407 * Drive says invalid field in cdb. 15408 * Doesn't like space multiple. Position isn't lost. 15409 */ 15410 un->un_err_resid = cnt; 15411 un->un_status = 0; 15412 rval = ENOTTY; 15413 } else { 15414 un->un_err_resid = cnt; 15415 un->un_pos.pmode = invalid; 15416 } 15417 return (rval); 15418 } 15419 15420 static int 15421 st_mtbsfm_ioctl(struct scsi_tape *un, int cnt) 15422 { 15423 int rval; 15424 15425 ST_FUNC(ST_DEVINFO, st_mtbsfm_ioctl); 15426 15427 rval = st_cmd(un, SCMD_SPACE, SPACE(SP_SQFLM, -cnt), SYNC_CMD); 15428 if (rval == 0) { 15429 un->un_pos.pmode = logical; 15430 } else if ((un->un_status == KEY_ILLEGAL_REQUEST) && 15431 (un->un_sd->sd_sense->es_add_code == 0x24)) { 15432 /* 15433 * Drive says invalid field in cdb. 15434 * Doesn't like space multiple. Position isn't lost. 15435 */ 15436 un->un_err_resid = cnt; 15437 un->un_status = 0; 15438 rval = ENOTTY; 15439 } else { 15440 un->un_err_resid = cnt; 15441 un->un_pos.pmode = invalid; 15442 } 15443 return (rval); 15444 } 15445 15446 #ifdef __x86 15447 15448 /* 15449 * release contig_mem and wake up waiting thread, if any 15450 */ 15451 static void 15452 st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp) 15453 { 15454 mutex_enter(ST_MUTEX); 15455 15456 ST_FUNC(ST_DEVINFO, st_release_contig_mem); 15457 15458 cp->cm_next = un->un_contig_mem; 15459 un->un_contig_mem = cp; 15460 un->un_contig_mem_available_num++; 15461 cv_broadcast(&un->un_contig_mem_cv); 15462 15463 mutex_exit(ST_MUTEX); 15464 } 15465 15466 /* 15467 * St_get_contig_mem will return a contig_mem if there is one available 15468 * in current system. Otherwise, it will try to alloc one, if the total 15469 * number of contig_mem is within st_max_contig_mem_num. 15470 * It will sleep, if allowed by caller or return NULL, if no contig_mem 15471 * is available for now. 15472 */ 15473 static struct contig_mem * 15474 st_get_contig_mem(struct scsi_tape *un, size_t len, int alloc_flags) 15475 { 15476 size_t rlen; 15477 struct contig_mem *cp = NULL; 15478 ddi_acc_handle_t acc_hdl; 15479 caddr_t addr; 15480 int big_enough = 0; 15481 int (*dma_alloc_cb)() = (alloc_flags == KM_SLEEP) ? 15482 DDI_DMA_SLEEP : DDI_DMA_DONTWAIT; 15483 15484 /* Try to get one available contig_mem */ 15485 mutex_enter(ST_MUTEX); 15486 15487 ST_FUNC(ST_DEVINFO, st_get_contig_mem); 15488 15489 if (un->un_contig_mem_available_num > 0) { 15490 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 15491 } else if (un->un_contig_mem_total_num < st_max_contig_mem_num) { 15492 /* 15493 * we failed to get one. we're going to 15494 * alloc one more contig_mem for this I/O 15495 */ 15496 mutex_exit(ST_MUTEX); 15497 cp = (struct contig_mem *)kmem_zalloc( 15498 sizeof (struct contig_mem) + biosize(), 15499 alloc_flags); 15500 if (cp == NULL) { 15501 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15502 "alloc contig_mem failure\n"); 15503 return (NULL); /* cannot get one */ 15504 } 15505 cp->cm_bp = (struct buf *) 15506 (((caddr_t)cp) + sizeof (struct contig_mem)); 15507 bioinit(cp->cm_bp); 15508 mutex_enter(ST_MUTEX); 15509 un->un_contig_mem_total_num++; /* one more available */ 15510 } else { 15511 /* 15512 * we failed to get one and we're NOT allowed to 15513 * alloc more contig_mem 15514 */ 15515 if (alloc_flags == KM_SLEEP) { 15516 while (un->un_contig_mem_available_num <= 0) { 15517 cv_wait(&un->un_contig_mem_cv, ST_MUTEX); 15518 } 15519 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 15520 } else { 15521 mutex_exit(ST_MUTEX); 15522 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15523 "alloc contig_mem failure\n"); 15524 return (NULL); /* cannot get one */ 15525 } 15526 } 15527 mutex_exit(ST_MUTEX); 15528 15529 /* We need to check if this block of mem is big enough for this I/O */ 15530 if (cp->cm_len < len) { 15531 /* not big enough, need to alloc a new one */ 15532 if (ddi_dma_mem_alloc(un->un_contig_mem_hdl, len, &st_acc_attr, 15533 DDI_DMA_STREAMING, dma_alloc_cb, NULL, 15534 &addr, &rlen, &acc_hdl) != DDI_SUCCESS) { 15535 ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG, 15536 "alloc contig_mem failure: not enough mem\n"); 15537 st_release_contig_mem(un, cp); 15538 cp = NULL; 15539 } else { 15540 if (cp->cm_addr) { 15541 /* release previous one before attach new one */ 15542 ddi_dma_mem_free(&cp->cm_acc_hdl); 15543 } 15544 mutex_enter(ST_MUTEX); 15545 un->un_max_contig_mem_len = 15546 un->un_max_contig_mem_len >= len ? 15547 un->un_max_contig_mem_len : len; 15548 mutex_exit(ST_MUTEX); 15549 15550 /* attach new mem to this cp */ 15551 cp->cm_addr = addr; 15552 cp->cm_acc_hdl = acc_hdl; 15553 cp->cm_len = len; 15554 15555 goto alloc_ok; /* get one usable cp */ 15556 } 15557 } else { 15558 goto alloc_ok; /* get one usable cp */ 15559 } 15560 15561 /* cannot find/alloc a usable cp, when we get here */ 15562 15563 mutex_enter(ST_MUTEX); 15564 if ((un->un_max_contig_mem_len < len) || 15565 (alloc_flags != KM_SLEEP)) { 15566 mutex_exit(ST_MUTEX); 15567 return (NULL); 15568 } 15569 15570 /* 15571 * we're allowed to sleep, and there is one big enough 15572 * contig mem in the system, which is currently in use, 15573 * wait for it... 15574 */ 15575 big_enough = 1; 15576 do { 15577 cv_wait(&un->un_contig_mem_cv, ST_MUTEX); 15578 ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough); 15579 } while (cp == NULL); 15580 mutex_exit(ST_MUTEX); 15581 15582 /* we get the big enough contig mem, finally */ 15583 15584 alloc_ok: 15585 /* init bp attached to this cp */ 15586 bioreset(cp->cm_bp); 15587 cp->cm_bp->b_un.b_addr = cp->cm_addr; 15588 cp->cm_bp->b_private = (void *)cp; 15589 15590 return (cp); 15591 } 15592 15593 /* 15594 * this is the biodone func for the bp used in big block I/O 15595 */ 15596 static int 15597 st_bigblk_xfer_done(struct buf *bp) 15598 { 15599 struct contig_mem *cp; 15600 struct buf *orig_bp; 15601 int ioerr; 15602 struct scsi_tape *un; 15603 15604 /* sanity check */ 15605 if (bp == NULL) { 15606 return (DDI_FAILURE); 15607 } 15608 15609 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 15610 if (un == NULL) { 15611 return (DDI_FAILURE); 15612 } 15613 15614 ST_FUNC(ST_DEVINFO, st_bigblk_xfer_done); 15615 15616 cp = (struct contig_mem *)bp->b_private; 15617 orig_bp = cp->cm_bp; /* get back the bp we have replaced */ 15618 cp->cm_bp = bp; 15619 15620 /* special handling for special I/O */ 15621 if (cp->cm_use_sbuf) { 15622 #ifndef __lock_lint 15623 ASSERT(un->un_sbuf_busy); 15624 #endif 15625 un->un_sbufp = orig_bp; 15626 cp->cm_use_sbuf = 0; 15627 } 15628 15629 orig_bp->b_resid = bp->b_resid; 15630 ioerr = geterror(bp); 15631 if (ioerr != 0) { 15632 bioerror(orig_bp, ioerr); 15633 } else if (orig_bp->b_flags & B_READ) { 15634 /* copy data back to original bp */ 15635 (void) bp_copyout(bp->b_un.b_addr, orig_bp, 0, 15636 bp->b_bcount - bp->b_resid); 15637 } 15638 15639 st_release_contig_mem(un, cp); 15640 15641 biodone(orig_bp); 15642 15643 return (DDI_SUCCESS); 15644 } 15645 15646 /* 15647 * We use this func to replace original bp that may not be able to do I/O 15648 * in big block size with one that can 15649 */ 15650 static struct buf * 15651 st_get_bigblk_bp(struct buf *bp) 15652 { 15653 struct contig_mem *cp; 15654 struct scsi_tape *un; 15655 struct buf *cont_bp; 15656 15657 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 15658 if (un == NULL) { 15659 return (bp); 15660 } 15661 15662 ST_FUNC(ST_DEVINFO, st_get_bigblk_bp); 15663 15664 /* try to get one contig_mem */ 15665 cp = st_get_contig_mem(un, bp->b_bcount, KM_SLEEP); 15666 if (!cp) { 15667 scsi_log(ST_DEVINFO, st_label, CE_WARN, 15668 "Cannot alloc contig buf for I/O for %lu blk size", 15669 bp->b_bcount); 15670 return (bp); 15671 } 15672 cont_bp = cp->cm_bp; 15673 cp->cm_bp = bp; 15674 15675 /* make sure that we "are" using un_sbufp for special I/O */ 15676 if (bp == un->un_sbufp) { 15677 #ifndef __lock_lint 15678 ASSERT(un->un_sbuf_busy); 15679 #endif 15680 un->un_sbufp = cont_bp; 15681 cp->cm_use_sbuf = 1; 15682 } 15683 15684 /* clone bp */ 15685 cont_bp->b_bcount = bp->b_bcount; 15686 cont_bp->b_resid = bp->b_resid; 15687 cont_bp->b_iodone = st_bigblk_xfer_done; 15688 cont_bp->b_file = bp->b_file; 15689 cont_bp->b_offset = bp->b_offset; 15690 cont_bp->b_dip = bp->b_dip; 15691 cont_bp->b_error = 0; 15692 cont_bp->b_proc = NULL; 15693 cont_bp->b_flags = bp->b_flags & ~(B_PAGEIO | B_PHYS | B_SHADOW); 15694 cont_bp->b_shadow = NULL; 15695 cont_bp->b_pages = NULL; 15696 cont_bp->b_edev = bp->b_edev; 15697 cont_bp->b_dev = bp->b_dev; 15698 cont_bp->b_lblkno = bp->b_lblkno; 15699 cont_bp->b_forw = bp->b_forw; 15700 cont_bp->b_back = bp->b_back; 15701 cont_bp->av_forw = bp->av_forw; 15702 cont_bp->av_back = bp->av_back; 15703 cont_bp->b_bufsize = bp->b_bufsize; 15704 15705 /* get data in original bp */ 15706 if (bp->b_flags & B_WRITE) { 15707 (void) bp_copyin(bp, cont_bp->b_un.b_addr, 0, bp->b_bcount); 15708 } 15709 15710 return (cont_bp); 15711 } 15712 #else 15713 #ifdef __lock_lint 15714 static int 15715 st_bigblk_xfer_done(struct buf *bp) 15716 { 15717 return (0); 15718 } 15719 #endif 15720 #endif 15721 15722 static const char *eof_status[] = 15723 { 15724 "NO_EOF", 15725 "EOF_PENDING", 15726 "EOF", 15727 "EOT_PENDING", 15728 "EOT", 15729 "EOM", 15730 "AFTER_EOM" 15731 }; 15732 static const char *mode[] = { 15733 "invalid", 15734 "legacy", 15735 "logical" 15736 }; 15737 15738 static void 15739 st_print_position(dev_info_t *dev, char *label, uint_t level, 15740 const char *comment, tapepos_t *pos) 15741 { 15742 ST_FUNC(dev, st_print_position); 15743 15744 scsi_log(dev, label, level, 15745 "%s Position data:\n", comment); 15746 scsi_log(dev, label, CE_CONT, 15747 "Positioning mode = %s", mode[pos->pmode]); 15748 scsi_log(dev, label, CE_CONT, 15749 "End Of File/Tape = %s", eof_status[pos->eof]); 15750 scsi_log(dev, label, CE_CONT, 15751 "File Number = 0x%x", pos->fileno); 15752 scsi_log(dev, label, CE_CONT, 15753 "Block Number = 0x%x", pos->blkno); 15754 scsi_log(dev, label, CE_CONT, 15755 "Logical Block = 0x%"PRIx64, pos->lgclblkno); 15756 scsi_log(dev, label, CE_CONT, 15757 "Partition Number = 0x%x", pos->partition); 15758 } 15759 static int 15760 st_check_if_media_changed(struct scsi_tape *un, caddr_t data, int size) 15761 { 15762 15763 int result = 0; 15764 int i; 15765 ST_FUNC(ST_DEVINFO, st_check_if_media_changed); 15766 15767 /* 15768 * find non alpha numeric working from the end. 15769 */ 15770 for (i = size - 1; i; i--) { 15771 if (ISALNUM(data[i]) == 0 || data[i] == ' ') { 15772 data[i] = 0; 15773 size = i; 15774 } 15775 } 15776 15777 if (size == 1) { 15778 /* 15779 * Drive seems to think its returning useful data 15780 * but it looks like all junk 15781 */ 15782 return (result); 15783 } 15784 15785 size++; 15786 15787 /* 15788 * Actually got a valid serial number. 15789 * If never stored one before alloc space for it. 15790 */ 15791 if (un->un_media_id_len == 0) { 15792 un->un_media_id = kmem_zalloc(size, KM_SLEEP); 15793 un->un_media_id_len = size; 15794 (void) strncpy(un->un_media_id, data, min(size, strlen(data))); 15795 un->un_media_id[min(size, strlen(data))] = 0; 15796 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 15797 "Found Media Id %s length = %d\n", un->un_media_id, size); 15798 } else if (size > un->un_media_id_len) { 15799 if (strncmp(un->un_media_id, data, size) != 0) { 15800 result = ESPIPE; 15801 } 15802 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 15803 "Longer Media Id old ID:%s new ID:%s\n", 15804 un->un_media_id, data); 15805 kmem_free(un->un_media_id, un->un_media_id_len); 15806 un->un_media_id = kmem_zalloc(size, KM_SLEEP); 15807 un->un_media_id_len = size; 15808 (void) strncpy(un->un_media_id, data, size); 15809 un->un_media_id[size] = 0; 15810 } else if (strncmp(data, un->un_media_id, 15811 min(size, un->un_media_id_len)) != 0) { 15812 ST_DEBUG1(ST_DEVINFO, st_label, SCSI_DEBUG, 15813 "Old Media Id %s length = %d New %s length = %d\n", 15814 un->un_media_id, un->un_media_id_len, data, size); 15815 bzero(un->un_media_id, un->un_media_id_len); 15816 (void) strncpy(un->un_media_id, data, min(size, strlen(data))); 15817 un->un_media_id[min(size, strlen(data))] = 0; 15818 result = ESPIPE; 15819 } else { 15820 ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, 15821 "Media Id still %s\n", un->un_media_id); 15822 } 15823 15824 ASSERT(strlen(un->un_media_id) <= size); 15825 15826 return (result); 15827 } 15828 #define ID_SIZE 32 15829 typedef struct 15830 { 15831 uchar_t avilable_data0; 15832 uchar_t avilable_data1; 15833 uchar_t avilable_data2; 15834 uchar_t avilable_data3; 15835 uchar_t attribute_msb; 15836 uchar_t attribute_lsb; 15837 #ifdef _BIT_FIELDS_LTOH 15838 uchar_t format : 2, 15839 : 5, 15840 read_only : 1; 15841 #else 15842 uchar_t read_only : 1, 15843 : 5, 15844 format : 2; 15845 #endif 15846 uchar_t attribute_len_msb; 15847 uchar_t attribute_len_lsb; 15848 }attribute_header; 15849 15850 typedef struct { 15851 attribute_header header; 15852 char data[1]; 15853 }mam_attribute; 15854 15855 static int 15856 st_handle_hex_media_id(struct scsi_tape *un, void *pnt, int size) 15857 { 15858 int result; 15859 int newsize = (size + 1) << 1; 15860 int i; 15861 char byte; 15862 char *format; 15863 char *data = (char *)pnt; 15864 char *buf = kmem_alloc(newsize, KM_SLEEP); 15865 15866 ST_FUNC(ST_DEVINFO, st_handle_hex_media_id); 15867 15868 (void) sprintf(buf, "0x"); 15869 for (i = 0; i < size; i++) { 15870 byte = (uchar_t)data[i]; 15871 if (byte < 0x10) 15872 format = "0%x"; 15873 else 15874 format = "%x"; 15875 (void) sprintf(&buf[(int)strlen(buf)], format, byte); 15876 } 15877 result = st_check_if_media_changed(un, buf, newsize); 15878 15879 kmem_free(buf, newsize); 15880 15881 return (result); 15882 } 15883 15884 15885 static int 15886 st_get_media_id_via_read_attribute(struct scsi_tape *un, ubufunc_t bufunc) 15887 { 15888 int result; 15889 mam_attribute *buffer; 15890 int size; 15891 int newsize; 15892 15893 ST_FUNC(ST_DEVINFO, st_get_media_id_via_read_attribute); 15894 size = sizeof (attribute_header) + max(un->un_media_id_len, ID_SIZE); 15895 again: 15896 buffer = kmem_zalloc(size, KM_SLEEP); 15897 result = st_read_attributes(un, 0x0401, buffer, size, bufunc); 15898 if (result == 0) { 15899 15900 newsize = (buffer->header.attribute_len_msb << 8) | 15901 buffer->header.attribute_len_lsb; 15902 15903 if (newsize + sizeof (attribute_header) > size) { 15904 ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, 15905 "resizing read attribute data from %d to %d format" 15906 " %d\n", size, (int)sizeof (attribute_header) + 15907 newsize, buffer->header.format); 15908 kmem_free(buffer, size); 15909 size = newsize + sizeof (attribute_header); 15910 goto again; 15911 } 15912 15913 un->un_media_id_method = st_get_media_id_via_read_attribute; 15914 if (buffer->header.format == 0) { 15915 result = 15916 st_handle_hex_media_id(un, buffer->data, newsize); 15917 } else { 15918 result = st_check_if_media_changed(un, buffer->data, 15919 newsize); 15920 } 15921 } else if (result == EINVAL && un->un_max_cdb_sz < CDB_GROUP4) { 15922 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 15923 "Read Attribute Command for Media Identification is not " 15924 "supported on the HBA that this drive is attached to."); 15925 result = ENOTTY; 15926 } 15927 15928 kmem_free(buffer, size); 15929 un->un_status = 0; 15930 15931 return (result); 15932 } 15933 15934 15935 static int 15936 st_get_media_id_via_media_serial_cmd(struct scsi_tape *un, ubufunc_t bufunc) 15937 { 15938 char cdb[CDB_GROUP5]; 15939 struct uscsi_cmd *ucmd; 15940 struct scsi_extended_sense sense; 15941 int rval; 15942 int size = max(un->un_media_id_len, ID_SIZE); 15943 caddr_t buf; 15944 15945 ST_FUNC(ST_DEVINFO, st_get_media_id_via_media_serial_cmd); 15946 15947 ucmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP); 15948 upsize: 15949 buf = kmem_alloc(size, KM_SLEEP); 15950 15951 cdb[0] = (char)SCMD_SVC_ACTION_IN_G5; 15952 cdb[1] = 1; /* READ MEDIA SERIAL NUMBER */ 15953 cdb[2] = 0; 15954 cdb[3] = 0; 15955 cdb[4] = 0; 15956 cdb[5] = 0; 15957 cdb[6] = (char)(size >> 24); 15958 cdb[7] = (char)(size >> 16); 15959 cdb[8] = (char)(size >> 8); 15960 cdb[9] = (char)(size); 15961 cdb[10] = 0; 15962 cdb[11] = 0; 15963 15964 ucmd->uscsi_flags = USCSI_READ | USCSI_RQENABLE; 15965 ucmd->uscsi_timeout = un->un_dp->non_motion_timeout; 15966 ucmd->uscsi_cdb = &cdb[0]; 15967 ucmd->uscsi_cdblen = sizeof (cdb); 15968 ucmd->uscsi_bufaddr = buf; 15969 ucmd->uscsi_buflen = size; 15970 ucmd->uscsi_rqbuf = (caddr_t)&sense; 15971 ucmd->uscsi_rqlen = sizeof (sense); 15972 15973 rval = bufunc(un, ucmd, FKIOCTL); 15974 15975 if (rval || ucmd->uscsi_status != 0) { 15976 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 15977 "media serial command returned %d scsi_status %d" 15978 " rqstatus %d", rval, ucmd->uscsi_status, 15979 ucmd->uscsi_rqstatus); 15980 /* 15981 * If this returns invalid operation code don't try again. 15982 */ 15983 if (sense.es_key == KEY_ILLEGAL_REQUEST && 15984 sense.es_add_code == 0x20) { 15985 rval = ENOTTY; 15986 } else if (rval == 0) { 15987 rval = EIO; 15988 } 15989 un->un_status = 0; 15990 } else { 15991 int act_size; 15992 15993 /* 15994 * get reported size. 15995 */ 15996 act_size = (int)buf[3] | (int)(buf[2] << 8) | 15997 (int)(buf[1] << 16) | (int)(buf[0] << 24); 15998 15999 /* documentation says mod 4. */ 16000 while (act_size & 3) { 16001 act_size++; 16002 } 16003 16004 /* 16005 * If reported size is larger that we our buffer. 16006 * Free the old one and allocate one that is larger 16007 * enough and re-issuse the command. 16008 */ 16009 if (act_size + 4 > size) { 16010 kmem_free(buf, size); 16011 size = act_size + 4; 16012 goto upsize; 16013 } 16014 16015 /* 16016 * set data pointer to point to the start of that serial number. 16017 */ 16018 un->un_media_id_method = st_get_media_id_via_media_serial_cmd; 16019 rval = st_check_if_media_changed(un, &buf[4], act_size); 16020 } 16021 16022 kmem_free(ucmd, sizeof (struct uscsi_cmd)); 16023 kmem_free(buf, size); 16024 16025 return (rval); 16026 } 16027 16028 16029 /* ARGSUSED */ 16030 static int 16031 st_bogus_media_id(struct scsi_tape *un, ubufunc_t bufunc) 16032 { 16033 ST_FUNC(ST_DEVINFO, st_bogus_media_id); 16034 16035 ASSERT(un->un_media_id == NULL || un->un_media_id == bogusID); 16036 ASSERT(un->un_media_id_len == 0); 16037 un->un_media_id = (char *)bogusID; 16038 un->un_media_id_len = 0; 16039 return (0); 16040 } 16041 16042 typedef int (*media_chk_function)(struct scsi_tape *, ubufunc_t bufunc); 16043 16044 media_chk_function media_chk_functions[] = { 16045 st_get_media_id_via_media_serial_cmd, 16046 st_get_media_id_via_read_attribute, 16047 st_bogus_media_id 16048 }; 16049 16050 static int 16051 st_get_media_identification(struct scsi_tape *un, ubufunc_t bufunc) 16052 { 16053 int result = 0; 16054 int i; 16055 16056 ST_FUNC(ST_DEVINFO, st_get_media_identification); 16057 16058 for (i = 0; i < ST_NUM_MEMBERS(media_chk_functions); i++) { 16059 if (result == ENOTTY) { 16060 /* 16061 * Last operation type not supported by this device. 16062 * Make so next time it doesn`t do that again. 16063 */ 16064 un->un_media_id_method = media_chk_functions[i]; 16065 } else if (un->un_media_id_method != media_chk_functions[i] && 16066 un->un_media_id_method != st_get_media_identification) { 16067 continue; 16068 } 16069 result = media_chk_functions[i](un, bufunc); 16070 /* 16071 * If result indicates the function was successful or 16072 * that the media is not the same as last known, break. 16073 */ 16074 if (result == 0 || result == ESPIPE) { 16075 break; 16076 } 16077 } 16078 16079 return (result); 16080 } 16081 16082 static errstate 16083 st_command_recovery(struct scsi_tape *un, struct scsi_pkt *pkt, 16084 errstate onentry) 16085 { 16086 16087 int ret; 16088 st_err_info *errinfo; 16089 recov_info *ri = (recov_info *)pkt->pkt_private; 16090 16091 ST_FUNC(ST_DEVINFO, st_command_recovery); 16092 16093 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 16094 16095 ASSERT(un->un_recov_buf_busy == 0); 16096 16097 /* 16098 * Don't try and recover a reset that this device sent. 16099 */ 16100 if (un->un_rsvd_status & ST_INITIATED_RESET && 16101 onentry == DEVICE_RESET) { 16102 return (COMMAND_DONE_ERROR); 16103 } 16104 16105 /* 16106 * See if expected position was passed with scsi_pkt. 16107 */ 16108 if (ri->privatelen == sizeof (recov_info)) { 16109 16110 /* 16111 * Not for this command. 16112 */ 16113 if (ri->cmd_attrib->do_not_recover) { 16114 return (COMMAND_DONE_ERROR); 16115 } 16116 16117 /* 16118 * Create structure to hold all error state info. 16119 */ 16120 errinfo = kmem_zalloc(sizeof (st_err_info), KM_SLEEP); 16121 errinfo->ei_error_type = onentry; 16122 errinfo->ei_failing_bp = ri->cmd_bp; 16123 COPY_POS(&errinfo->ei_expected_pos, &ri->pos); 16124 } else { 16125 /* disabled */ 16126 return (COMMAND_DONE_ERROR); 16127 } 16128 16129 bcopy(pkt, &errinfo->ei_failed_pkt, sizeof (struct scsi_pkt)); 16130 bcopy(pkt->pkt_scbp, &errinfo->ei_failing_status, SECMDS_STATUS_SIZE); 16131 ret = ddi_taskq_dispatch(un->un_recov_taskq, st_recover, errinfo, 16132 DDI_NOSLEEP); 16133 ASSERT(ret == DDI_SUCCESS); 16134 if (ret != DDI_SUCCESS) { 16135 kmem_free(errinfo, sizeof (st_err_info)); 16136 return (COMMAND_DONE_ERROR); 16137 } 16138 return (JUST_RETURN); /* release calling thread */ 16139 } 16140 16141 static void 16142 st_recov_ret(struct scsi_tape *un, st_err_info *errinfo, errstate err) 16143 { 16144 int error_number; 16145 buf_t *bp; 16146 16147 16148 ST_FUNC(ST_DEVINFO, st_recov_ret); 16149 16150 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 16151 16152 bp = errinfo->ei_failing_bp; 16153 kmem_free(errinfo, sizeof (st_err_info)); 16154 16155 switch (err) { 16156 case JUST_RETURN: 16157 mutex_exit(&un->un_sd->sd_mutex); 16158 return; 16159 16160 case COMMAND_DONE: 16161 case COMMAND_DONE_ERROR_RECOVERED: 16162 ST_DO_KSTATS(bp, kstat_runq_exit); 16163 error_number = 0; 16164 break; 16165 16166 case COMMAND_DONE_ERROR: 16167 case COMMAND_DONE_EACCES: 16168 ST_DO_KSTATS(bp, kstat_waitq_exit); 16169 ST_DO_ERRSTATS(un, st_transerrs); 16170 error_number = EIO; 16171 st_set_pe_flag(un); 16172 break; 16173 16174 default: 16175 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 16176 "st_recov_ret with unhandled errstat %d\n", err); 16177 } 16178 st_bioerror(bp, error_number); 16179 st_done_and_mutex_exit(un, bp); 16180 } 16181 16182 static void 16183 st_recover(void *arg) 16184 { 16185 st_err_info *const errinfo = (st_err_info *)arg; 16186 uchar_t com = errinfo->ei_failed_pkt.pkt_cdbp[0]; 16187 struct scsi_tape *un; 16188 tapepos_t cur_pos; 16189 int rval; 16190 errstate status = COMMAND_DONE_ERROR; 16191 recov_info *rcv; 16192 buf_t *bp; 16193 16194 16195 rcv = errinfo->ei_failed_pkt.pkt_private; 16196 ASSERT(rcv->privatelen == sizeof (recov_info)); 16197 bp = rcv->cmd_bp; 16198 16199 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 16200 16201 ASSERT(un != NULL); 16202 16203 mutex_enter(ST_MUTEX); 16204 16205 ST_FUNC(ST_DEVINFO, st_recover); 16206 16207 ST_CDB(ST_DEVINFO, "Recovering command", 16208 (caddr_t)errinfo->ei_failed_pkt.pkt_cdbp); 16209 ST_SENSE(ST_DEVINFO, "sense status for failed command", 16210 (caddr_t)&errinfo->ei_failing_status, 16211 sizeof (struct scsi_arq_status)); 16212 ST_POS(ST_DEVINFO, rcv->cmd_attrib->recov_pos_type == POS_STARTING ? 16213 "starting position for recovery command" : 16214 "expected position for recovery command", 16215 &errinfo->ei_expected_pos); 16216 16217 rval = st_test_path_to_device(un); 16218 16219 /* 16220 * If the drive responed to the TUR lets try and get it to sync 16221 * any data it have in the buffer. 16222 */ 16223 if (rval == 0 && rcv->cmd_attrib->chg_tape_data) { 16224 (void) st_rcmd(un, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD); 16225 } 16226 switch (errinfo->ei_error_type) { 16227 case ATTEMPT_RETRY: 16228 case COMMAND_TIMEOUT: 16229 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16230 "st_recover called with COMMAND_TIMEOUT, TUR returned %d\n", 16231 rval); 16232 if (rval != 0) { 16233 /* ping failed, we're done. */ 16234 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16235 return; 16236 } 16237 16238 /* 16239 * If a reset occured fall through. 16240 */ 16241 if (un->un_unit_attention_flags == 0) { 16242 break; 16243 } 16244 /* FALLTHROUGH */ 16245 case DEVICE_RESET: 16246 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16247 "st_recover called with DEVICE_RESET, TUR returned %d\n", 16248 rval); 16249 /* 16250 * For now if we can't talk to the device we are done. 16251 */ 16252 if (rval) { 16253 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16254 return; 16255 } 16256 16257 if ((un->un_rsvd_status & ST_LOST_RESERVE) && 16258 (errinfo->ei_failed_pkt.pkt_cdbp[0] != SCMD_RELEASE)) { 16259 rval = st_reserve_release(un, ST_RESERVE, 16260 st_uscsi_rcmd); 16261 if (rval == 0) { 16262 un->un_rsvd_status |= ST_RESERVE; 16263 un->un_rsvd_status &= ~(ST_RELEASE | 16264 ST_LOST_RESERVE | ST_RESERVATION_CONFLICT | 16265 ST_INITIATED_RESET); 16266 } else { 16267 st_recov_ret(un, errinfo, COMMAND_DONE_EACCES); 16268 return; 16269 } 16270 rval = st_check_mode_for_change(un, st_uscsi_rcmd); 16271 if (rval) { 16272 rval = st_gen_mode_select(un, st_uscsi_rcmd, 16273 un->un_mspl, sizeof (struct seq_mode)); 16274 } 16275 if (rval) { 16276 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16277 return; 16278 } 16279 } 16280 break; 16281 case PATH_FAILED: 16282 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16283 "st_recover called with PATH_FAILED, TUR returned %d\n", 16284 rval); 16285 if (rval != 0) { 16286 /* ping failed, we're done. */ 16287 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16288 return; 16289 } 16290 break; 16291 case DEVICE_TAMPER: 16292 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16293 "st_recover called with DEVICE_TAMPER, TUR returned %d\n", 16294 rval); 16295 /* 16296 * Check if the ASC/ASCQ says mode data has changed. 16297 */ 16298 if (errinfo->ei_failing_status.sts_sensedata.es_add_code == 16299 0x2a && 16300 errinfo->ei_failing_status.sts_sensedata.es_qual_code == 16301 0x01) { 16302 /* 16303 * See if mode sense changed. 16304 */ 16305 rval = st_check_mode_for_change(un, st_uscsi_rcmd); 16306 /* 16307 * if not cross your fingers and go for it. 16308 */ 16309 if (rval == 0) { 16310 st_recov_ret(un, errinfo, COMMAND_DONE); 16311 return; 16312 } 16313 /* 16314 * If so change it back. 16315 */ 16316 rval = st_gen_mode_select(un, st_uscsi_rcmd, 16317 un->un_mspl, sizeof (struct seq_mode)); 16318 if (rval) { 16319 st_recov_ret(un, errinfo, COMMAND_DONE_ERROR); 16320 } 16321 st_recov_ret(un, errinfo, COMMAND_DONE); 16322 return; 16323 } 16324 /* 16325 * if we have a media id and its not bogus. 16326 * Check to see if it the same. 16327 */ 16328 if (un->un_media_id != NULL && un->un_media_id != bogusID) { 16329 rval = st_get_media_identification(un, st_uscsi_rcmd); 16330 if (rval == ESPIPE) { 16331 st_recov_ret(un, errinfo, COMMAND_DONE_EACCES); 16332 return; 16333 } 16334 } 16335 break; 16336 default: 16337 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 16338 "Unhandled error type 0x%x in st_recover()\n", com); 16339 } 16340 16341 /* 16342 * if command is retriable retry it 16343 */ 16344 if (rcv->cmd_attrib->retriable) { 16345 status = st_recover_reissue_pkt(un, &errinfo->ei_failed_pkt); 16346 16347 /* 16348 * if drive doesn't support read position we are done 16349 */ 16350 } else if (un->un_read_pos_type == NO_POS) { 16351 status = COMMAND_DONE_ERROR; 16352 /* 16353 * If this command results in a changed tape position, 16354 * lets see where we are. 16355 */ 16356 } else if (rcv->cmd_attrib->chg_tape_pos) { 16357 /* 16358 * XXX May be a reason to choose a different type here. 16359 * Long format has file position information. 16360 * Short and Extended have information about whats 16361 * in the buffer. St's positioning assumes in the buffer 16362 * to be the same as on tape. 16363 */ 16364 rval = st_compare_expected_position(un, errinfo, 16365 rcv->cmd_attrib, &cur_pos); 16366 if (rval == 0) { 16367 status = COMMAND_DONE; 16368 } else if (rval == EAGAIN) { 16369 status = st_recover_reissue_pkt(un, 16370 &errinfo->ei_failed_pkt); 16371 } else { 16372 status = COMMAND_DONE_ERROR; 16373 } 16374 } else { 16375 ASSERT(0); 16376 } 16377 16378 st_recov_ret(un, errinfo, status); 16379 } 16380 16381 static void 16382 st_recov_cb(struct scsi_pkt *pkt) 16383 { 16384 struct scsi_tape *un; 16385 struct buf *bp; 16386 recov_info *rcv; 16387 errstate action = COMMAND_DONE; 16388 int timout = ST_TRAN_BUSY_TIMEOUT; /* short (default) timeout */ 16389 16390 /* 16391 * Get the buf from the packet. 16392 */ 16393 rcv = pkt->pkt_private; 16394 ASSERT(rcv->privatelen == sizeof (recov_info)); 16395 bp = rcv->cmd_bp; 16396 16397 /* 16398 * get the unit from the buf. 16399 */ 16400 un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev)); 16401 ASSERT(un != NULL); 16402 16403 ST_FUNC(ST_DEVINFO, st_recov_cb); 16404 16405 mutex_enter(ST_MUTEX); 16406 16407 ASSERT(bp == un->un_recov_buf); 16408 16409 16410 switch (pkt->pkt_reason) { 16411 case CMD_CMPLT: 16412 if (un->un_arq_enabled && pkt->pkt_state & STATE_ARQ_DONE) { 16413 action = st_handle_autosense(un, bp, &rcv->pos); 16414 } else if (*pkt->pkt_scbp & (STATUS_BUSY | STATUS_CHECK)) { 16415 action = st_check_error(un, pkt); 16416 } 16417 break; 16418 case CMD_TIMEOUT: 16419 action = COMMAND_TIMEOUT; 16420 break; 16421 default: 16422 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 16423 "pkt_reason not handled yet %s", 16424 scsi_rname(pkt->pkt_reason)); 16425 } 16426 16427 switch (action) { 16428 case COMMAND_DONE: 16429 break; 16430 16431 case COMMAND_DONE_EACCES: 16432 bioerror(bp, EACCES); 16433 break; 16434 16435 case COMMAND_TIMEOUT: 16436 case COMMAND_DONE_ERROR: 16437 bioerror(bp, EIO); 16438 break; 16439 16440 case QUE_BUSY_COMMAND: 16441 /* longish timeout */ 16442 timout = ST_STATUS_BUSY_TIMEOUT; 16443 /* FALLTHRU */ 16444 case QUE_COMMAND: 16445 case DEVICE_TAMPER: 16446 case ATTEMPT_RETRY: 16447 /* 16448 * let st_handle_intr_busy put this bp back on waitq and make 16449 * checks to see if it is ok to requeue the command. 16450 */ 16451 ST_DO_KSTATS(bp, kstat_runq_back_to_waitq); 16452 16453 /* 16454 * Save the throttle before setting up the timeout 16455 */ 16456 if (un->un_throttle) { 16457 un->un_last_throttle = un->un_throttle; 16458 } 16459 mutex_exit(ST_MUTEX); 16460 if (st_handle_intr_busy(un, bp, timout) == 0) { 16461 return; /* timeout is setup again */ 16462 } 16463 mutex_enter(ST_MUTEX); 16464 un->un_pos.pmode = invalid; 16465 un->un_err_resid = bp->b_resid = bp->b_bcount; 16466 st_bioerror(bp, EIO); 16467 st_set_pe_flag(un); 16468 break; 16469 16470 default: 16471 ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC, 16472 "Unhandled recovery state 0x%x\n", action); 16473 } 16474 16475 st_done_and_mutex_exit(un, bp); 16476 } 16477 16478 static int 16479 st_rcmd(struct scsi_tape *un, int com, int64_t count, int wait) 16480 { 16481 struct buf *bp; 16482 int err; 16483 16484 ST_FUNC(ST_DEVINFO, st_rcmd); 16485 16486 ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, 16487 "st_rcmd(un = 0x%p, com = 0x%x, count = %"PRIx64", wait = %d)\n", 16488 (void *)un, com, count, wait); 16489 16490 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 16491 ASSERT(mutex_owned(ST_MUTEX)); 16492 16493 #ifdef STDEBUG 16494 if ((st_debug & 0x7)) { 16495 st_debug_cmds(un, com, count, wait); 16496 } 16497 #endif 16498 16499 while (un->un_recov_buf_busy) 16500 cv_wait(&un->un_recov_buf_cv, ST_MUTEX); 16501 un->un_recov_buf_busy = 1; 16502 16503 bp = un->un_recov_buf; 16504 bzero(bp, sizeof (buf_t)); 16505 16506 bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC; 16507 16508 err = st_setup_cmd(un, bp, com, count); 16509 16510 un->un_recov_buf_busy = 0; 16511 16512 cv_signal(&un->un_recov_buf_cv); 16513 16514 return (err); 16515 } 16516 16517 /* args used */ 16518 static int 16519 st_uscsi_rcmd(struct scsi_tape *un, struct uscsi_cmd *ucmd, int flag) 16520 { 16521 int rval; 16522 buf_t *bp; 16523 16524 ST_FUNC(ST_DEVINFO, st_uscsi_rcmd); 16525 ASSERT(flag == FKIOCTL); 16526 16527 /* 16528 * Get buffer resources... 16529 */ 16530 while (un->un_recov_buf_busy) 16531 cv_wait(&un->un_recov_buf_cv, ST_MUTEX); 16532 un->un_recov_buf_busy = 1; 16533 16534 bp = un->un_recov_buf; 16535 bzero(bp, sizeof (buf_t)); 16536 16537 bp->b_forw = (struct buf *)(uintptr_t)ucmd->uscsi_cdb[0]; 16538 bp->b_back = (struct buf *)ucmd; 16539 16540 mutex_exit(ST_MUTEX); 16541 rval = scsi_uscsi_handle_cmd(un->un_dev, UIO_SYSSPACE, ucmd, 16542 st_strategy, bp, NULL); 16543 mutex_enter(ST_MUTEX); 16544 16545 ucmd->uscsi_resid = bp->b_resid; 16546 16547 /* 16548 * Free resources 16549 */ 16550 un->un_recov_buf_busy = 0; 16551 cv_signal(&un->un_recov_buf_cv); 16552 16553 return (rval); 16554 } 16555 16556 /* 16557 * Add data to scsi_pkt to help know what to do if the command fails. 16558 */ 16559 static void 16560 st_add_recovery_info_to_pkt(struct scsi_tape *un, buf_t *bp, 16561 struct scsi_pkt *pkt) 16562 { 16563 uint64_t count; 16564 recov_info *rinfo = (recov_info *)pkt->pkt_private; 16565 16566 ST_FUNC(ST_DEVINFO, st_add_recovery_info_to_pkt); 16567 16568 ASSERT(rinfo->privatelen == sizeof (pkt_info) || 16569 rinfo->privatelen == sizeof (recov_info)); 16570 16571 SET_BP_PKT(bp, pkt); 16572 rinfo->cmd_bp = bp; 16573 16574 if (rinfo->privatelen != sizeof (recov_info)) { 16575 return; 16576 } 16577 16578 rinfo->cmd_bp = bp; 16579 16580 rinfo->cmd_attrib = NULL; 16581 16582 /* 16583 * lookup the command attributes and add them to the recovery info. 16584 */ 16585 rinfo->cmd_attrib = st_lookup_cmd_attribute(pkt->pkt_cdbp[0]); 16586 16587 ASSERT(rinfo->cmd_attrib); 16588 16589 /* 16590 * For commands that there is no way to figure the expected position 16591 * once completed, we save the position the command was started from 16592 * so that if they fail we can position back and try again. 16593 * This has already been done in st_cmd() or st_iscsi_cmd(). 16594 */ 16595 if (rinfo->cmd_attrib->recov_pos_type == POS_STARTING) { 16596 /* save current position as the starting position. */ 16597 COPY_POS(&rinfo->pos, &un->un_pos); 16598 un->un_running.pmode = invalid; 16599 return; 16600 } 16601 16602 /* 16603 * Don't want to update the running position for recovery. 16604 */ 16605 if (bp == un->un_recov_buf) { 16606 rinfo->pos.pmode = un->un_running.pmode; 16607 return; 16608 } 16609 /* 16610 * If running position is invalid copy the current position. 16611 * Running being set invalid means we are not in a read, write 16612 * or write filemark sequence. 16613 * We'll copy the current position and start from there. 16614 */ 16615 if (un->un_running.pmode == invalid) { 16616 COPY_POS(&un->un_running, &un->un_pos); 16617 COPY_POS(&rinfo->pos, &un->un_running); 16618 } else { 16619 COPY_POS(&rinfo->pos, &un->un_running); 16620 if (rinfo->pos.pmode == legacy) { 16621 /* 16622 * Always should be more logical blocks then 16623 * data blocks and files marks. 16624 */ 16625 ASSERT(rinfo->pos.lgclblkno >= rinfo->pos.blkno + 16626 rinfo->pos.fileno); 16627 } 16628 } 16629 16630 /* 16631 * If the command is not expected to change the drive position 16632 * then the running position should be the expected position. 16633 */ 16634 if (rinfo->cmd_attrib->chg_tape_pos == 0) { 16635 ASSERT(rinfo->cmd_attrib->chg_tape_direction == DIR_NONE); 16636 return; 16637 } 16638 16639 if (rinfo->cmd_attrib->explicit) { 16640 ASSERT(rinfo->pos.pmode != invalid); 16641 ASSERT(rinfo->cmd_attrib->get_cnt); 16642 count = rinfo->cmd_attrib->get_cnt(pkt->pkt_cdbp); 16643 /* 16644 * This is a user generated CDB. 16645 */ 16646 if (bp == un->un_sbufp) { 16647 uint64_t lbn; 16648 16649 lbn = rinfo->cmd_attrib->get_lba(pkt->pkt_cdbp); 16650 16651 /* 16652 * See if this CDB will generate a locate or change 16653 * partition. 16654 */ 16655 if ((lbn != un->un_running.lgclblkno) || 16656 (pkt->pkt_cdbp[3] != un->un_running.partition)) { 16657 rinfo->pos.partition = pkt->pkt_cdbp[3]; 16658 rinfo->pos.pmode = logical; 16659 rinfo->pos.lgclblkno = lbn; 16660 un->un_running.partition = pkt->pkt_cdbp[3]; 16661 un->un_running.pmode = logical; 16662 un->un_running.lgclblkno = lbn; 16663 } 16664 } else { 16665 uint64_t lbn = un->un_running.lgclblkno; 16666 16667 pkt->pkt_cdbp[3] = (uchar_t)un->un_running.partition; 16668 16669 pkt->pkt_cdbp[4] = (uchar_t)(lbn >> 56); 16670 pkt->pkt_cdbp[5] = (uchar_t)(lbn >> 48); 16671 pkt->pkt_cdbp[6] = (uchar_t)(lbn >> 40); 16672 pkt->pkt_cdbp[7] = (uchar_t)(lbn >> 32); 16673 pkt->pkt_cdbp[8] = (uchar_t)(lbn >> 24); 16674 pkt->pkt_cdbp[9] = (uchar_t)(lbn >> 16); 16675 pkt->pkt_cdbp[10] = (uchar_t)(lbn >> 8); 16676 pkt->pkt_cdbp[11] = (uchar_t)(lbn); 16677 } 16678 rinfo->pos.lgclblkno += count; 16679 rinfo->pos.blkno += count; 16680 un->un_running.lgclblkno += count; 16681 return; 16682 } 16683 16684 if (rinfo->cmd_attrib->chg_tape_pos) { 16685 16686 /* should not have got an invalid position from running. */ 16687 if (un->un_mediastate == MTIO_INSERTED) { 16688 ASSERT(rinfo->pos.pmode != invalid); 16689 } 16690 16691 /* should have either a get count or or get lba function */ 16692 ASSERT(rinfo->cmd_attrib->get_cnt != NULL || 16693 rinfo->cmd_attrib->get_lba != NULL); 16694 16695 /* only explicit commands have both and they're handled above */ 16696 ASSERT(!(rinfo->cmd_attrib->get_cnt != NULL && 16697 rinfo->cmd_attrib->get_lba != NULL)); 16698 16699 /* if it has a get count function */ 16700 if (rinfo->cmd_attrib->get_cnt != NULL) { 16701 count = rinfo->cmd_attrib->get_cnt(pkt->pkt_cdbp); 16702 if (count == 0) { 16703 return; 16704 } 16705 /* 16706 * Changes position but doesn't transfer data. 16707 * i.e. rewind, write_file_mark and load. 16708 */ 16709 if (rinfo->cmd_attrib->transfers_data == TRAN_NONE) { 16710 switch (rinfo->cmd_attrib->chg_tape_direction) { 16711 case DIR_NONE: /* Erase */ 16712 ASSERT(rinfo->cmd_attrib->cmd == 16713 SCMD_ERASE); 16714 break; 16715 case DIR_FORW: /* write_file_mark */ 16716 rinfo->pos.fileno += count; 16717 rinfo->pos.lgclblkno += count; 16718 rinfo->pos.blkno = 0; 16719 un->un_running.fileno += count; 16720 un->un_running.lgclblkno += count; 16721 un->un_running.blkno = 0; 16722 break; 16723 case DIR_REVC: /* rewind */ 16724 rinfo->pos.fileno = 0; 16725 rinfo->pos.lgclblkno = 0; 16726 rinfo->pos.blkno = 0; 16727 rinfo->pos.eof = ST_NO_EOF; 16728 rinfo->pos.pmode = legacy; 16729 un->un_running.fileno = 0; 16730 un->un_running.lgclblkno = 0; 16731 un->un_running.blkno = 0; 16732 un->un_running.eof = ST_NO_EOF; 16733 if (un->un_running.pmode != legacy) 16734 un->un_running.pmode = legacy; 16735 break; 16736 case DIR_EITH: /* Load unload */ 16737 ASSERT(rinfo->cmd_attrib->cmd == 16738 SCMD_LOAD); 16739 switch (count & (LD_LOAD | LD_RETEN | 16740 LD_RETEN | LD_HOLD)) { 16741 case LD_UNLOAD: 16742 case LD_RETEN: 16743 case LD_HOLD: 16744 case LD_LOAD | LD_HOLD: 16745 case LD_EOT | LD_HOLD: 16746 case LD_RETEN | LD_HOLD: 16747 rinfo->pos.pmode = invalid; 16748 un->un_running.pmode = invalid; 16749 break; 16750 case LD_EOT: 16751 case LD_LOAD | LD_EOT: 16752 rinfo->pos.eof = ST_EOT; 16753 rinfo->pos.pmode = invalid; 16754 un->un_running.eof = ST_EOT; 16755 un->un_running.pmode = invalid; 16756 break; 16757 case LD_LOAD: 16758 case LD_RETEN | LD_LOAD: 16759 rinfo->pos.fileno = 0; 16760 rinfo->pos.lgclblkno = 0; 16761 rinfo->pos.blkno = 0; 16762 rinfo->pos.eof = ST_NO_EOF; 16763 rinfo->pos.pmode = legacy; 16764 un->un_running.fileno = 0; 16765 un->un_running.lgclblkno = 0; 16766 un->un_running.blkno = 0; 16767 un->un_running.eof = ST_NO_EOF; 16768 break; 16769 default: 16770 ASSERT(0); 16771 } 16772 break; 16773 default: 16774 ASSERT(0); 16775 break; 16776 } 16777 } else { 16778 /* 16779 * Changes position and does transfer data. 16780 * i.e. read or write. 16781 */ 16782 switch (rinfo->cmd_attrib->chg_tape_direction) { 16783 case DIR_FORW: 16784 rinfo->pos.lgclblkno += count; 16785 rinfo->pos.blkno += count; 16786 un->un_running.lgclblkno += count; 16787 un->un_running.blkno += count; 16788 break; 16789 case DIR_REVC: 16790 rinfo->pos.lgclblkno -= count; 16791 rinfo->pos.blkno -= count; 16792 un->un_running.lgclblkno -= count; 16793 un->un_running.blkno -= count; 16794 break; 16795 default: 16796 ASSERT(0); 16797 break; 16798 } 16799 } 16800 } else if (rinfo->cmd_attrib->get_lba != NULL) { 16801 /* Have a get LBA fuction. i.e. Locate */ 16802 ASSERT(rinfo->cmd_attrib->chg_tape_direction == 16803 DIR_EITH); 16804 count = rinfo->cmd_attrib->get_lba(pkt->pkt_cdbp); 16805 un->un_running.lgclblkno = count; 16806 un->un_running.blkno = 0; 16807 un->un_running.fileno = 0; 16808 un->un_running.pmode = logical; 16809 rinfo->pos.lgclblkno = count; 16810 rinfo->pos.pmode = invalid; 16811 } else { 16812 ASSERT(0); 16813 } 16814 return; 16815 } 16816 16817 ST_CDB(ST_DEVINFO, "Unhanded CDB for position prediction", 16818 (char *)pkt->pkt_cdbp); 16819 16820 } 16821 16822 static int 16823 st_check_mode_for_change(struct scsi_tape *un, ubufunc_t ubf) 16824 { 16825 struct seq_mode *current; 16826 int rval; 16827 int i; 16828 caddr_t this; 16829 caddr_t that; 16830 16831 ST_FUNC(ST_DEVINFO, st_check_mode_for_change); 16832 16833 /* recovery called with mode tamper before mode selection */ 16834 if (un->un_comp_page == (ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE)) { 16835 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16836 "Mode Select not done yet"); 16837 return (0); 16838 } 16839 16840 current = kmem_zalloc(sizeof (struct seq_mode), KM_SLEEP); 16841 16842 rval = st_gen_mode_sense(un, ubf, un->un_comp_page, current, 16843 sizeof (struct seq_mode)); 16844 if (rval != 0) { 16845 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16846 "Mode Sense for mode verification failed"); 16847 kmem_free(current, sizeof (struct seq_mode)); 16848 return (rval); 16849 } 16850 16851 this = (caddr_t)current; 16852 that = (caddr_t)un->un_mspl; 16853 16854 rval = bcmp(this, that, sizeof (struct seq_mode)); 16855 if (rval == 0) { 16856 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 16857 "Found no changes in mode data"); 16858 } 16859 #ifdef STDEBUG 16860 else { 16861 for (i = 1; i < sizeof (struct seq_mode); i++) { 16862 if (this[i] != that[i]) { 16863 ST_RECOV(ST_DEVINFO, st_label, CE_CONT, 16864 "sense data changed at byte %d was " 16865 "0x%x now 0x%x", i, 16866 (uchar_t)that[i], (uchar_t)this[i]); 16867 } 16868 } 16869 } 16870 #endif 16871 kmem_free(current, sizeof (struct seq_mode)); 16872 16873 return (rval); 16874 } 16875 16876 static int 16877 st_test_path_to_device(struct scsi_tape *un) 16878 { 16879 int rval; 16880 16881 ST_FUNC(ST_DEVINFO, st_test_path_to_device); 16882 16883 /* 16884 * XXX Newer drives may not RESEVATION CONFLICT a TUR. 16885 */ 16886 do { 16887 rval = st_rcmd(un, SCMD_TEST_UNIT_READY, 0, SYNC_CMD); 16888 } while (rval == DEVICE_RESET); 16889 16890 return (rval); 16891 } 16892 16893 /* 16894 * Does read position using recov_buf and doesn't update un_pos. 16895 * Does what ever kind of read position you want. 16896 */ 16897 static int 16898 st_recovery_read_pos(struct scsi_tape *un, read_p_types type, 16899 read_pos_data_t *raw) 16900 { 16901 int rval; 16902 struct uscsi_cmd cmd; 16903 char cdb[CDB_GROUP1]; 16904 16905 ST_FUNC(ST_DEVINFO, st_recovery_read_pos); 16906 bzero(&cmd, sizeof (cmd)); 16907 16908 cdb[0] = SCMD_READ_POSITION; 16909 cdb[1] = type; 16910 cdb[2] = 0; 16911 cdb[3] = 0; 16912 cdb[4] = 0; 16913 cdb[5] = 0; 16914 cdb[6] = 0; 16915 cdb[7] = 0; 16916 cdb[8] = (type == EXT_POS) ? 28 : 0; 16917 cdb[9] = 0; 16918 16919 cmd.uscsi_flags = USCSI_READ; 16920 cmd.uscsi_timeout = un->un_dp->non_motion_timeout; 16921 cmd.uscsi_cdb = cdb; 16922 cmd.uscsi_cdblen = sizeof (cdb); 16923 cmd.uscsi_bufaddr = (caddr_t)raw; 16924 switch (type) { 16925 case SHORT_POS: 16926 cmd.uscsi_buflen = sizeof (tape_position_t); 16927 break; 16928 case LONG_POS: 16929 cmd.uscsi_buflen = sizeof (tape_position_long_t); 16930 break; 16931 case EXT_POS: 16932 cmd.uscsi_buflen = sizeof (tape_position_ext_t); 16933 break; 16934 default: 16935 ASSERT(0); 16936 } 16937 16938 rval = st_uscsi_rcmd(un, &cmd, FKIOCTL); 16939 if (cmd.uscsi_status) { 16940 rval = EIO; 16941 } 16942 return (rval); 16943 } 16944 16945 static int 16946 st_recovery_get_position(struct scsi_tape *un, tapepos_t *read, 16947 read_pos_data_t *raw) 16948 { 16949 int rval; 16950 read_p_types type = un->un_read_pos_type; 16951 16952 ST_FUNC(ST_DEVINFO, st_recovery_get_position); 16953 16954 rval = st_recovery_read_pos(un, type, raw); 16955 if (rval != 0) { 16956 return (rval); 16957 } 16958 rval = st_interpret_read_pos(un, read, type, sizeof (read_pos_data_t), 16959 (caddr_t)raw, 1); 16960 16961 return (rval); 16962 } 16963 16964 /* 16965 * based on the command do we retry, continue or give up? 16966 * possable return values? 16967 * zero do nothing looks fine. 16968 * EAGAIN retry. 16969 * EIO failed makes no sense. 16970 */ 16971 static int 16972 st_compare_expected_position(struct scsi_tape *un, st_err_info *ei, 16973 cmd_attribute const * cmd_att, tapepos_t *read) 16974 { 16975 int rval; 16976 read_pos_data_t *readp_datap; 16977 16978 ST_FUNC(ST_DEVINFO, st_compare_expected_position); 16979 16980 ASSERT(un != NULL); 16981 ASSERT(ei != NULL); 16982 ASSERT(read != NULL); 16983 ASSERT(cmd_att->chg_tape_pos); 16984 16985 COPY_POS(read, &ei->ei_expected_pos); 16986 16987 readp_datap = kmem_zalloc(sizeof (read_pos_data_t), KM_SLEEP); 16988 16989 rval = st_recovery_get_position(un, read, readp_datap); 16990 16991 kmem_free(readp_datap, sizeof (read_pos_data_t)); 16992 16993 if (rval != 0) { 16994 return (EIO); 16995 } 16996 16997 ST_POS(ST_DEVINFO, "st_compare_expected_position", read); 16998 16999 if ((read->pmode == invalid) || 17000 (ei->ei_expected_pos.pmode == invalid)) { 17001 return (EIO); 17002 } 17003 17004 /* 17005 * Command that changes tape position and have an expected position 17006 * if it were to chave completed sucessfully. 17007 */ 17008 if (cmd_att->recov_pos_type == POS_EXPECTED) { 17009 uint32_t count; 17010 int64_t difference; 17011 17012 /* At expected? */ 17013 if (read->lgclblkno == ei->ei_expected_pos.lgclblkno) { 17014 ST_RECOV(ST_DEVINFO, st_label, SCSI_DEBUG, 17015 "Found drive to be at expected position\n"); 17016 return (0); /* Good */ 17017 } 17018 ASSERT(cmd_att->get_cnt); 17019 count = cmd_att->get_cnt(ei->ei_failed_pkt.pkt_cdbp); 17020 17021 ST_RECOV(ST_DEVINFO, st_label, SCSI_DEBUG, 17022 "Got count from CDB and it was %d\n", count); 17023 if (cmd_att->chg_tape_direction == DIR_FORW) { 17024 difference = 17025 ei->ei_expected_pos.lgclblkno - read->lgclblkno; 17026 ST_RECOV(ST_DEVINFO, st_label, SCSI_DEBUG, 17027 "difference between expected and actual is %" 17028 PRId64"\n", difference); 17029 if (count == difference) { 17030 ST_RECOV(ST_DEVINFO, st_label, SCSI_DEBUG, 17031 "Found failed FORW command, retrying\n"); 17032 return (EAGAIN); 17033 } 17034 17035 /* 17036 * If rewound or somewhere between the starting position 17037 * and the expected position (partial read or write). 17038 * Locate to the starting position and try the whole 17039 * thing over again. 17040 */ 17041 if ((read->lgclblkno == 0) || 17042 ((difference > 0) && (difference < count))) { 17043 rval = st_logical_block_locate(un, 17044 st_uscsi_rcmd, read, 17045 ei->ei_expected_pos.lgclblkno - count, 17046 ei->ei_expected_pos.partition); 17047 if (rval == 0) { 17048 ST_RECOV(ST_DEVINFO, st_label, 17049 SCSI_DEBUG, "reestablished FORW" 17050 " command retrying\n"); 17051 return (EAGAIN); 17052 } 17053 /* This handles flushed read ahead on the drive */ 17054 } else if ((cmd_att->transfers_data == TRAN_READ) && 17055 (difference < 0)) { 17056 rval = st_logical_block_locate(un, 17057 st_uscsi_rcmd, read, 17058 ei->ei_expected_pos.lgclblkno - count, 17059 ei->ei_expected_pos.partition); 17060 if (rval == 0) { 17061 ST_RECOV(ST_DEVINFO, st_label, 17062 SCSI_DEBUG, "reestablished FORW" 17063 " read command retrying\n"); 17064 return (EAGAIN); 17065 } 17066 /* 17067 * XXX swag seeing difference of 2 on write filemark. 17068 * If the space to the starting position works on a 17069 * write that means the previous write made it to tape. 17070 * If not we lost data and have to give up. 17071 * 17072 * The plot thickens. Now I am attempting to cover a 17073 * count of 1 and a differance of 2 on a write. 17074 */ 17075 } else if (difference > count) { 17076 rval = st_logical_block_locate(un, 17077 st_uscsi_rcmd, read, 17078 ei->ei_expected_pos.lgclblkno - count, 17079 ei->ei_expected_pos.partition); 17080 if (rval == 0) { 17081 ST_RECOV(ST_DEVINFO, st_label, 17082 SCSI_DEBUG, "reestablished FORW" 17083 " write command retrying\n"); 17084 return (EAGAIN); 17085 } 17086 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 17087 "Seek to block %"PRId64" returned %d\n", 17088 ei->ei_expected_pos.lgclblkno - count, 17089 rval); 17090 } else { 17091 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 17092 "Not expected transfers_data = %d " 17093 "difference = %"PRId64, 17094 cmd_att->transfers_data, difference); 17095 } 17096 17097 return (EIO); 17098 17099 } else if (cmd_att->chg_tape_direction == DIR_REVC) { 17100 /* Don't think we can write backwards */ 17101 ASSERT(cmd_att->transfers_data != TRAN_WRTE); 17102 difference = 17103 read->lgclblkno - ei->ei_expected_pos.lgclblkno; 17104 ST_RECOV(ST_DEVINFO, st_label, SCSI_DEBUG, 17105 "difference between expected and actual is %" 17106 PRId64"\n", difference); 17107 if (count == difference) { 17108 ST_RECOV(ST_DEVINFO, st_label, SCSI_DEBUG, 17109 "Found failed REVC command, retrying\n"); 17110 return (EAGAIN); 17111 } 17112 if ((read->lgclblkno == 0) || 17113 ((difference > 0) && (difference < count))) { 17114 rval = st_logical_block_locate(un, 17115 st_uscsi_rcmd, read, 17116 ei->ei_expected_pos.lgclblkno + count, 17117 ei->ei_expected_pos.partition); 17118 if (rval == 0) { 17119 ST_RECOV(ST_DEVINFO, st_label, 17120 SCSI_DEBUG, "reestablished REVC" 17121 " command retrying\n"); 17122 return (EAGAIN); 17123 } 17124 /* This handles read ahead in reverse direction */ 17125 } else if ((cmd_att->transfers_data == TRAN_READ) && 17126 (difference < 0)) { 17127 rval = st_logical_block_locate(un, 17128 st_uscsi_rcmd, read, 17129 ei->ei_expected_pos.lgclblkno - count, 17130 ei->ei_expected_pos.partition); 17131 if (rval == 0) { 17132 ST_RECOV(ST_DEVINFO, st_label, 17133 SCSI_DEBUG, "reestablished REVC" 17134 " read command retrying\n"); 17135 return (EAGAIN); 17136 } 17137 } else { 17138 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 17139 "Not expected transfers_data = %d " 17140 "difference = %"PRId64, 17141 cmd_att->transfers_data, difference); 17142 } 17143 return (EIO); 17144 17145 } else { 17146 /* 17147 * Commands that change tape position either 17148 * direction or don't change position should not 17149 * get here. 17150 */ 17151 ASSERT(0); 17152 } 17153 scsi_log(ST_DEVINFO, st_label, CE_NOTE, 17154 "Didn't find a recoverable position, Failing\n"); 17155 17156 /* 17157 * Command that changes tape position and can only be recovered 17158 * by going back to the point of origin and retrying. 17159 * 17160 * Example SCMD_SPACE. 17161 */ 17162 } else if (cmd_att->recov_pos_type == POS_STARTING) { 17163 /* 17164 * This type of command stores the starting position. 17165 * If the read position is the starting position, 17166 * reissue the command. 17167 */ 17168 if (ei->ei_expected_pos.lgclblkno == read->lgclblkno) { 17169 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17170 "Found Space command at starting position, " 17171 "Reissuing\n"); 17172 return (EAGAIN); 17173 } 17174 /* 17175 * Not in the position that the command was originally issued, 17176 * Attempt to locate to that position. 17177 */ 17178 rval = st_logical_block_locate(un, st_uscsi_rcmd, read, 17179 ei->ei_expected_pos.lgclblkno, 17180 ei->ei_expected_pos.partition); 17181 if (rval) { 17182 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17183 "Found Space at an unexpected position and locate " 17184 "back to starting position failed\n"); 17185 return (EIO); 17186 } 17187 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17188 "Found Space at an unexpected position and locate " 17189 "back to starting position worked, Reissuing\n"); 17190 return (EAGAIN); 17191 } 17192 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 17193 "Unhandled attribute/expected position", &ei->ei_expected_pos); 17194 st_print_position(ST_DEVINFO, st_label, CE_NOTE, 17195 "Read position above did not make sense", read); 17196 ASSERT(0); 17197 return (EIO); 17198 } 17199 17200 static errstate 17201 st_recover_reissue_pkt(struct scsi_tape *un, struct scsi_pkt *oldpkt) 17202 { 17203 buf_t *bp; 17204 buf_t *pkt_bp; 17205 struct scsi_pkt *newpkt; 17206 cmd_attribute const *attrib; 17207 recov_info *rcv = oldpkt->pkt_private; 17208 uint_t cdblen; 17209 int rval; 17210 int stat_size = 17211 (un->un_arq_enabled ? sizeof (struct scsi_arq_status) : 1); 17212 17213 ST_FUNC(ST_DEVINFO, st_recover_reissue_pkt); 17214 17215 bp = rcv->cmd_bp; 17216 17217 if (rcv->privatelen == sizeof (recov_info)) { 17218 attrib = rcv->cmd_attrib; 17219 } else { 17220 attrib = st_lookup_cmd_attribute(oldpkt->pkt_cdbp[0]); 17221 } 17222 17223 /* 17224 * Some non-uscsi commands use the b_bcount for values that 17225 * have nothing to do with how much data is transfered. 17226 * In those cases we need to hide the buf_t from scsi_init_pkt(). 17227 */ 17228 if ((BP_UCMD(bp)) && (bp->b_bcount)) { 17229 pkt_bp = bp; 17230 } else if (attrib->transfers_data == TRAN_NONE) { 17231 pkt_bp = NULL; 17232 } else { 17233 pkt_bp = bp; 17234 } 17235 /* 17236 * if this is a queued command make sure it the only one in the 17237 * run queue. 17238 */ 17239 if (bp != un->un_sbufp && bp != un->un_recov_buf) { 17240 ASSERT(un->un_runqf == un->un_runql); 17241 ASSERT(un->un_runqf == bp); 17242 } 17243 17244 cdblen = scsi_cdb_size[CDB_GROUPID(oldpkt->pkt_cdbp[0])]; 17245 17246 newpkt = scsi_init_pkt(ROUTE, NULL, pkt_bp, cdblen, 17247 stat_size, rcv->privatelen, 0, NULL_FUNC, NULL); 17248 if (newpkt == NULL) { 17249 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17250 "Reissue pkt scsi_init_pkt() failure\n"); 17251 return (COMMAND_DONE_ERROR); 17252 } 17253 17254 ASSERT(newpkt->pkt_resid == 0); 17255 bp->b_flags &= ~(B_DONE); 17256 bp->b_resid = 0; 17257 st_bioerror(bp, 0); 17258 17259 bcopy(oldpkt->pkt_private, newpkt->pkt_private, rcv->privatelen); 17260 17261 newpkt->pkt_comp = oldpkt->pkt_comp; 17262 newpkt->pkt_time = oldpkt->pkt_time; 17263 17264 bzero(newpkt->pkt_scbp, stat_size); 17265 bcopy(oldpkt->pkt_cdbp, newpkt->pkt_cdbp, cdblen); 17266 17267 newpkt->pkt_state = 0; 17268 newpkt->pkt_statistics = 0; 17269 17270 SET_BP_PKT(bp, newpkt); 17271 17272 scsi_destroy_pkt(oldpkt); 17273 17274 rval = st_transport(un, newpkt); 17275 if (rval == TRAN_ACCEPT) { 17276 return (JUST_RETURN); 17277 } 17278 ST_RECOV(ST_DEVINFO, st_label, CE_NOTE, 17279 "Reissue pkt st_transport(0x%x) failure\n", rval); 17280 if (rval != TRAN_BUSY) { 17281 return (COMMAND_DONE_ERROR); 17282 } 17283 rval = st_handle_start_busy(un, bp, ST_TRAN_BUSY_TIMEOUT, 0); 17284 if (rval) { 17285 return (COMMAND_DONE_ERROR); 17286 } 17287 17288 return (JUST_RETURN); 17289 } 17290 17291 static int 17292 st_transport(struct scsi_tape *un, struct scsi_pkt *pkt) 17293 { 17294 int status; 17295 17296 ST_FUNC(ST_DEVINFO, st_transport); 17297 17298 ST_CDB(ST_DEVINFO, "transport CDB", (caddr_t)pkt->pkt_cdbp); 17299 17300 mutex_exit(ST_MUTEX); 17301 17302 status = scsi_transport(pkt); 17303 17304 mutex_enter(ST_MUTEX); 17305 17306 return (status); 17307 } 17308 17309 /* 17310 * Removed the buf_t bp from the queue referenced to by head and tail. 17311 * Returns the buf_t pointer if it is found in the queue. 17312 * Returns NULL if it is not found. 17313 */ 17314 static buf_t * 17315 st_remove_from_queue(buf_t **head, buf_t **tail, buf_t *bp) 17316 { 17317 buf_t *runqbp; 17318 buf_t *prevbp = NULL; 17319 17320 for (runqbp = *head; runqbp != 0; runqbp = runqbp->av_forw) { 17321 if (runqbp == bp) { 17322 /* found it, is it at the head? */ 17323 if (runqbp == *head) { 17324 *head = bp->av_forw; 17325 } else { 17326 prevbp->av_forw = bp->av_forw; 17327 } 17328 if (*tail == bp) { 17329 *tail = prevbp; 17330 } 17331 bp->av_forw = NULL; 17332 return (bp); /* found and removed */ 17333 } 17334 prevbp = runqbp; 17335 } 17336 return (NULL); 17337 } 17338 17339 /* 17340 * Adds a buf_t to the queue pointed to by head and tail. 17341 * Adds it either to the head end or the tail end based on which 17342 * the passed variable end (head or tail) points at. 17343 */ 17344 static void 17345 st_add_to_queue(buf_t **head, buf_t **tail, buf_t *end, buf_t *bp) 17346 { 17347 17348 bp->av_forw = NULL; 17349 if (*head) { 17350 /* Queue is not empty */ 17351 if (end == *head) { 17352 /* Add at front of queue */ 17353 bp->av_forw = *head; 17354 *head = bp; 17355 } else if (end == *tail) { 17356 /* Add at end of queue */ 17357 (*tail)->av_forw = bp; 17358 *tail = bp; 17359 } else { 17360 ASSERT(0); 17361 } 17362 } else { 17363 /* Queue is empty */ 17364 *head = bp; 17365 *tail = bp; 17366 } 17367 } 17368 17369 17370 static uint64_t 17371 st_get_cdb_g0_rw_count(uchar_t *cdb) 17372 { 17373 uint64_t count; 17374 17375 if ((cdb[1]) & 1) { 17376 /* fixed block mode, the count is the number of blocks */ 17377 count = 17378 cdb[2] << 16 | 17379 cdb[3] << 8 | 17380 cdb[4]; 17381 } else { 17382 /* variable block mode, the count is the block size */ 17383 count = 1; 17384 } 17385 return (count); 17386 } 17387 17388 static uint64_t 17389 st_get_cdb_g0_sign_count(uchar_t *cdb) 17390 { 17391 uint64_t count; 17392 17393 count = 17394 cdb[2] << 16 | 17395 cdb[3] << 8 | 17396 cdb[4]; 17397 /* 17398 * If the sign bit of the 3 byte value is set, extended it. 17399 */ 17400 if (count & 0x800000) { 17401 count |= 0xffffffffff000000; 17402 } 17403 return (count); 17404 } 17405 17406 static uint64_t 17407 st_get_cdb_g0_count(uchar_t *cdb) 17408 { 17409 uint64_t count; 17410 17411 count = 17412 cdb[2] << 16 | 17413 cdb[3] << 8 | 17414 cdb[4]; 17415 return (count); 17416 } 17417 17418 static uint64_t 17419 st_get_cdb_g5_rw_cnt(uchar_t *cdb) 17420 { 17421 uint64_t count; 17422 17423 if ((cdb[1]) & 1) { 17424 /* fixed block mode */ 17425 count = 17426 cdb[12] << 16 | 17427 cdb[13] << 8 | 17428 cdb[14]; 17429 } else { 17430 /* variable block mode */ 17431 count = 1; 17432 } 17433 return (count); 17434 } 17435 17436 static uint64_t 17437 st_get_no_count(uchar_t *cdb) 17438 { 17439 ASSERT(cdb[0] == SCMD_REWIND); 17440 return ((uint64_t)cdb[0]); 17441 } 17442 17443 static uint64_t 17444 st_get_load_options(uchar_t *cdb) 17445 { 17446 return ((uint64_t)(cdb[4] | (LD_HOLD << 1))); 17447 } 17448 17449 static uint64_t 17450 st_get_erase_options(uchar_t *cdb) 17451 { 17452 return (cdb[1] | (cdb[0] << 8)); 17453 } 17454 17455 static uint64_t 17456 st_get_cdb_g1_lba(uchar_t *cdb) 17457 { 17458 uint64_t lba; 17459 17460 lba = 17461 cdb[3] << 24 | 17462 cdb[4] << 16 | 17463 cdb[5] << 8 | 17464 cdb[6]; 17465 return (lba); 17466 } 17467 17468 static uint64_t 17469 st_get_cdb_g5_count(uchar_t *cdb) 17470 { 17471 uint64_t count = 17472 cdb[12] << 16 | 17473 cdb[13] << 8 | 17474 cdb[14]; 17475 17476 return (count); 17477 } 17478 17479 static uint64_t 17480 st_get_cdb_g4g5_cnt(uchar_t *cdb) 17481 { 17482 uint64_t lba; 17483 17484 lba = 17485 (uint64_t)cdb[4] << 56 | 17486 (uint64_t)cdb[5] << 48 | 17487 (uint64_t)cdb[6] << 40 | 17488 (uint64_t)cdb[7] << 32 | 17489 (uint64_t)cdb[8] << 24 | 17490 (uint64_t)cdb[9] << 16 | 17491 (uint64_t)cdb[10] << 8 | 17492 (uint64_t)cdb[11]; 17493 return (lba); 17494 } 17495 17496 static const cmd_attribute cmd_attributes[] = { 17497 { SCMD_TEST_UNIT_READY, 17498 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 17499 0, 0, 0 }, 17500 { SCMD_REWIND, 17501 1, 1, 1, 0, 0, DIR_REVC, TRAN_NONE, POS_EXPECTED, 17502 0, 0, 0, st_get_no_count }, 17503 { SCMD_REQUEST_SENSE, 17504 0, 0, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17505 0, 0, 0 }, 17506 { SCMD_READ_BLKLIM, 17507 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17508 0, 0, 0 }, 17509 { SCMD_READ, 17510 1, 0, 1, 0, 0, DIR_FORW, TRAN_READ, POS_EXPECTED, 17511 0, 0, 0, st_get_cdb_g0_rw_count }, 17512 { SCMD_WRITE, 17513 1, 0, 1, 1, 0, DIR_FORW, TRAN_WRTE, POS_EXPECTED, 17514 0, 0, 0, st_get_cdb_g0_rw_count }, 17515 { SCMD_READ_G4, 17516 1, 0, 1, 0, 1, DIR_FORW, TRAN_READ, POS_EXPECTED, 17517 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 17518 { SCMD_WRITE_G4, 17519 1, 0, 1, 1, 1, DIR_FORW, TRAN_WRTE, POS_EXPECTED, 17520 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 17521 { SCMD_READ_REVERSE, 17522 1, 0, 1, 1, 0, DIR_REVC, TRAN_READ, POS_EXPECTED, 17523 0, 0, 0, st_get_cdb_g0_rw_count }, 17524 { SCMD_READ_REVERSE_G4, 17525 1, 0, 1, 1, 1, DIR_REVC, TRAN_READ, POS_EXPECTED, 17526 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 17527 { SCMD_WRITE_FILE_MARK, 17528 1, 0, 1, 1, 0, DIR_FORW, TRAN_NONE, POS_EXPECTED, 17529 0, 0, 0, st_get_cdb_g0_count }, 17530 { SCMD_WRITE_FILE_MARK_G4, 17531 1, 0, 1, 1, 1, DIR_FORW, TRAN_NONE, POS_EXPECTED, 17532 0, 0, 0, st_get_cdb_g5_count, st_get_cdb_g4g5_cnt }, 17533 { SCMD_SPACE, 17534 1, 0, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_STARTING, 17535 0, 0, 0, st_get_cdb_g0_sign_count }, 17536 { SCMD_SPACE_G4, 17537 1, 0, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_STARTING, 17538 0, 0, 0, st_get_cdb_g4g5_cnt }, 17539 { SCMD_INQUIRY, 17540 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17541 0, 0, 0 }, 17542 { SCMD_VERIFY_G0, 17543 1, 0, 1, 0, 0, DIR_FORW, TRAN_NONE, POS_EXPECTED, 17544 0, 0, 0, st_get_cdb_g0_rw_count }, 17545 { SCMD_VERIFY_G4, 17546 1, 0, 1, 0, 1, DIR_FORW, TRAN_NONE, POS_EXPECTED, 17547 0, 0, 0, st_get_cdb_g5_rw_cnt, st_get_cdb_g4g5_cnt }, 17548 { SCMD_RECOVER_BUF, 17549 1, 0, 1, 1, 0, DIR_REVC, TRAN_READ, POS_EXPECTED, 17550 0, 0, 0 }, 17551 { SCMD_MODE_SELECT, 17552 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 17553 0, 0, 0 }, 17554 { SCMD_RESERVE, 17555 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 17556 0, 0, 0 }, 17557 { SCMD_RELEASE, 17558 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 17559 0, 0, 0 }, 17560 { SCMD_ERASE, 17561 1, 0, 1, 1, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 17562 0, 0, 0, st_get_erase_options }, 17563 { SCMD_MODE_SENSE, 17564 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17565 0, 0, 0 }, 17566 { SCMD_LOAD, 17567 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 17568 0, 0, 0, st_get_load_options }, 17569 { SCMD_GDIAG, 17570 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17571 1, 0, 0 }, 17572 { SCMD_SDIAG, 17573 1, 0, 1, 1, 0, DIR_EITH, TRAN_WRTE, POS_EXPECTED, 17574 1, 0, 0 }, 17575 { SCMD_DOORLOCK, 17576 0, 1, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_EXPECTED, 17577 0, 4, 3 }, 17578 { SCMD_LOCATE, 17579 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 17580 0, 0, 0, NULL, st_get_cdb_g1_lba }, 17581 { SCMD_READ_POSITION, 17582 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17583 0, 0, 0 }, 17584 { SCMD_WRITE_BUFFER, 17585 1, 0, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 17586 1, 0, 0 }, 17587 { SCMD_READ_BUFFER, 17588 1, 0, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17589 1, 0, 0 }, 17590 { SCMD_REPORT_DENSITIES, 17591 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17592 0, 0, 0 }, 17593 { SCMD_LOG_SELECT_G1, 17594 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 17595 0, 0, 0 }, 17596 { SCMD_LOG_SENSE_G1, 17597 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17598 0, 0, 0 }, 17599 { SCMD_PRIN, 17600 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17601 0, 0, 0 }, 17602 { SCMD_PROUT, 17603 0, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 17604 0, 0, 0 }, 17605 { SCMD_READ_ATTRIBUTE, 17606 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17607 0, 0, 0 }, 17608 { SCMD_WRITE_ATTRIBUTE, 17609 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 17610 0, 0, 0 }, 17611 { SCMD_LOCATE_G4, 17612 1, 1, 1, 0, 0, DIR_EITH, TRAN_NONE, POS_EXPECTED, 17613 0, 0, 0, NULL, st_get_cdb_g4g5_cnt }, 17614 { SCMD_REPORT_LUNS, 17615 0, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17616 0, 0, 0 }, 17617 { SCMD_SVC_ACTION_IN_G5, 17618 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17619 0, 0, 0 }, 17620 { SCMD_MAINTENANCE_IN, 17621 1, 1, 0, 0, 0, DIR_NONE, TRAN_READ, POS_EXPECTED, 17622 0, 0, 0 }, 17623 { SCMD_MAINTENANCE_OUT, 17624 1, 1, 0, 0, 0, DIR_NONE, TRAN_WRTE, POS_EXPECTED, 17625 0, 0, 0 }, 17626 { 0xff, /* Default attribute for unsupported commands */ 17627 1, 0, 0, 0, 0, DIR_NONE, TRAN_NONE, POS_STARTING, 17628 1, 0, 0, NULL, NULL } 17629 }; 17630 17631 static const cmd_attribute * 17632 st_lookup_cmd_attribute(unsigned char cmd) 17633 { 17634 int i; 17635 cmd_attribute const *attribute; 17636 17637 for (i = 0; i < ST_NUM_MEMBERS(cmd_attributes); i++) { 17638 attribute = &cmd_attributes[i]; 17639 if (attribute->cmd == cmd) { 17640 return (attribute); 17641 } 17642 } 17643 ASSERT(attribute); 17644 return (attribute); 17645 } 17646 17647 static int 17648 st_reset(struct scsi_tape *un, int reset_type) 17649 { 17650 int rval; 17651 17652 ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex)); 17653 17654 ST_FUNC(ST_DEVINFO, st_reset); 17655 un->un_rsvd_status |= ST_INITIATED_RESET; 17656 mutex_exit(ST_MUTEX); 17657 do { 17658 rval = scsi_reset(&un->un_sd->sd_address, reset_type); 17659 if (rval == 0) { 17660 switch (reset_type) { 17661 case RESET_LUN: 17662 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 17663 "LUN reset failed trying target reset"); 17664 reset_type = RESET_TARGET; 17665 break; 17666 case RESET_TARGET: 17667 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 17668 "target reset failed trying bus reset"); 17669 reset_type = RESET_BUS; 17670 break; 17671 case RESET_BUS: 17672 ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN, 17673 "bus reset failed trying all reset"); 17674 reset_type = RESET_ALL; 17675 default: 17676 mutex_enter(ST_MUTEX); 17677 return (rval); 17678 } 17679 } 17680 } while (rval == 0); 17681 mutex_enter(ST_MUTEX); 17682 return (rval); 17683 } 17684 17685 17686 static void 17687 st_reset_notification(caddr_t arg) 17688 { 17689 struct scsi_tape *un = (struct scsi_tape *)arg; 17690 17691 ST_FUNC(ST_DEVINFO, st_reset_notification); 17692 mutex_enter(ST_MUTEX); 17693 17694 un->un_unit_attention_flags = 2; 17695 if ((un->un_rsvd_status & (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 17696 ST_RESERVE) { 17697 un->un_rsvd_status |= ST_LOST_RESERVE; 17698 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 17699 "Lost Reservation notification"); 17700 } else { 17701 ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN, 17702 "reset notification"); 17703 } 17704 17705 if ((un->un_restore_pos == 0) && 17706 (un->un_state == ST_STATE_CLOSED) || 17707 (un->un_state == ST_STATE_OPEN_PENDING_IO) || 17708 (un->un_state == ST_STATE_CLOSING)) { 17709 un->un_restore_pos = 1; 17710 } 17711 ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN, 17712 "reset and state was %d\n", un->un_state); 17713 mutex_exit(ST_MUTEX); 17714 } 17715