1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying 4 file Documentation/scsi/st.rst for more information. 5 6 History: 7 Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara. 8 Contribution and ideas from several people including (in alphabetical 9 order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk, 10 Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky, 11 Michael Schaefer, J"org Weule, and Eric Youngdale. 12 13 Copyright 1992 - 2016 Kai Makisara 14 email Kai.Makisara@kolumbus.fi 15 16 Some small formal changes - aeb, 950809 17 18 Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support 19 */ 20 21 static const char *verstr = "20160209"; 22 23 #include <linux/module.h> 24 25 #include <linux/compat.h> 26 #include <linux/fs.h> 27 #include <linux/kernel.h> 28 #include <linux/sched/signal.h> 29 #include <linux/mm.h> 30 #include <linux/init.h> 31 #include <linux/string.h> 32 #include <linux/slab.h> 33 #include <linux/errno.h> 34 #include <linux/mtio.h> 35 #include <linux/major.h> 36 #include <linux/cdrom.h> 37 #include <linux/ioctl.h> 38 #include <linux/fcntl.h> 39 #include <linux/spinlock.h> 40 #include <linux/blkdev.h> 41 #include <linux/moduleparam.h> 42 #include <linux/cdev.h> 43 #include <linux/idr.h> 44 #include <linux/delay.h> 45 #include <linux/mutex.h> 46 47 #include <linux/uaccess.h> 48 #include <asm/dma.h> 49 #include <asm/unaligned.h> 50 51 #include <scsi/scsi.h> 52 #include <scsi/scsi_dbg.h> 53 #include <scsi/scsi_device.h> 54 #include <scsi/scsi_driver.h> 55 #include <scsi/scsi_eh.h> 56 #include <scsi/scsi_host.h> 57 #include <scsi/scsi_ioctl.h> 58 #include <scsi/sg.h> 59 60 61 /* The driver prints some debugging information on the console if DEBUG 62 is defined and non-zero. */ 63 #define DEBUG 1 64 #define NO_DEBUG 0 65 66 #define ST_DEB_MSG KERN_NOTICE 67 #if DEBUG 68 /* The message level for the debug messages is currently set to KERN_NOTICE 69 so that people can easily see the messages. Later when the debugging messages 70 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */ 71 #define DEB(a) a 72 #define DEBC(a) if (debugging) { a ; } 73 #else 74 #define DEB(a) 75 #define DEBC(a) 76 #endif 77 78 #define ST_KILOBYTE 1024 79 80 #include "st_options.h" 81 #include "st.h" 82 83 static int buffer_kbs; 84 static int max_sg_segs; 85 static int try_direct_io = TRY_DIRECT_IO; 86 static int try_rdio = 1; 87 static int try_wdio = 1; 88 static int debug_flag; 89 90 static struct class st_sysfs_class; 91 static const struct attribute_group *st_dev_groups[]; 92 static const struct attribute_group *st_drv_groups[]; 93 94 MODULE_AUTHOR("Kai Makisara"); 95 MODULE_DESCRIPTION("SCSI tape (st) driver"); 96 MODULE_LICENSE("GPL"); 97 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR); 98 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE); 99 100 /* Set 'perm' (4th argument) to 0 to disable module_param's definition 101 * of sysfs parameters (which module_param doesn't yet support). 102 * Sysfs parameters defined explicitly later. 103 */ 104 module_param_named(buffer_kbs, buffer_kbs, int, 0); 105 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)"); 106 module_param_named(max_sg_segs, max_sg_segs, int, 0); 107 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)"); 108 module_param_named(try_direct_io, try_direct_io, int, 0); 109 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)"); 110 module_param_named(debug_flag, debug_flag, int, 0); 111 MODULE_PARM_DESC(debug_flag, "Enable DEBUG, same as setting debugging=1"); 112 113 114 /* Extra parameters for testing */ 115 module_param_named(try_rdio, try_rdio, int, 0); 116 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible"); 117 module_param_named(try_wdio, try_wdio, int, 0); 118 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible"); 119 120 #ifndef MODULE 121 static int write_threshold_kbs; /* retained for compatibility */ 122 static struct st_dev_parm { 123 char *name; 124 int *val; 125 } parms[] __initdata = { 126 { 127 "buffer_kbs", &buffer_kbs 128 }, 129 { /* Retained for compatibility with 2.4 */ 130 "write_threshold_kbs", &write_threshold_kbs 131 }, 132 { 133 "max_sg_segs", NULL 134 }, 135 { 136 "try_direct_io", &try_direct_io 137 }, 138 { 139 "debug_flag", &debug_flag 140 } 141 }; 142 #endif 143 144 /* Restrict the number of modes so that names for all are assigned */ 145 #if ST_NBR_MODES > 16 146 #error "Maximum number of modes is 16" 147 #endif 148 /* Bit reversed order to get same names for same minors with all 149 mode counts */ 150 static const char *st_formats[] = { 151 "", "r", "k", "s", "l", "t", "o", "u", 152 "m", "v", "p", "x", "a", "y", "q", "z"}; 153 154 /* The default definitions have been moved to st_options.h */ 155 156 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE) 157 158 /* The buffer size should fit into the 24 bits for length in the 159 6-byte SCSI read and write commands. */ 160 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1) 161 #error "Buffer size should not exceed (2 << 24 - 1) bytes!" 162 #endif 163 164 static int debugging = DEBUG; 165 166 #define MAX_RETRIES 0 167 #define MAX_WRITE_RETRIES 0 168 #define MAX_READY_RETRIES 0 169 #define NO_TAPE NOT_READY 170 171 #define ST_TIMEOUT (900 * HZ) 172 #define ST_LONG_TIMEOUT (14000 * HZ) 173 174 /* Remove mode bits and auto-rewind bit (7) */ 175 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \ 176 (iminor(x) & ((1 << ST_MODE_SHIFT)-1))) 177 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT) 178 179 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */ 180 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \ 181 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) ) 182 183 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower 184 24 bits) */ 185 #define SET_DENS_AND_BLK 0x10001 186 187 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE; 188 static int st_max_sg_segs = ST_MAX_SG; 189 190 static int modes_defined; 191 192 static int enlarge_buffer(struct st_buffer *, int); 193 static void clear_buffer(struct st_buffer *); 194 static void normalize_buffer(struct st_buffer *); 195 static int append_to_buffer(const char __user *, struct st_buffer *, int); 196 static int from_buffer(struct st_buffer *, char __user *, int); 197 static void move_buffer_data(struct st_buffer *, int); 198 199 static int sgl_map_user_pages(struct st_buffer *, const unsigned int, 200 unsigned long, size_t, int); 201 static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int); 202 203 static int st_probe(struct device *); 204 static int st_remove(struct device *); 205 206 static struct scsi_driver st_template = { 207 .gendrv = { 208 .name = "st", 209 .owner = THIS_MODULE, 210 .probe = st_probe, 211 .remove = st_remove, 212 .groups = st_drv_groups, 213 }, 214 }; 215 216 static int st_compression(struct scsi_tape *, int); 217 218 static int find_partition(struct scsi_tape *); 219 static int switch_partition(struct scsi_tape *); 220 221 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long); 222 223 static void scsi_tape_release(struct kref *); 224 225 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref) 226 227 static DEFINE_MUTEX(st_ref_mutex); 228 static DEFINE_SPINLOCK(st_index_lock); 229 static DEFINE_SPINLOCK(st_use_lock); 230 static DEFINE_IDR(st_index_idr); 231 232 233 234 #ifndef SIGS_FROM_OSST 235 #define SIGS_FROM_OSST \ 236 {"OnStream", "SC-", "", "osst"}, \ 237 {"OnStream", "DI-", "", "osst"}, \ 238 {"OnStream", "DP-", "", "osst"}, \ 239 {"OnStream", "USB", "", "osst"}, \ 240 {"OnStream", "FW-", "", "osst"} 241 #endif 242 243 static struct scsi_tape *scsi_tape_get(int dev) 244 { 245 struct scsi_tape *STp = NULL; 246 247 mutex_lock(&st_ref_mutex); 248 spin_lock(&st_index_lock); 249 250 STp = idr_find(&st_index_idr, dev); 251 if (!STp) goto out; 252 253 kref_get(&STp->kref); 254 255 if (!STp->device) 256 goto out_put; 257 258 if (scsi_device_get(STp->device)) 259 goto out_put; 260 261 goto out; 262 263 out_put: 264 kref_put(&STp->kref, scsi_tape_release); 265 STp = NULL; 266 out: 267 spin_unlock(&st_index_lock); 268 mutex_unlock(&st_ref_mutex); 269 return STp; 270 } 271 272 static void scsi_tape_put(struct scsi_tape *STp) 273 { 274 struct scsi_device *sdev = STp->device; 275 276 mutex_lock(&st_ref_mutex); 277 kref_put(&STp->kref, scsi_tape_release); 278 scsi_device_put(sdev); 279 mutex_unlock(&st_ref_mutex); 280 } 281 282 struct st_reject_data { 283 char *vendor; 284 char *model; 285 char *rev; 286 char *driver_hint; /* Name of the correct driver, NULL if unknown */ 287 }; 288 289 static struct st_reject_data reject_list[] = { 290 /* {"XXX", "Yy-", "", NULL}, example */ 291 SIGS_FROM_OSST, 292 {NULL, }}; 293 294 /* If the device signature is on the list of incompatible drives, the 295 function returns a pointer to the name of the correct driver (if known) */ 296 static char * st_incompatible(struct scsi_device* SDp) 297 { 298 struct st_reject_data *rp; 299 300 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++) 301 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) && 302 !strncmp(rp->model, SDp->model, strlen(rp->model)) && 303 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) { 304 if (rp->driver_hint) 305 return rp->driver_hint; 306 else 307 return "unknown"; 308 } 309 return NULL; 310 } 311 312 313 #define st_printk(prefix, t, fmt, a...) \ 314 sdev_prefix_printk(prefix, (t)->device, (t)->name, fmt, ##a) 315 #ifdef DEBUG 316 #define DEBC_printk(t, fmt, a...) \ 317 if (debugging) { st_printk(ST_DEB_MSG, t, fmt, ##a ); } 318 #else 319 #define DEBC_printk(t, fmt, a...) 320 #endif 321 322 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s) 323 { 324 const u8 *ucp; 325 const u8 *sense = SRpnt->sense; 326 327 s->have_sense = scsi_normalize_sense(SRpnt->sense, 328 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr); 329 s->flags = 0; 330 331 if (s->have_sense) { 332 s->deferred = 0; 333 s->remainder_valid = 334 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64); 335 switch (sense[0] & 0x7f) { 336 case 0x71: 337 s->deferred = 1; 338 fallthrough; 339 case 0x70: 340 s->fixed_format = 1; 341 s->flags = sense[2] & 0xe0; 342 break; 343 case 0x73: 344 s->deferred = 1; 345 fallthrough; 346 case 0x72: 347 s->fixed_format = 0; 348 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4); 349 s->flags = ucp ? (ucp[3] & 0xe0) : 0; 350 break; 351 } 352 } 353 } 354 355 356 /* Convert the result to success code */ 357 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) 358 { 359 int result = SRpnt->result; 360 u8 scode; 361 DEB(const char *stp;) 362 char *name = STp->name; 363 struct st_cmdstatus *cmdstatp; 364 365 if (!result) 366 return 0; 367 368 cmdstatp = &STp->buffer->cmdstat; 369 st_analyze_sense(SRpnt, cmdstatp); 370 371 if (cmdstatp->have_sense) 372 scode = STp->buffer->cmdstat.sense_hdr.sense_key; 373 else 374 scode = 0; 375 376 DEB( 377 if (debugging) { 378 st_printk(ST_DEB_MSG, STp, 379 "Error: %x, cmd: %x %x %x %x %x %x\n", result, 380 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2], 381 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]); 382 if (cmdstatp->have_sense) 383 __scsi_print_sense(STp->device, name, 384 SRpnt->sense, SCSI_SENSE_BUFFERSIZE); 385 } ) /* end DEB */ 386 if (!debugging) { /* Abnormal conditions for tape */ 387 if (!cmdstatp->have_sense) 388 st_printk(KERN_WARNING, STp, 389 "Error %x (driver bt 0, host bt 0x%x).\n", 390 result, host_byte(result)); 391 else if (cmdstatp->have_sense && 392 scode != NO_SENSE && 393 scode != RECOVERED_ERROR && 394 /* scode != UNIT_ATTENTION && */ 395 scode != BLANK_CHECK && 396 scode != VOLUME_OVERFLOW && 397 SRpnt->cmd[0] != MODE_SENSE && 398 SRpnt->cmd[0] != TEST_UNIT_READY) { 399 400 __scsi_print_sense(STp->device, name, 401 SRpnt->sense, SCSI_SENSE_BUFFERSIZE); 402 } 403 } 404 405 if (cmdstatp->fixed_format && 406 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */ 407 if (STp->cln_sense_value) 408 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] & 409 STp->cln_sense_mask) == STp->cln_sense_value); 410 else 411 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] & 412 STp->cln_sense_mask) != 0); 413 } 414 if (cmdstatp->have_sense && 415 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17) 416 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */ 417 if (cmdstatp->have_sense && scode == UNIT_ATTENTION && cmdstatp->sense_hdr.asc == 0x29) 418 STp->pos_unknown = 1; /* ASC => power on / reset */ 419 420 STp->pos_unknown |= STp->device->was_reset; 421 422 if (cmdstatp->have_sense && 423 scode == RECOVERED_ERROR 424 #if ST_RECOVERED_WRITE_FATAL 425 && SRpnt->cmd[0] != WRITE_6 426 && SRpnt->cmd[0] != WRITE_FILEMARKS 427 #endif 428 ) { 429 STp->recover_count++; 430 STp->recover_reg++; 431 432 DEB( 433 if (debugging) { 434 if (SRpnt->cmd[0] == READ_6) 435 stp = "read"; 436 else if (SRpnt->cmd[0] == WRITE_6) 437 stp = "write"; 438 else 439 stp = "ioctl"; 440 st_printk(ST_DEB_MSG, STp, 441 "Recovered %s error (%d).\n", 442 stp, STp->recover_count); 443 } ) /* end DEB */ 444 445 if (cmdstatp->flags == 0) 446 return 0; 447 } 448 return (-EIO); 449 } 450 451 static struct st_request *st_allocate_request(struct scsi_tape *stp) 452 { 453 struct st_request *streq; 454 455 streq = kzalloc(sizeof(*streq), GFP_KERNEL); 456 if (streq) 457 streq->stp = stp; 458 else { 459 st_printk(KERN_ERR, stp, 460 "Can't get SCSI request.\n"); 461 if (signal_pending(current)) 462 stp->buffer->syscall_result = -EINTR; 463 else 464 stp->buffer->syscall_result = -EBUSY; 465 } 466 467 return streq; 468 } 469 470 static void st_release_request(struct st_request *streq) 471 { 472 kfree(streq); 473 } 474 475 static void st_do_stats(struct scsi_tape *STp, struct request *req) 476 { 477 struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req); 478 ktime_t now; 479 480 now = ktime_get(); 481 if (scmd->cmnd[0] == WRITE_6) { 482 now = ktime_sub(now, STp->stats->write_time); 483 atomic64_add(ktime_to_ns(now), &STp->stats->tot_write_time); 484 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time); 485 atomic64_inc(&STp->stats->write_cnt); 486 if (scmd->result) { 487 atomic64_add(atomic_read(&STp->stats->last_write_size) 488 - STp->buffer->cmdstat.residual, 489 &STp->stats->write_byte_cnt); 490 if (STp->buffer->cmdstat.residual > 0) 491 atomic64_inc(&STp->stats->resid_cnt); 492 } else 493 atomic64_add(atomic_read(&STp->stats->last_write_size), 494 &STp->stats->write_byte_cnt); 495 } else if (scmd->cmnd[0] == READ_6) { 496 now = ktime_sub(now, STp->stats->read_time); 497 atomic64_add(ktime_to_ns(now), &STp->stats->tot_read_time); 498 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time); 499 atomic64_inc(&STp->stats->read_cnt); 500 if (scmd->result) { 501 atomic64_add(atomic_read(&STp->stats->last_read_size) 502 - STp->buffer->cmdstat.residual, 503 &STp->stats->read_byte_cnt); 504 if (STp->buffer->cmdstat.residual > 0) 505 atomic64_inc(&STp->stats->resid_cnt); 506 } else 507 atomic64_add(atomic_read(&STp->stats->last_read_size), 508 &STp->stats->read_byte_cnt); 509 } else { 510 now = ktime_sub(now, STp->stats->other_time); 511 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time); 512 atomic64_inc(&STp->stats->other_cnt); 513 } 514 atomic64_dec(&STp->stats->in_flight); 515 } 516 517 static enum rq_end_io_ret st_scsi_execute_end(struct request *req, 518 blk_status_t status) 519 { 520 struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req); 521 struct st_request *SRpnt = req->end_io_data; 522 struct scsi_tape *STp = SRpnt->stp; 523 struct bio *tmp; 524 525 STp->buffer->cmdstat.midlevel_result = SRpnt->result = scmd->result; 526 STp->buffer->cmdstat.residual = scmd->resid_len; 527 528 st_do_stats(STp, req); 529 530 tmp = SRpnt->bio; 531 if (scmd->sense_len) 532 memcpy(SRpnt->sense, scmd->sense_buffer, SCSI_SENSE_BUFFERSIZE); 533 if (SRpnt->waiting) 534 complete(SRpnt->waiting); 535 536 blk_rq_unmap_user(tmp); 537 blk_mq_free_request(req); 538 return RQ_END_IO_NONE; 539 } 540 541 static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd, 542 int data_direction, void *buffer, unsigned bufflen, 543 int timeout, int retries) 544 { 545 struct request *req; 546 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data; 547 int err = 0; 548 struct scsi_tape *STp = SRpnt->stp; 549 struct scsi_cmnd *scmd; 550 551 req = scsi_alloc_request(SRpnt->stp->device->request_queue, 552 data_direction == DMA_TO_DEVICE ? 553 REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0); 554 if (IS_ERR(req)) 555 return PTR_ERR(req); 556 scmd = blk_mq_rq_to_pdu(req); 557 req->rq_flags |= RQF_QUIET; 558 559 mdata->null_mapped = 1; 560 561 if (bufflen) { 562 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen, 563 GFP_KERNEL); 564 if (err) { 565 blk_mq_free_request(req); 566 return err; 567 } 568 } 569 570 atomic64_inc(&STp->stats->in_flight); 571 if (cmd[0] == WRITE_6) { 572 atomic_set(&STp->stats->last_write_size, bufflen); 573 STp->stats->write_time = ktime_get(); 574 } else if (cmd[0] == READ_6) { 575 atomic_set(&STp->stats->last_read_size, bufflen); 576 STp->stats->read_time = ktime_get(); 577 } else { 578 STp->stats->other_time = ktime_get(); 579 } 580 581 SRpnt->bio = req->bio; 582 scmd->cmd_len = COMMAND_SIZE(cmd[0]); 583 memcpy(scmd->cmnd, cmd, scmd->cmd_len); 584 req->timeout = timeout; 585 scmd->allowed = retries; 586 req->end_io = st_scsi_execute_end; 587 req->end_io_data = SRpnt; 588 589 blk_execute_rq_nowait(req, true); 590 return 0; 591 } 592 593 /* Do the scsi command. Waits until command performed if do_wait is true. 594 Otherwise write_behind_check() is used to check that the command 595 has finished. */ 596 static struct st_request * 597 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd, 598 int bytes, int direction, int timeout, int retries, int do_wait) 599 { 600 struct completion *waiting; 601 struct rq_map_data *mdata = &STp->buffer->map_data; 602 int ret; 603 604 /* if async, make sure there's no command outstanding */ 605 if (!do_wait && ((STp->buffer)->last_SRpnt)) { 606 st_printk(KERN_ERR, STp, 607 "Async command already active.\n"); 608 if (signal_pending(current)) 609 (STp->buffer)->syscall_result = (-EINTR); 610 else 611 (STp->buffer)->syscall_result = (-EBUSY); 612 return NULL; 613 } 614 615 if (!SRpnt) { 616 SRpnt = st_allocate_request(STp); 617 if (!SRpnt) 618 return NULL; 619 } 620 621 /* If async IO, set last_SRpnt. This ptr tells write_behind_check 622 which IO is outstanding. It's nulled out when the IO completes. */ 623 if (!do_wait) 624 (STp->buffer)->last_SRpnt = SRpnt; 625 626 waiting = &STp->wait; 627 init_completion(waiting); 628 SRpnt->waiting = waiting; 629 630 if (STp->buffer->do_dio) { 631 mdata->page_order = 0; 632 mdata->nr_entries = STp->buffer->sg_segs; 633 mdata->pages = STp->buffer->mapped_pages; 634 } else { 635 mdata->page_order = STp->buffer->reserved_page_order; 636 mdata->nr_entries = 637 DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order); 638 mdata->pages = STp->buffer->reserved_pages; 639 mdata->offset = 0; 640 } 641 642 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd)); 643 STp->buffer->cmdstat.have_sense = 0; 644 STp->buffer->syscall_result = 0; 645 646 ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout, 647 retries); 648 if (ret) { 649 /* could not allocate the buffer or request was too large */ 650 (STp->buffer)->syscall_result = (-EBUSY); 651 (STp->buffer)->last_SRpnt = NULL; 652 } else if (do_wait) { 653 wait_for_completion(waiting); 654 SRpnt->waiting = NULL; 655 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); 656 } 657 658 return SRpnt; 659 } 660 661 662 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if 663 write has been correct but EOM early warning reached, -EIO if write ended in 664 error or zero if write successful. Asynchronous writes are used only in 665 variable block mode. */ 666 static int write_behind_check(struct scsi_tape * STp) 667 { 668 int retval = 0; 669 struct st_buffer *STbuffer; 670 struct st_partstat *STps; 671 struct st_cmdstatus *cmdstatp; 672 struct st_request *SRpnt; 673 674 STbuffer = STp->buffer; 675 if (!STbuffer->writing) 676 return 0; 677 678 DEB( 679 if (STp->write_pending) 680 STp->nbr_waits++; 681 else 682 STp->nbr_finished++; 683 ) /* end DEB */ 684 685 wait_for_completion(&(STp->wait)); 686 SRpnt = STbuffer->last_SRpnt; 687 STbuffer->last_SRpnt = NULL; 688 SRpnt->waiting = NULL; 689 690 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); 691 st_release_request(SRpnt); 692 693 STbuffer->buffer_bytes -= STbuffer->writing; 694 STps = &(STp->ps[STp->partition]); 695 if (STps->drv_block >= 0) { 696 if (STp->block_size == 0) 697 STps->drv_block++; 698 else 699 STps->drv_block += STbuffer->writing / STp->block_size; 700 } 701 702 cmdstatp = &STbuffer->cmdstat; 703 if (STbuffer->syscall_result) { 704 retval = -EIO; 705 if (cmdstatp->have_sense && !cmdstatp->deferred && 706 (cmdstatp->flags & SENSE_EOM) && 707 (cmdstatp->sense_hdr.sense_key == NO_SENSE || 708 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) { 709 /* EOM at write-behind, has all data been written? */ 710 if (!cmdstatp->remainder_valid || 711 cmdstatp->uremainder64 == 0) 712 retval = -ENOSPC; 713 } 714 if (retval == -EIO) 715 STps->drv_block = -1; 716 } 717 STbuffer->writing = 0; 718 719 DEB(if (debugging && retval) 720 st_printk(ST_DEB_MSG, STp, 721 "Async write error %x, return value %d.\n", 722 STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */ 723 724 return retval; 725 } 726 727 728 /* Step over EOF if it has been inadvertently crossed (ioctl not used because 729 it messes up the block number). */ 730 static int cross_eof(struct scsi_tape * STp, int forward) 731 { 732 struct st_request *SRpnt; 733 unsigned char cmd[MAX_COMMAND_SIZE]; 734 735 cmd[0] = SPACE; 736 cmd[1] = 0x01; /* Space FileMarks */ 737 if (forward) { 738 cmd[2] = cmd[3] = 0; 739 cmd[4] = 1; 740 } else 741 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */ 742 cmd[5] = 0; 743 744 DEBC_printk(STp, "Stepping over filemark %s.\n", 745 forward ? "forward" : "backward"); 746 747 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 748 STp->device->request_queue->rq_timeout, 749 MAX_RETRIES, 1); 750 if (!SRpnt) 751 return (STp->buffer)->syscall_result; 752 753 st_release_request(SRpnt); 754 SRpnt = NULL; 755 756 if ((STp->buffer)->cmdstat.midlevel_result != 0) 757 st_printk(KERN_ERR, STp, 758 "Stepping over filemark %s failed.\n", 759 forward ? "forward" : "backward"); 760 761 return (STp->buffer)->syscall_result; 762 } 763 764 765 /* Flush the write buffer (never need to write if variable blocksize). */ 766 static int st_flush_write_buffer(struct scsi_tape * STp) 767 { 768 int transfer, blks; 769 int result; 770 unsigned char cmd[MAX_COMMAND_SIZE]; 771 struct st_request *SRpnt; 772 struct st_partstat *STps; 773 774 result = write_behind_check(STp); 775 if (result) 776 return result; 777 778 result = 0; 779 if (STp->dirty == 1) { 780 781 transfer = STp->buffer->buffer_bytes; 782 DEBC_printk(STp, "Flushing %d bytes.\n", transfer); 783 784 memset(cmd, 0, MAX_COMMAND_SIZE); 785 cmd[0] = WRITE_6; 786 cmd[1] = 1; 787 blks = transfer / STp->block_size; 788 cmd[2] = blks >> 16; 789 cmd[3] = blks >> 8; 790 cmd[4] = blks; 791 792 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE, 793 STp->device->request_queue->rq_timeout, 794 MAX_WRITE_RETRIES, 1); 795 if (!SRpnt) 796 return (STp->buffer)->syscall_result; 797 798 STps = &(STp->ps[STp->partition]); 799 if ((STp->buffer)->syscall_result != 0) { 800 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 801 802 if (cmdstatp->have_sense && !cmdstatp->deferred && 803 (cmdstatp->flags & SENSE_EOM) && 804 (cmdstatp->sense_hdr.sense_key == NO_SENSE || 805 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 806 (!cmdstatp->remainder_valid || 807 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */ 808 STp->dirty = 0; 809 (STp->buffer)->buffer_bytes = 0; 810 if (STps->drv_block >= 0) 811 STps->drv_block += blks; 812 result = (-ENOSPC); 813 } else { 814 st_printk(KERN_ERR, STp, "Error on flush.\n"); 815 STps->drv_block = (-1); 816 result = (-EIO); 817 } 818 } else { 819 if (STps->drv_block >= 0) 820 STps->drv_block += blks; 821 STp->dirty = 0; 822 (STp->buffer)->buffer_bytes = 0; 823 } 824 st_release_request(SRpnt); 825 SRpnt = NULL; 826 } 827 return result; 828 } 829 830 831 /* Flush the tape buffer. The tape will be positioned correctly unless 832 seek_next is true. */ 833 static int flush_buffer(struct scsi_tape *STp, int seek_next) 834 { 835 int backspace, result; 836 struct st_partstat *STps; 837 838 if (STp->ready != ST_READY) 839 return 0; 840 841 /* 842 * If there was a bus reset, block further access 843 * to this device. 844 */ 845 if (STp->pos_unknown) 846 return (-EIO); 847 848 STps = &(STp->ps[STp->partition]); 849 if (STps->rw == ST_WRITING) /* Writing */ 850 return st_flush_write_buffer(STp); 851 852 if (STp->block_size == 0) 853 return 0; 854 855 backspace = ((STp->buffer)->buffer_bytes + 856 (STp->buffer)->read_pointer) / STp->block_size - 857 ((STp->buffer)->read_pointer + STp->block_size - 1) / 858 STp->block_size; 859 (STp->buffer)->buffer_bytes = 0; 860 (STp->buffer)->read_pointer = 0; 861 result = 0; 862 if (!seek_next) { 863 if (STps->eof == ST_FM_HIT) { 864 result = cross_eof(STp, 0); /* Back over the EOF hit */ 865 if (!result) 866 STps->eof = ST_NOEOF; 867 else { 868 if (STps->drv_file >= 0) 869 STps->drv_file++; 870 STps->drv_block = 0; 871 } 872 } 873 if (!result && backspace > 0) 874 result = st_int_ioctl(STp, MTBSR, backspace); 875 } else if (STps->eof == ST_FM_HIT) { 876 if (STps->drv_file >= 0) 877 STps->drv_file++; 878 STps->drv_block = 0; 879 STps->eof = ST_NOEOF; 880 } 881 return result; 882 883 } 884 885 /* Set the mode parameters */ 886 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm) 887 { 888 int set_it = 0; 889 unsigned long arg; 890 891 if (!STp->density_changed && 892 STm->default_density >= 0 && 893 STm->default_density != STp->density) { 894 arg = STm->default_density; 895 set_it = 1; 896 } else 897 arg = STp->density; 898 arg <<= MT_ST_DENSITY_SHIFT; 899 if (!STp->blksize_changed && 900 STm->default_blksize >= 0 && 901 STm->default_blksize != STp->block_size) { 902 arg |= STm->default_blksize; 903 set_it = 1; 904 } else 905 arg |= STp->block_size; 906 if (set_it && 907 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) { 908 st_printk(KERN_WARNING, STp, 909 "Can't set default block size to %d bytes " 910 "and density %x.\n", 911 STm->default_blksize, STm->default_density); 912 if (modes_defined) 913 return (-EINVAL); 914 } 915 return 0; 916 } 917 918 919 /* Lock or unlock the drive door. Don't use when st_request allocated. */ 920 static int do_door_lock(struct scsi_tape * STp, int do_lock) 921 { 922 int retval; 923 924 DEBC_printk(STp, "%socking drive door.\n", do_lock ? "L" : "Unl"); 925 926 retval = scsi_set_medium_removal(STp->device, 927 do_lock ? SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW); 928 if (!retval) 929 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED; 930 else 931 STp->door_locked = ST_LOCK_FAILS; 932 return retval; 933 } 934 935 936 /* Set the internal state after reset */ 937 static void reset_state(struct scsi_tape *STp) 938 { 939 int i; 940 struct st_partstat *STps; 941 942 STp->pos_unknown = 0; 943 for (i = 0; i < ST_NBR_PARTITIONS; i++) { 944 STps = &(STp->ps[i]); 945 STps->rw = ST_IDLE; 946 STps->eof = ST_NOEOF; 947 STps->at_sm = 0; 948 STps->last_block_valid = 0; 949 STps->drv_block = -1; 950 STps->drv_file = -1; 951 } 952 if (STp->can_partitions) { 953 STp->partition = find_partition(STp); 954 if (STp->partition < 0) 955 STp->partition = 0; 956 STp->new_partition = STp->partition; 957 } 958 } 959 960 /* Test if the drive is ready. Returns either one of the codes below or a negative system 961 error code. */ 962 #define CHKRES_READY 0 963 #define CHKRES_NEW_SESSION 1 964 #define CHKRES_NOT_READY 2 965 #define CHKRES_NO_TAPE 3 966 967 #define MAX_ATTENTIONS 10 968 969 static int test_ready(struct scsi_tape *STp, int do_wait) 970 { 971 int attentions, waits, max_wait, scode; 972 int retval = CHKRES_READY, new_session = 0; 973 unsigned char cmd[MAX_COMMAND_SIZE]; 974 struct st_request *SRpnt = NULL; 975 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 976 977 max_wait = do_wait ? ST_BLOCK_SECONDS : 0; 978 979 for (attentions=waits=0; ; ) { 980 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 981 cmd[0] = TEST_UNIT_READY; 982 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, 983 STp->long_timeout, MAX_READY_RETRIES, 1); 984 985 if (!SRpnt) { 986 retval = (STp->buffer)->syscall_result; 987 break; 988 } 989 990 if (cmdstatp->have_sense) { 991 992 scode = cmdstatp->sense_hdr.sense_key; 993 994 if (scode == UNIT_ATTENTION) { /* New media? */ 995 new_session = 1; 996 if (attentions < MAX_ATTENTIONS) { 997 attentions++; 998 continue; 999 } 1000 else { 1001 retval = (-EIO); 1002 break; 1003 } 1004 } 1005 1006 if (scode == NOT_READY) { 1007 if (waits < max_wait) { 1008 if (msleep_interruptible(1000)) { 1009 retval = (-EINTR); 1010 break; 1011 } 1012 waits++; 1013 continue; 1014 } 1015 else { 1016 if ((STp->device)->scsi_level >= SCSI_2 && 1017 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */ 1018 retval = CHKRES_NO_TAPE; 1019 else 1020 retval = CHKRES_NOT_READY; 1021 break; 1022 } 1023 } 1024 } 1025 1026 retval = (STp->buffer)->syscall_result; 1027 if (!retval) 1028 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY; 1029 break; 1030 } 1031 1032 if (SRpnt != NULL) 1033 st_release_request(SRpnt); 1034 return retval; 1035 } 1036 1037 1038 /* See if the drive is ready and gather information about the tape. Return values: 1039 < 0 negative error code from errno.h 1040 0 drive ready 1041 1 drive not ready (possibly no tape) 1042 */ 1043 static int check_tape(struct scsi_tape *STp, struct file *filp) 1044 { 1045 int i, retval, new_session = 0, do_wait; 1046 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning; 1047 unsigned short st_flags = filp->f_flags; 1048 struct st_request *SRpnt = NULL; 1049 struct st_modedef *STm; 1050 struct st_partstat *STps; 1051 struct inode *inode = file_inode(filp); 1052 int mode = TAPE_MODE(inode); 1053 1054 STp->ready = ST_READY; 1055 1056 if (mode != STp->current_mode) { 1057 DEBC_printk(STp, "Mode change from %d to %d.\n", 1058 STp->current_mode, mode); 1059 new_session = 1; 1060 STp->current_mode = mode; 1061 } 1062 STm = &(STp->modes[STp->current_mode]); 1063 1064 saved_cleaning = STp->cleaning_req; 1065 STp->cleaning_req = 0; 1066 1067 do_wait = ((filp->f_flags & O_NONBLOCK) == 0); 1068 retval = test_ready(STp, do_wait); 1069 1070 if (retval < 0) 1071 goto err_out; 1072 1073 if (retval == CHKRES_NEW_SESSION) { 1074 STp->pos_unknown = 0; 1075 STp->partition = STp->new_partition = 0; 1076 if (STp->can_partitions) 1077 STp->nbr_partitions = 1; /* This guess will be updated later 1078 if necessary */ 1079 for (i = 0; i < ST_NBR_PARTITIONS; i++) { 1080 STps = &(STp->ps[i]); 1081 STps->rw = ST_IDLE; 1082 STps->eof = ST_NOEOF; 1083 STps->at_sm = 0; 1084 STps->last_block_valid = 0; 1085 STps->drv_block = 0; 1086 STps->drv_file = 0; 1087 } 1088 new_session = 1; 1089 } 1090 else { 1091 STp->cleaning_req |= saved_cleaning; 1092 1093 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) { 1094 if (retval == CHKRES_NO_TAPE) 1095 STp->ready = ST_NO_TAPE; 1096 else 1097 STp->ready = ST_NOT_READY; 1098 1099 STp->density = 0; /* Clear the erroneous "residue" */ 1100 STp->write_prot = 0; 1101 STp->block_size = 0; 1102 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1); 1103 STp->partition = STp->new_partition = 0; 1104 STp->door_locked = ST_UNLOCKED; 1105 return CHKRES_NOT_READY; 1106 } 1107 } 1108 1109 if (STp->omit_blklims) 1110 STp->min_block = STp->max_block = (-1); 1111 else { 1112 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 1113 cmd[0] = READ_BLOCK_LIMITS; 1114 1115 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE, 1116 STp->device->request_queue->rq_timeout, 1117 MAX_READY_RETRIES, 1); 1118 if (!SRpnt) { 1119 retval = (STp->buffer)->syscall_result; 1120 goto err_out; 1121 } 1122 1123 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) { 1124 STp->max_block = ((STp->buffer)->b_data[1] << 16) | 1125 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3]; 1126 STp->min_block = ((STp->buffer)->b_data[4] << 8) | 1127 (STp->buffer)->b_data[5]; 1128 if ( DEB( debugging || ) !STp->inited) 1129 st_printk(KERN_INFO, STp, 1130 "Block limits %d - %d bytes.\n", 1131 STp->min_block, STp->max_block); 1132 } else { 1133 STp->min_block = STp->max_block = (-1); 1134 DEBC_printk(STp, "Can't read block limits.\n"); 1135 } 1136 } 1137 1138 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE); 1139 cmd[0] = MODE_SENSE; 1140 cmd[4] = 12; 1141 1142 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE, 1143 STp->device->request_queue->rq_timeout, 1144 MAX_READY_RETRIES, 1); 1145 if (!SRpnt) { 1146 retval = (STp->buffer)->syscall_result; 1147 goto err_out; 1148 } 1149 1150 if ((STp->buffer)->syscall_result != 0) { 1151 DEBC_printk(STp, "No Mode Sense.\n"); 1152 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */ 1153 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */ 1154 STp->drv_write_prot = 0; 1155 } else { 1156 DEBC_printk(STp,"Mode sense. Length %d, " 1157 "medium %x, WBS %x, BLL %d\n", 1158 (STp->buffer)->b_data[0], 1159 (STp->buffer)->b_data[1], 1160 (STp->buffer)->b_data[2], 1161 (STp->buffer)->b_data[3]); 1162 1163 if ((STp->buffer)->b_data[3] >= 8) { 1164 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7; 1165 STp->density = (STp->buffer)->b_data[4]; 1166 STp->block_size = (STp->buffer)->b_data[9] * 65536 + 1167 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11]; 1168 DEBC_printk(STp, "Density %x, tape length: %x, " 1169 "drv buffer: %d\n", 1170 STp->density, 1171 (STp->buffer)->b_data[5] * 65536 + 1172 (STp->buffer)->b_data[6] * 256 + 1173 (STp->buffer)->b_data[7], 1174 STp->drv_buffer); 1175 } 1176 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0; 1177 if (!STp->drv_buffer && STp->immediate_filemark) { 1178 st_printk(KERN_WARNING, STp, 1179 "non-buffered tape: disabling " 1180 "writing immediate filemarks\n"); 1181 STp->immediate_filemark = 0; 1182 } 1183 } 1184 st_release_request(SRpnt); 1185 SRpnt = NULL; 1186 STp->inited = 1; 1187 1188 if (STp->block_size > 0) 1189 (STp->buffer)->buffer_blocks = 1190 (STp->buffer)->buffer_size / STp->block_size; 1191 else 1192 (STp->buffer)->buffer_blocks = 1; 1193 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 1194 1195 DEBC_printk(STp, "Block size: %d, buffer size: %d (%d blocks).\n", 1196 STp->block_size, (STp->buffer)->buffer_size, 1197 (STp->buffer)->buffer_blocks); 1198 1199 if (STp->drv_write_prot) { 1200 STp->write_prot = 1; 1201 1202 DEBC_printk(STp, "Write protected\n"); 1203 1204 if (do_wait && 1205 ((st_flags & O_ACCMODE) == O_WRONLY || 1206 (st_flags & O_ACCMODE) == O_RDWR)) { 1207 retval = (-EROFS); 1208 goto err_out; 1209 } 1210 } 1211 1212 if (STp->can_partitions && STp->nbr_partitions < 1) { 1213 /* This code is reached when the device is opened for the first time 1214 after the driver has been initialized with tape in the drive and the 1215 partition support has been enabled. */ 1216 DEBC_printk(STp, "Updating partition number in status.\n"); 1217 if ((STp->partition = find_partition(STp)) < 0) { 1218 retval = STp->partition; 1219 goto err_out; 1220 } 1221 STp->new_partition = STp->partition; 1222 STp->nbr_partitions = 1; /* This guess will be updated when necessary */ 1223 } 1224 1225 if (new_session) { /* Change the drive parameters for the new mode */ 1226 STp->density_changed = STp->blksize_changed = 0; 1227 STp->compression_changed = 0; 1228 if (!(STm->defaults_for_writes) && 1229 (retval = set_mode_densblk(STp, STm)) < 0) 1230 goto err_out; 1231 1232 if (STp->default_drvbuffer != 0xff) { 1233 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer)) 1234 st_printk(KERN_WARNING, STp, 1235 "Can't set default drive " 1236 "buffering to %d.\n", 1237 STp->default_drvbuffer); 1238 } 1239 } 1240 1241 return CHKRES_READY; 1242 1243 err_out: 1244 return retval; 1245 } 1246 1247 1248 /* Open the device. Needs to take the BKL only because of incrementing the SCSI host 1249 module count. */ 1250 static int st_open(struct inode *inode, struct file *filp) 1251 { 1252 int i, retval = (-EIO); 1253 int resumed = 0; 1254 struct scsi_tape *STp; 1255 struct st_partstat *STps; 1256 int dev = TAPE_NR(inode); 1257 1258 /* 1259 * We really want to do nonseekable_open(inode, filp); here, but some 1260 * versions of tar incorrectly call lseek on tapes and bail out if that 1261 * fails. So we disallow pread() and pwrite(), but permit lseeks. 1262 */ 1263 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 1264 1265 if (!(STp = scsi_tape_get(dev))) { 1266 return -ENXIO; 1267 } 1268 1269 filp->private_data = STp; 1270 1271 spin_lock(&st_use_lock); 1272 if (STp->in_use) { 1273 spin_unlock(&st_use_lock); 1274 DEBC_printk(STp, "Device already in use.\n"); 1275 scsi_tape_put(STp); 1276 return (-EBUSY); 1277 } 1278 1279 STp->in_use = 1; 1280 spin_unlock(&st_use_lock); 1281 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0; 1282 1283 if (scsi_autopm_get_device(STp->device) < 0) { 1284 retval = -EIO; 1285 goto err_out; 1286 } 1287 resumed = 1; 1288 if (!scsi_block_when_processing_errors(STp->device)) { 1289 retval = (-ENXIO); 1290 goto err_out; 1291 } 1292 1293 /* See that we have at least a one page buffer available */ 1294 if (!enlarge_buffer(STp->buffer, PAGE_SIZE)) { 1295 st_printk(KERN_WARNING, STp, 1296 "Can't allocate one page tape buffer.\n"); 1297 retval = (-EOVERFLOW); 1298 goto err_out; 1299 } 1300 1301 (STp->buffer)->cleared = 0; 1302 (STp->buffer)->writing = 0; 1303 (STp->buffer)->syscall_result = 0; 1304 1305 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY); 1306 1307 STp->dirty = 0; 1308 for (i = 0; i < ST_NBR_PARTITIONS; i++) { 1309 STps = &(STp->ps[i]); 1310 STps->rw = ST_IDLE; 1311 } 1312 STp->try_dio_now = STp->try_dio; 1313 STp->recover_count = 0; 1314 DEB( STp->nbr_waits = STp->nbr_finished = 0; 1315 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; ) 1316 1317 retval = check_tape(STp, filp); 1318 if (retval < 0) 1319 goto err_out; 1320 if ((filp->f_flags & O_NONBLOCK) == 0 && 1321 retval != CHKRES_READY) { 1322 if (STp->ready == NO_TAPE) 1323 retval = (-ENOMEDIUM); 1324 else 1325 retval = (-EIO); 1326 goto err_out; 1327 } 1328 return 0; 1329 1330 err_out: 1331 normalize_buffer(STp->buffer); 1332 spin_lock(&st_use_lock); 1333 STp->in_use = 0; 1334 spin_unlock(&st_use_lock); 1335 if (resumed) 1336 scsi_autopm_put_device(STp->device); 1337 scsi_tape_put(STp); 1338 return retval; 1339 1340 } 1341 1342 1343 /* Flush the tape buffer before close */ 1344 static int st_flush(struct file *filp, fl_owner_t id) 1345 { 1346 int result = 0, result2; 1347 unsigned char cmd[MAX_COMMAND_SIZE]; 1348 struct st_request *SRpnt; 1349 struct scsi_tape *STp = filp->private_data; 1350 struct st_modedef *STm = &(STp->modes[STp->current_mode]); 1351 struct st_partstat *STps = &(STp->ps[STp->partition]); 1352 1353 if (file_count(filp) > 1) 1354 return 0; 1355 1356 if (STps->rw == ST_WRITING && !STp->pos_unknown) { 1357 result = st_flush_write_buffer(STp); 1358 if (result != 0 && result != (-ENOSPC)) 1359 goto out; 1360 } 1361 1362 if (STp->can_partitions && 1363 (result2 = switch_partition(STp)) < 0) { 1364 DEBC_printk(STp, "switch_partition at close failed.\n"); 1365 if (result == 0) 1366 result = result2; 1367 goto out; 1368 } 1369 1370 DEBC( if (STp->nbr_requests) 1371 st_printk(KERN_DEBUG, STp, 1372 "Number of r/w requests %d, dio used in %d, " 1373 "pages %d.\n", STp->nbr_requests, STp->nbr_dio, 1374 STp->nbr_pages)); 1375 1376 if (STps->rw == ST_WRITING && !STp->pos_unknown) { 1377 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 1378 1379 #if DEBUG 1380 DEBC_printk(STp, "Async write waits %d, finished %d.\n", 1381 STp->nbr_waits, STp->nbr_finished); 1382 #endif 1383 memset(cmd, 0, MAX_COMMAND_SIZE); 1384 cmd[0] = WRITE_FILEMARKS; 1385 if (STp->immediate_filemark) 1386 cmd[1] = 1; 1387 cmd[4] = 1 + STp->two_fm; 1388 1389 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 1390 STp->device->request_queue->rq_timeout, 1391 MAX_WRITE_RETRIES, 1); 1392 if (!SRpnt) { 1393 result = (STp->buffer)->syscall_result; 1394 goto out; 1395 } 1396 1397 if (STp->buffer->syscall_result == 0 || 1398 (cmdstatp->have_sense && !cmdstatp->deferred && 1399 (cmdstatp->flags & SENSE_EOM) && 1400 (cmdstatp->sense_hdr.sense_key == NO_SENSE || 1401 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && 1402 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) { 1403 /* Write successful at EOM */ 1404 st_release_request(SRpnt); 1405 SRpnt = NULL; 1406 if (STps->drv_file >= 0) 1407 STps->drv_file++; 1408 STps->drv_block = 0; 1409 if (STp->two_fm) 1410 cross_eof(STp, 0); 1411 STps->eof = ST_FM; 1412 } 1413 else { /* Write error */ 1414 st_release_request(SRpnt); 1415 SRpnt = NULL; 1416 st_printk(KERN_ERR, STp, 1417 "Error on write filemark.\n"); 1418 if (result == 0) 1419 result = (-EIO); 1420 } 1421 1422 DEBC_printk(STp, "Buffer flushed, %d EOF(s) written\n", cmd[4]); 1423 } else if (!STp->rew_at_close) { 1424 STps = &(STp->ps[STp->partition]); 1425 if (!STm->sysv || STps->rw != ST_READING) { 1426 if (STp->can_bsr) 1427 result = flush_buffer(STp, 0); 1428 else if (STps->eof == ST_FM_HIT) { 1429 result = cross_eof(STp, 0); 1430 if (result) { 1431 if (STps->drv_file >= 0) 1432 STps->drv_file++; 1433 STps->drv_block = 0; 1434 STps->eof = ST_FM; 1435 } else 1436 STps->eof = ST_NOEOF; 1437 } 1438 } else if ((STps->eof == ST_NOEOF && 1439 !(result = cross_eof(STp, 1))) || 1440 STps->eof == ST_FM_HIT) { 1441 if (STps->drv_file >= 0) 1442 STps->drv_file++; 1443 STps->drv_block = 0; 1444 STps->eof = ST_FM; 1445 } 1446 } 1447 1448 out: 1449 if (STp->rew_at_close) { 1450 result2 = st_int_ioctl(STp, MTREW, 1); 1451 if (result == 0) 1452 result = result2; 1453 } 1454 return result; 1455 } 1456 1457 1458 /* Close the device and release it. BKL is not needed: this is the only thread 1459 accessing this tape. */ 1460 static int st_release(struct inode *inode, struct file *filp) 1461 { 1462 struct scsi_tape *STp = filp->private_data; 1463 1464 if (STp->door_locked == ST_LOCKED_AUTO) 1465 do_door_lock(STp, 0); 1466 1467 normalize_buffer(STp->buffer); 1468 spin_lock(&st_use_lock); 1469 STp->in_use = 0; 1470 spin_unlock(&st_use_lock); 1471 scsi_autopm_put_device(STp->device); 1472 scsi_tape_put(STp); 1473 1474 return 0; 1475 } 1476 1477 /* The checks common to both reading and writing */ 1478 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count) 1479 { 1480 ssize_t retval = 0; 1481 1482 /* 1483 * If we are in the middle of error recovery, don't let anyone 1484 * else try and use this device. Also, if error recovery fails, it 1485 * may try and take the device offline, in which case all further 1486 * access to the device is prohibited. 1487 */ 1488 if (!scsi_block_when_processing_errors(STp->device)) { 1489 retval = (-ENXIO); 1490 goto out; 1491 } 1492 1493 if (STp->ready != ST_READY) { 1494 if (STp->ready == ST_NO_TAPE) 1495 retval = (-ENOMEDIUM); 1496 else 1497 retval = (-EIO); 1498 goto out; 1499 } 1500 1501 if (! STp->modes[STp->current_mode].defined) { 1502 retval = (-ENXIO); 1503 goto out; 1504 } 1505 1506 1507 /* 1508 * If there was a bus reset, block further access 1509 * to this device. 1510 */ 1511 if (STp->pos_unknown) { 1512 retval = (-EIO); 1513 goto out; 1514 } 1515 1516 if (count == 0) 1517 goto out; 1518 1519 DEB( 1520 if (!STp->in_use) { 1521 st_printk(ST_DEB_MSG, STp, 1522 "Incorrect device.\n"); 1523 retval = (-EIO); 1524 goto out; 1525 } ) /* end DEB */ 1526 1527 if (STp->can_partitions && 1528 (retval = switch_partition(STp)) < 0) 1529 goto out; 1530 1531 if (STp->block_size == 0 && STp->max_block > 0 && 1532 (count < STp->min_block || count > STp->max_block)) { 1533 retval = (-EINVAL); 1534 goto out; 1535 } 1536 1537 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && 1538 !do_door_lock(STp, 1)) 1539 STp->door_locked = ST_LOCKED_AUTO; 1540 1541 out: 1542 return retval; 1543 } 1544 1545 1546 static int setup_buffering(struct scsi_tape *STp, const char __user *buf, 1547 size_t count, int is_read) 1548 { 1549 int i, bufsize, retval = 0; 1550 struct st_buffer *STbp = STp->buffer; 1551 1552 if (is_read) 1553 i = STp->try_dio_now && try_rdio; 1554 else 1555 i = STp->try_dio_now && try_wdio; 1556 1557 if (i && ((unsigned long)buf & queue_dma_alignment( 1558 STp->device->request_queue)) == 0) { 1559 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf, 1560 count, (is_read ? READ : WRITE)); 1561 if (i > 0) { 1562 STbp->do_dio = i; 1563 STbp->buffer_bytes = 0; /* can be used as transfer counter */ 1564 } 1565 else 1566 STbp->do_dio = 0; /* fall back to buffering with any error */ 1567 STbp->sg_segs = STbp->do_dio; 1568 DEB( 1569 if (STbp->do_dio) { 1570 STp->nbr_dio++; 1571 STp->nbr_pages += STbp->do_dio; 1572 } 1573 ) 1574 } else 1575 STbp->do_dio = 0; 1576 DEB( STp->nbr_requests++; ) 1577 1578 if (!STbp->do_dio) { 1579 if (STp->block_size) 1580 bufsize = STp->block_size > st_fixed_buffer_size ? 1581 STp->block_size : st_fixed_buffer_size; 1582 else { 1583 bufsize = count; 1584 /* Make sure that data from previous user is not leaked even if 1585 HBA does not return correct residual */ 1586 if (is_read && STp->sili && !STbp->cleared) 1587 clear_buffer(STbp); 1588 } 1589 1590 if (bufsize > STbp->buffer_size && 1591 !enlarge_buffer(STbp, bufsize)) { 1592 st_printk(KERN_WARNING, STp, 1593 "Can't allocate %d byte tape buffer.\n", 1594 bufsize); 1595 retval = (-EOVERFLOW); 1596 goto out; 1597 } 1598 if (STp->block_size) 1599 STbp->buffer_blocks = bufsize / STp->block_size; 1600 } 1601 1602 out: 1603 return retval; 1604 } 1605 1606 1607 /* Can be called more than once after each setup_buffer() */ 1608 static void release_buffering(struct scsi_tape *STp, int is_read) 1609 { 1610 struct st_buffer *STbp; 1611 1612 STbp = STp->buffer; 1613 if (STbp->do_dio) { 1614 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read); 1615 STbp->do_dio = 0; 1616 STbp->sg_segs = 0; 1617 } 1618 } 1619 1620 1621 /* Write command */ 1622 static ssize_t 1623 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) 1624 { 1625 ssize_t total; 1626 ssize_t i, do_count, blks, transfer; 1627 ssize_t retval; 1628 int undone, retry_eot = 0, scode; 1629 int async_write; 1630 unsigned char cmd[MAX_COMMAND_SIZE]; 1631 const char __user *b_point; 1632 struct st_request *SRpnt = NULL; 1633 struct scsi_tape *STp = filp->private_data; 1634 struct st_modedef *STm; 1635 struct st_partstat *STps; 1636 struct st_buffer *STbp; 1637 1638 if (mutex_lock_interruptible(&STp->lock)) 1639 return -ERESTARTSYS; 1640 1641 retval = rw_checks(STp, filp, count); 1642 if (retval || count == 0) 1643 goto out; 1644 1645 /* Write must be integral number of blocks */ 1646 if (STp->block_size != 0 && (count % STp->block_size) != 0) { 1647 st_printk(KERN_WARNING, STp, 1648 "Write not multiple of tape block size.\n"); 1649 retval = (-EINVAL); 1650 goto out; 1651 } 1652 1653 STm = &(STp->modes[STp->current_mode]); 1654 STps = &(STp->ps[STp->partition]); 1655 1656 if (STp->write_prot) { 1657 retval = (-EACCES); 1658 goto out; 1659 } 1660 1661 1662 if (STps->rw == ST_READING) { 1663 retval = flush_buffer(STp, 0); 1664 if (retval) 1665 goto out; 1666 STps->rw = ST_WRITING; 1667 } else if (STps->rw != ST_WRITING && 1668 STps->drv_file == 0 && STps->drv_block == 0) { 1669 if ((retval = set_mode_densblk(STp, STm)) < 0) 1670 goto out; 1671 if (STm->default_compression != ST_DONT_TOUCH && 1672 !(STp->compression_changed)) { 1673 if (st_compression(STp, (STm->default_compression == ST_YES))) { 1674 st_printk(KERN_WARNING, STp, 1675 "Can't set default compression.\n"); 1676 if (modes_defined) { 1677 retval = (-EINVAL); 1678 goto out; 1679 } 1680 } 1681 } 1682 } 1683 1684 STbp = STp->buffer; 1685 i = write_behind_check(STp); 1686 if (i) { 1687 if (i == -ENOSPC) 1688 STps->eof = ST_EOM_OK; 1689 else 1690 STps->eof = ST_EOM_ERROR; 1691 } 1692 1693 if (STps->eof == ST_EOM_OK) { 1694 STps->eof = ST_EOD_1; /* allow next write */ 1695 retval = (-ENOSPC); 1696 goto out; 1697 } 1698 else if (STps->eof == ST_EOM_ERROR) { 1699 retval = (-EIO); 1700 goto out; 1701 } 1702 1703 /* Check the buffer readability in cases where copy_user might catch 1704 the problems after some tape movement. */ 1705 if (STp->block_size != 0 && 1706 !STbp->do_dio && 1707 (copy_from_user(&i, buf, 1) != 0 || 1708 copy_from_user(&i, buf + count - 1, 1) != 0)) { 1709 retval = (-EFAULT); 1710 goto out; 1711 } 1712 1713 retval = setup_buffering(STp, buf, count, 0); 1714 if (retval) 1715 goto out; 1716 1717 total = count; 1718 1719 memset(cmd, 0, MAX_COMMAND_SIZE); 1720 cmd[0] = WRITE_6; 1721 cmd[1] = (STp->block_size != 0); 1722 1723 STps->rw = ST_WRITING; 1724 1725 b_point = buf; 1726 while (count > 0 && !retry_eot) { 1727 1728 if (STbp->do_dio) { 1729 do_count = count; 1730 } 1731 else { 1732 if (STp->block_size == 0) 1733 do_count = count; 1734 else { 1735 do_count = STbp->buffer_blocks * STp->block_size - 1736 STbp->buffer_bytes; 1737 if (do_count > count) 1738 do_count = count; 1739 } 1740 1741 i = append_to_buffer(b_point, STbp, do_count); 1742 if (i) { 1743 retval = i; 1744 goto out; 1745 } 1746 } 1747 count -= do_count; 1748 b_point += do_count; 1749 1750 async_write = STp->block_size == 0 && !STbp->do_dio && 1751 STm->do_async_writes && STps->eof < ST_EOM_OK; 1752 1753 if (STp->block_size != 0 && STm->do_buffer_writes && 1754 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK && 1755 STbp->buffer_bytes < STbp->buffer_size) { 1756 STp->dirty = 1; 1757 /* Don't write a buffer that is not full enough. */ 1758 if (!async_write && count == 0) 1759 break; 1760 } 1761 1762 retry_write: 1763 if (STp->block_size == 0) 1764 blks = transfer = do_count; 1765 else { 1766 if (!STbp->do_dio) 1767 blks = STbp->buffer_bytes; 1768 else 1769 blks = do_count; 1770 blks /= STp->block_size; 1771 transfer = blks * STp->block_size; 1772 } 1773 cmd[2] = blks >> 16; 1774 cmd[3] = blks >> 8; 1775 cmd[4] = blks; 1776 1777 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE, 1778 STp->device->request_queue->rq_timeout, 1779 MAX_WRITE_RETRIES, !async_write); 1780 if (!SRpnt) { 1781 retval = STbp->syscall_result; 1782 goto out; 1783 } 1784 if (async_write && !STbp->syscall_result) { 1785 STbp->writing = transfer; 1786 STp->dirty = !(STbp->writing == 1787 STbp->buffer_bytes); 1788 SRpnt = NULL; /* Prevent releasing this request! */ 1789 DEB( STp->write_pending = 1; ) 1790 break; 1791 } 1792 1793 if (STbp->syscall_result != 0) { 1794 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 1795 1796 DEBC_printk(STp, "Error on write:\n"); 1797 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) { 1798 scode = cmdstatp->sense_hdr.sense_key; 1799 if (cmdstatp->remainder_valid) 1800 undone = (int)cmdstatp->uremainder64; 1801 else if (STp->block_size == 0 && 1802 scode == VOLUME_OVERFLOW) 1803 undone = transfer; 1804 else 1805 undone = 0; 1806 if (STp->block_size != 0) 1807 undone *= STp->block_size; 1808 if (undone <= do_count) { 1809 /* Only data from this write is not written */ 1810 count += undone; 1811 b_point -= undone; 1812 do_count -= undone; 1813 if (STp->block_size) 1814 blks = (transfer - undone) / STp->block_size; 1815 STps->eof = ST_EOM_OK; 1816 /* Continue in fixed block mode if all written 1817 in this request but still something left to write 1818 (retval left to zero) 1819 */ 1820 if (STp->block_size == 0 || 1821 undone > 0 || count == 0) 1822 retval = (-ENOSPC); /* EOM within current request */ 1823 DEBC_printk(STp, "EOM with %d " 1824 "bytes unwritten.\n", 1825 (int)count); 1826 } else { 1827 /* EOT within data buffered earlier (possible only 1828 in fixed block mode without direct i/o) */ 1829 if (!retry_eot && !cmdstatp->deferred && 1830 (scode == NO_SENSE || scode == RECOVERED_ERROR)) { 1831 move_buffer_data(STp->buffer, transfer - undone); 1832 retry_eot = 1; 1833 if (STps->drv_block >= 0) { 1834 STps->drv_block += (transfer - undone) / 1835 STp->block_size; 1836 } 1837 STps->eof = ST_EOM_OK; 1838 DEBC_printk(STp, "Retry " 1839 "write of %d " 1840 "bytes at EOM.\n", 1841 STp->buffer->buffer_bytes); 1842 goto retry_write; 1843 } 1844 else { 1845 /* Either error within data buffered by driver or 1846 failed retry */ 1847 count -= do_count; 1848 blks = do_count = 0; 1849 STps->eof = ST_EOM_ERROR; 1850 STps->drv_block = (-1); /* Too cautious? */ 1851 retval = (-EIO); /* EOM for old data */ 1852 DEBC_printk(STp, "EOM with " 1853 "lost data.\n"); 1854 } 1855 } 1856 } else { 1857 count += do_count; 1858 STps->drv_block = (-1); /* Too cautious? */ 1859 retval = STbp->syscall_result; 1860 } 1861 1862 } 1863 1864 if (STps->drv_block >= 0) { 1865 if (STp->block_size == 0) 1866 STps->drv_block += (do_count > 0); 1867 else 1868 STps->drv_block += blks; 1869 } 1870 1871 STbp->buffer_bytes = 0; 1872 STp->dirty = 0; 1873 1874 if (retval || retry_eot) { 1875 if (count < total) 1876 retval = total - count; 1877 goto out; 1878 } 1879 } 1880 1881 if (STps->eof == ST_EOD_1) 1882 STps->eof = ST_EOM_OK; 1883 else if (STps->eof != ST_EOM_OK) 1884 STps->eof = ST_NOEOF; 1885 retval = total - count; 1886 1887 out: 1888 if (SRpnt != NULL) 1889 st_release_request(SRpnt); 1890 release_buffering(STp, 0); 1891 mutex_unlock(&STp->lock); 1892 1893 return retval; 1894 } 1895 1896 /* Read data from the tape. Returns zero in the normal case, one if the 1897 eof status has changed, and the negative error code in case of a 1898 fatal error. Otherwise updates the buffer and the eof state. 1899 1900 Does release user buffer mapping if it is set. 1901 */ 1902 static long read_tape(struct scsi_tape *STp, long count, 1903 struct st_request ** aSRpnt) 1904 { 1905 int transfer, blks, bytes; 1906 unsigned char cmd[MAX_COMMAND_SIZE]; 1907 struct st_request *SRpnt; 1908 struct st_modedef *STm; 1909 struct st_partstat *STps; 1910 struct st_buffer *STbp; 1911 int retval = 0; 1912 1913 if (count == 0) 1914 return 0; 1915 1916 STm = &(STp->modes[STp->current_mode]); 1917 STps = &(STp->ps[STp->partition]); 1918 if (STps->eof == ST_FM_HIT) 1919 return 1; 1920 STbp = STp->buffer; 1921 1922 if (STp->block_size == 0) 1923 blks = bytes = count; 1924 else { 1925 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) { 1926 blks = (STp->buffer)->buffer_blocks; 1927 bytes = blks * STp->block_size; 1928 } else { 1929 bytes = count; 1930 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size) 1931 bytes = (STp->buffer)->buffer_size; 1932 blks = bytes / STp->block_size; 1933 bytes = blks * STp->block_size; 1934 } 1935 } 1936 1937 memset(cmd, 0, MAX_COMMAND_SIZE); 1938 cmd[0] = READ_6; 1939 cmd[1] = (STp->block_size != 0); 1940 if (!cmd[1] && STp->sili) 1941 cmd[1] |= 2; 1942 cmd[2] = blks >> 16; 1943 cmd[3] = blks >> 8; 1944 cmd[4] = blks; 1945 1946 SRpnt = *aSRpnt; 1947 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE, 1948 STp->device->request_queue->rq_timeout, 1949 MAX_RETRIES, 1); 1950 release_buffering(STp, 1); 1951 *aSRpnt = SRpnt; 1952 if (!SRpnt) 1953 return STbp->syscall_result; 1954 1955 STbp->read_pointer = 0; 1956 STps->at_sm = 0; 1957 1958 /* Something to check */ 1959 if (STbp->syscall_result) { 1960 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 1961 1962 retval = 1; 1963 DEBC_printk(STp, 1964 "Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", 1965 SRpnt->sense[0], SRpnt->sense[1], 1966 SRpnt->sense[2], SRpnt->sense[3], 1967 SRpnt->sense[4], SRpnt->sense[5], 1968 SRpnt->sense[6], SRpnt->sense[7]); 1969 if (cmdstatp->have_sense) { 1970 1971 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 1972 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */ 1973 1974 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */ 1975 /* Compute the residual count */ 1976 if (cmdstatp->remainder_valid) 1977 transfer = (int)cmdstatp->uremainder64; 1978 else 1979 transfer = 0; 1980 if (cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR) { 1981 if (STp->block_size == 0) 1982 transfer = bytes; 1983 /* Some drives set ILI with MEDIUM ERROR */ 1984 cmdstatp->flags &= ~SENSE_ILI; 1985 } 1986 1987 if (cmdstatp->flags & SENSE_ILI) { /* ILI */ 1988 if (STp->block_size == 0 && 1989 transfer < 0) { 1990 st_printk(KERN_NOTICE, STp, 1991 "Failed to read %d " 1992 "byte block with %d " 1993 "byte transfer.\n", 1994 bytes - transfer, 1995 bytes); 1996 if (STps->drv_block >= 0) 1997 STps->drv_block += 1; 1998 STbp->buffer_bytes = 0; 1999 return (-ENOMEM); 2000 } else if (STp->block_size == 0) { 2001 STbp->buffer_bytes = bytes - transfer; 2002 } else { 2003 st_release_request(SRpnt); 2004 SRpnt = *aSRpnt = NULL; 2005 if (transfer == blks) { /* We did not get anything, error */ 2006 st_printk(KERN_NOTICE, STp, 2007 "Incorrect " 2008 "block size.\n"); 2009 if (STps->drv_block >= 0) 2010 STps->drv_block += blks - transfer + 1; 2011 st_int_ioctl(STp, MTBSR, 1); 2012 return (-EIO); 2013 } 2014 /* We have some data, deliver it */ 2015 STbp->buffer_bytes = (blks - transfer) * 2016 STp->block_size; 2017 DEBC_printk(STp, "ILI but " 2018 "enough data " 2019 "received %ld " 2020 "%d.\n", count, 2021 STbp->buffer_bytes); 2022 if (STps->drv_block >= 0) 2023 STps->drv_block += 1; 2024 if (st_int_ioctl(STp, MTBSR, 1)) 2025 return (-EIO); 2026 } 2027 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */ 2028 if (STps->eof != ST_FM_HIT) 2029 STps->eof = ST_FM_HIT; 2030 else 2031 STps->eof = ST_EOD_2; 2032 if (STp->block_size == 0) 2033 STbp->buffer_bytes = 0; 2034 else 2035 STbp->buffer_bytes = 2036 bytes - transfer * STp->block_size; 2037 DEBC_printk(STp, "EOF detected (%d " 2038 "bytes read).\n", 2039 STbp->buffer_bytes); 2040 } else if (cmdstatp->flags & SENSE_EOM) { 2041 if (STps->eof == ST_FM) 2042 STps->eof = ST_EOD_1; 2043 else 2044 STps->eof = ST_EOM_OK; 2045 if (STp->block_size == 0) 2046 STbp->buffer_bytes = bytes - transfer; 2047 else 2048 STbp->buffer_bytes = 2049 bytes - transfer * STp->block_size; 2050 2051 DEBC_printk(STp, "EOM detected (%d " 2052 "bytes read).\n", 2053 STbp->buffer_bytes); 2054 } 2055 } 2056 /* end of EOF, EOM, ILI test */ 2057 else { /* nonzero sense key */ 2058 DEBC_printk(STp, "Tape error while reading.\n"); 2059 STps->drv_block = (-1); 2060 if (STps->eof == ST_FM && 2061 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) { 2062 DEBC_printk(STp, "Zero returned for " 2063 "first BLANK CHECK " 2064 "after EOF.\n"); 2065 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */ 2066 } else /* Some other extended sense code */ 2067 retval = (-EIO); 2068 } 2069 2070 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */ 2071 STbp->buffer_bytes = 0; 2072 } 2073 /* End of extended sense test */ 2074 else { /* Non-extended sense */ 2075 retval = STbp->syscall_result; 2076 } 2077 2078 } 2079 /* End of error handling */ 2080 else { /* Read successful */ 2081 STbp->buffer_bytes = bytes; 2082 if (STp->sili) /* In fixed block mode residual is always zero here */ 2083 STbp->buffer_bytes -= STp->buffer->cmdstat.residual; 2084 } 2085 2086 if (STps->drv_block >= 0) { 2087 if (STp->block_size == 0) 2088 STps->drv_block++; 2089 else 2090 STps->drv_block += STbp->buffer_bytes / STp->block_size; 2091 } 2092 return retval; 2093 } 2094 2095 2096 /* Read command */ 2097 static ssize_t 2098 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) 2099 { 2100 ssize_t total; 2101 ssize_t retval = 0; 2102 ssize_t i, transfer; 2103 int special, do_dio = 0; 2104 struct st_request *SRpnt = NULL; 2105 struct scsi_tape *STp = filp->private_data; 2106 struct st_modedef *STm; 2107 struct st_partstat *STps; 2108 struct st_buffer *STbp = STp->buffer; 2109 2110 if (mutex_lock_interruptible(&STp->lock)) 2111 return -ERESTARTSYS; 2112 2113 retval = rw_checks(STp, filp, count); 2114 if (retval || count == 0) 2115 goto out; 2116 2117 STm = &(STp->modes[STp->current_mode]); 2118 if (STp->block_size != 0 && (count % STp->block_size) != 0) { 2119 if (!STm->do_read_ahead) { 2120 retval = (-EINVAL); /* Read must be integral number of blocks */ 2121 goto out; 2122 } 2123 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */ 2124 } 2125 2126 STps = &(STp->ps[STp->partition]); 2127 if (STps->rw == ST_WRITING) { 2128 retval = flush_buffer(STp, 0); 2129 if (retval) 2130 goto out; 2131 STps->rw = ST_READING; 2132 } 2133 DEB( 2134 if (debugging && STps->eof != ST_NOEOF) 2135 st_printk(ST_DEB_MSG, STp, 2136 "EOF/EOM flag up (%d). Bytes %d\n", 2137 STps->eof, STbp->buffer_bytes); 2138 ) /* end DEB */ 2139 2140 retval = setup_buffering(STp, buf, count, 1); 2141 if (retval) 2142 goto out; 2143 do_dio = STbp->do_dio; 2144 2145 if (STbp->buffer_bytes == 0 && 2146 STps->eof >= ST_EOD_1) { 2147 if (STps->eof < ST_EOD) { 2148 STps->eof += 1; 2149 retval = 0; 2150 goto out; 2151 } 2152 retval = (-EIO); /* EOM or Blank Check */ 2153 goto out; 2154 } 2155 2156 if (do_dio) { 2157 /* Check the buffer writability before any tape movement. Don't alter 2158 buffer data. */ 2159 if (copy_from_user(&i, buf, 1) != 0 || 2160 copy_to_user(buf, &i, 1) != 0 || 2161 copy_from_user(&i, buf + count - 1, 1) != 0 || 2162 copy_to_user(buf + count - 1, &i, 1) != 0) { 2163 retval = (-EFAULT); 2164 goto out; 2165 } 2166 } 2167 2168 STps->rw = ST_READING; 2169 2170 2171 /* Loop until enough data in buffer or a special condition found */ 2172 for (total = 0, special = 0; total < count && !special;) { 2173 2174 /* Get new data if the buffer is empty */ 2175 if (STbp->buffer_bytes == 0) { 2176 special = read_tape(STp, count - total, &SRpnt); 2177 if (special < 0) { /* No need to continue read */ 2178 retval = special; 2179 goto out; 2180 } 2181 } 2182 2183 /* Move the data from driver buffer to user buffer */ 2184 if (STbp->buffer_bytes > 0) { 2185 DEB( 2186 if (debugging && STps->eof != ST_NOEOF) 2187 st_printk(ST_DEB_MSG, STp, 2188 "EOF up (%d). Left %d, needed %d.\n", 2189 STps->eof, STbp->buffer_bytes, 2190 (int)(count - total)); 2191 ) /* end DEB */ 2192 transfer = STbp->buffer_bytes < count - total ? 2193 STbp->buffer_bytes : count - total; 2194 if (!do_dio) { 2195 i = from_buffer(STbp, buf, transfer); 2196 if (i) { 2197 retval = i; 2198 goto out; 2199 } 2200 } 2201 buf += transfer; 2202 total += transfer; 2203 } 2204 2205 if (STp->block_size == 0) 2206 break; /* Read only one variable length block */ 2207 2208 } /* for (total = 0, special = 0; 2209 total < count && !special; ) */ 2210 2211 /* Change the eof state if no data from tape or buffer */ 2212 if (total == 0) { 2213 if (STps->eof == ST_FM_HIT) { 2214 STps->eof = ST_FM; 2215 STps->drv_block = 0; 2216 if (STps->drv_file >= 0) 2217 STps->drv_file++; 2218 } else if (STps->eof == ST_EOD_1) { 2219 STps->eof = ST_EOD_2; 2220 STps->drv_block = 0; 2221 if (STps->drv_file >= 0) 2222 STps->drv_file++; 2223 } else if (STps->eof == ST_EOD_2) 2224 STps->eof = ST_EOD; 2225 } else if (STps->eof == ST_FM) 2226 STps->eof = ST_NOEOF; 2227 retval = total; 2228 2229 out: 2230 if (SRpnt != NULL) { 2231 st_release_request(SRpnt); 2232 SRpnt = NULL; 2233 } 2234 if (do_dio) { 2235 release_buffering(STp, 1); 2236 STbp->buffer_bytes = 0; 2237 } 2238 mutex_unlock(&STp->lock); 2239 2240 return retval; 2241 } 2242 2243 2244 2245 DEB( 2246 /* Set the driver options */ 2247 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm) 2248 { 2249 if (debugging) { 2250 st_printk(KERN_INFO, STp, 2251 "Mode %d options: buffer writes: %d, " 2252 "async writes: %d, read ahead: %d\n", 2253 STp->current_mode, STm->do_buffer_writes, 2254 STm->do_async_writes, STm->do_read_ahead); 2255 st_printk(KERN_INFO, STp, 2256 " can bsr: %d, two FMs: %d, " 2257 "fast mteom: %d, auto lock: %d,\n", 2258 STp->can_bsr, STp->two_fm, STp->fast_mteom, 2259 STp->do_auto_lock); 2260 st_printk(KERN_INFO, STp, 2261 " defs for wr: %d, no block limits: %d, " 2262 "partitions: %d, s2 log: %d\n", 2263 STm->defaults_for_writes, STp->omit_blklims, 2264 STp->can_partitions, STp->scsi2_logical); 2265 st_printk(KERN_INFO, STp, 2266 " sysv: %d nowait: %d sili: %d " 2267 "nowait_filemark: %d\n", 2268 STm->sysv, STp->immediate, STp->sili, 2269 STp->immediate_filemark); 2270 st_printk(KERN_INFO, STp, " debugging: %d\n", debugging); 2271 } 2272 } 2273 ) 2274 2275 2276 static int st_set_options(struct scsi_tape *STp, long options) 2277 { 2278 int value; 2279 long code; 2280 struct st_modedef *STm; 2281 struct cdev *cd0, *cd1; 2282 struct device *d0, *d1; 2283 2284 STm = &(STp->modes[STp->current_mode]); 2285 if (!STm->defined) { 2286 cd0 = STm->cdevs[0]; 2287 cd1 = STm->cdevs[1]; 2288 d0 = STm->devs[0]; 2289 d1 = STm->devs[1]; 2290 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef)); 2291 STm->cdevs[0] = cd0; 2292 STm->cdevs[1] = cd1; 2293 STm->devs[0] = d0; 2294 STm->devs[1] = d1; 2295 modes_defined = 1; 2296 DEBC_printk(STp, "Initialized mode %d definition from mode 0\n", 2297 STp->current_mode); 2298 } 2299 2300 code = options & MT_ST_OPTIONS; 2301 if (code == MT_ST_BOOLEANS) { 2302 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0; 2303 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0; 2304 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0; 2305 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0; 2306 STp->two_fm = (options & MT_ST_TWO_FM) != 0; 2307 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0; 2308 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0; 2309 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0; 2310 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0; 2311 if ((STp->device)->scsi_level >= SCSI_2) 2312 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0; 2313 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0; 2314 STp->immediate = (options & MT_ST_NOWAIT) != 0; 2315 STp->immediate_filemark = (options & MT_ST_NOWAIT_EOF) != 0; 2316 STm->sysv = (options & MT_ST_SYSV) != 0; 2317 STp->sili = (options & MT_ST_SILI) != 0; 2318 DEB( debugging = (options & MT_ST_DEBUGGING) != 0; 2319 st_log_options(STp, STm); ) 2320 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) { 2321 value = (code == MT_ST_SETBOOLEANS); 2322 if ((options & MT_ST_BUFFER_WRITES) != 0) 2323 STm->do_buffer_writes = value; 2324 if ((options & MT_ST_ASYNC_WRITES) != 0) 2325 STm->do_async_writes = value; 2326 if ((options & MT_ST_DEF_WRITES) != 0) 2327 STm->defaults_for_writes = value; 2328 if ((options & MT_ST_READ_AHEAD) != 0) 2329 STm->do_read_ahead = value; 2330 if ((options & MT_ST_TWO_FM) != 0) 2331 STp->two_fm = value; 2332 if ((options & MT_ST_FAST_MTEOM) != 0) 2333 STp->fast_mteom = value; 2334 if ((options & MT_ST_AUTO_LOCK) != 0) 2335 STp->do_auto_lock = value; 2336 if ((options & MT_ST_CAN_BSR) != 0) 2337 STp->can_bsr = value; 2338 if ((options & MT_ST_NO_BLKLIMS) != 0) 2339 STp->omit_blklims = value; 2340 if ((STp->device)->scsi_level >= SCSI_2 && 2341 (options & MT_ST_CAN_PARTITIONS) != 0) 2342 STp->can_partitions = value; 2343 if ((options & MT_ST_SCSI2LOGICAL) != 0) 2344 STp->scsi2_logical = value; 2345 if ((options & MT_ST_NOWAIT) != 0) 2346 STp->immediate = value; 2347 if ((options & MT_ST_NOWAIT_EOF) != 0) 2348 STp->immediate_filemark = value; 2349 if ((options & MT_ST_SYSV) != 0) 2350 STm->sysv = value; 2351 if ((options & MT_ST_SILI) != 0) 2352 STp->sili = value; 2353 DEB( 2354 if ((options & MT_ST_DEBUGGING) != 0) 2355 debugging = value; 2356 st_log_options(STp, STm); ) 2357 } else if (code == MT_ST_WRITE_THRESHOLD) { 2358 /* Retained for compatibility */ 2359 } else if (code == MT_ST_DEF_BLKSIZE) { 2360 value = (options & ~MT_ST_OPTIONS); 2361 if (value == ~MT_ST_OPTIONS) { 2362 STm->default_blksize = (-1); 2363 DEBC_printk(STp, "Default block size disabled.\n"); 2364 } else { 2365 STm->default_blksize = value; 2366 DEBC_printk(STp,"Default block size set to " 2367 "%d bytes.\n", STm->default_blksize); 2368 if (STp->ready == ST_READY) { 2369 STp->blksize_changed = 0; 2370 set_mode_densblk(STp, STm); 2371 } 2372 } 2373 } else if (code == MT_ST_TIMEOUTS) { 2374 value = (options & ~MT_ST_OPTIONS); 2375 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) { 2376 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ; 2377 DEBC_printk(STp, "Long timeout set to %d seconds.\n", 2378 (value & ~MT_ST_SET_LONG_TIMEOUT)); 2379 } else { 2380 blk_queue_rq_timeout(STp->device->request_queue, 2381 value * HZ); 2382 DEBC_printk(STp, "Normal timeout set to %d seconds.\n", 2383 value); 2384 } 2385 } else if (code == MT_ST_SET_CLN) { 2386 value = (options & ~MT_ST_OPTIONS) & 0xff; 2387 if (value != 0 && 2388 (value < EXTENDED_SENSE_START || 2389 value >= SCSI_SENSE_BUFFERSIZE)) 2390 return (-EINVAL); 2391 STp->cln_mode = value; 2392 STp->cln_sense_mask = (options >> 8) & 0xff; 2393 STp->cln_sense_value = (options >> 16) & 0xff; 2394 st_printk(KERN_INFO, STp, 2395 "Cleaning request mode %d, mask %02x, value %02x\n", 2396 value, STp->cln_sense_mask, STp->cln_sense_value); 2397 } else if (code == MT_ST_DEF_OPTIONS) { 2398 code = (options & ~MT_ST_CLEAR_DEFAULT); 2399 value = (options & MT_ST_CLEAR_DEFAULT); 2400 if (code == MT_ST_DEF_DENSITY) { 2401 if (value == MT_ST_CLEAR_DEFAULT) { 2402 STm->default_density = (-1); 2403 DEBC_printk(STp, 2404 "Density default disabled.\n"); 2405 } else { 2406 STm->default_density = value & 0xff; 2407 DEBC_printk(STp, "Density default set to %x\n", 2408 STm->default_density); 2409 if (STp->ready == ST_READY) { 2410 STp->density_changed = 0; 2411 set_mode_densblk(STp, STm); 2412 } 2413 } 2414 } else if (code == MT_ST_DEF_DRVBUFFER) { 2415 if (value == MT_ST_CLEAR_DEFAULT) { 2416 STp->default_drvbuffer = 0xff; 2417 DEBC_printk(STp, 2418 "Drive buffer default disabled.\n"); 2419 } else { 2420 STp->default_drvbuffer = value & 7; 2421 DEBC_printk(STp, 2422 "Drive buffer default set to %x\n", 2423 STp->default_drvbuffer); 2424 if (STp->ready == ST_READY) 2425 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer); 2426 } 2427 } else if (code == MT_ST_DEF_COMPRESSION) { 2428 if (value == MT_ST_CLEAR_DEFAULT) { 2429 STm->default_compression = ST_DONT_TOUCH; 2430 DEBC_printk(STp, 2431 "Compression default disabled.\n"); 2432 } else { 2433 if ((value & 0xff00) != 0) { 2434 STp->c_algo = (value & 0xff00) >> 8; 2435 DEBC_printk(STp, "Compression " 2436 "algorithm set to 0x%x.\n", 2437 STp->c_algo); 2438 } 2439 if ((value & 0xff) != 0xff) { 2440 STm->default_compression = (value & 1 ? ST_YES : ST_NO); 2441 DEBC_printk(STp, "Compression default " 2442 "set to %x\n", 2443 (value & 1)); 2444 if (STp->ready == ST_READY) { 2445 STp->compression_changed = 0; 2446 st_compression(STp, (STm->default_compression == ST_YES)); 2447 } 2448 } 2449 } 2450 } 2451 } else 2452 return (-EIO); 2453 2454 return 0; 2455 } 2456 2457 #define MODE_HEADER_LENGTH 4 2458 2459 /* Mode header and page byte offsets */ 2460 #define MH_OFF_DATA_LENGTH 0 2461 #define MH_OFF_MEDIUM_TYPE 1 2462 #define MH_OFF_DEV_SPECIFIC 2 2463 #define MH_OFF_BDESCS_LENGTH 3 2464 #define MP_OFF_PAGE_NBR 0 2465 #define MP_OFF_PAGE_LENGTH 1 2466 2467 /* Mode header and page bit masks */ 2468 #define MH_BIT_WP 0x80 2469 #define MP_MSK_PAGE_NBR 0x3f 2470 2471 /* Don't return block descriptors */ 2472 #define MODE_SENSE_OMIT_BDESCS 0x08 2473 2474 #define MODE_SELECT_PAGE_FORMAT 0x10 2475 2476 /* Read a mode page into the tape buffer. The block descriptors are included 2477 if incl_block_descs is true. The page control is ored to the page number 2478 parameter, if necessary. */ 2479 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs) 2480 { 2481 unsigned char cmd[MAX_COMMAND_SIZE]; 2482 struct st_request *SRpnt; 2483 2484 memset(cmd, 0, MAX_COMMAND_SIZE); 2485 cmd[0] = MODE_SENSE; 2486 if (omit_block_descs) 2487 cmd[1] = MODE_SENSE_OMIT_BDESCS; 2488 cmd[2] = page; 2489 cmd[4] = 255; 2490 2491 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE, 2492 STp->device->request_queue->rq_timeout, 0, 1); 2493 if (SRpnt == NULL) 2494 return (STp->buffer)->syscall_result; 2495 2496 st_release_request(SRpnt); 2497 2498 return STp->buffer->syscall_result; 2499 } 2500 2501 2502 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data 2503 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */ 2504 static int write_mode_page(struct scsi_tape *STp, int page, int slow) 2505 { 2506 int pgo; 2507 unsigned char cmd[MAX_COMMAND_SIZE]; 2508 struct st_request *SRpnt; 2509 int timeout; 2510 2511 memset(cmd, 0, MAX_COMMAND_SIZE); 2512 cmd[0] = MODE_SELECT; 2513 cmd[1] = MODE_SELECT_PAGE_FORMAT; 2514 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH]; 2515 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2; 2516 2517 /* Clear reserved fields */ 2518 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0; 2519 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0; 2520 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP; 2521 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR; 2522 2523 timeout = slow ? 2524 STp->long_timeout : STp->device->request_queue->rq_timeout; 2525 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE, 2526 timeout, 0, 1); 2527 if (SRpnt == NULL) 2528 return (STp->buffer)->syscall_result; 2529 2530 st_release_request(SRpnt); 2531 2532 return STp->buffer->syscall_result; 2533 } 2534 2535 2536 #define COMPRESSION_PAGE 0x0f 2537 #define COMPRESSION_PAGE_LENGTH 16 2538 2539 #define CP_OFF_DCE_DCC 2 2540 #define CP_OFF_C_ALGO 7 2541 2542 #define DCE_MASK 0x80 2543 #define DCC_MASK 0x40 2544 #define RED_MASK 0x60 2545 2546 2547 /* Control the compression with mode page 15. Algorithm not changed if zero. 2548 2549 The block descriptors are read and written because Sony SDT-7000 does not 2550 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 2551 Including block descriptors should not cause any harm to other drives. */ 2552 2553 static int st_compression(struct scsi_tape * STp, int state) 2554 { 2555 int retval; 2556 int mpoffs; /* Offset to mode page start */ 2557 unsigned char *b_data = (STp->buffer)->b_data; 2558 2559 if (STp->ready != ST_READY) 2560 return (-EIO); 2561 2562 /* Read the current page contents */ 2563 retval = read_mode_page(STp, COMPRESSION_PAGE, 0); 2564 if (retval) { 2565 DEBC_printk(STp, "Compression mode page not supported.\n"); 2566 return (-EIO); 2567 } 2568 2569 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH]; 2570 DEBC_printk(STp, "Compression state is %d.\n", 2571 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)); 2572 2573 /* Check if compression can be changed */ 2574 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) { 2575 DEBC_printk(STp, "Compression not supported.\n"); 2576 return (-EIO); 2577 } 2578 2579 /* Do the change */ 2580 if (state) { 2581 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK; 2582 if (STp->c_algo != 0) 2583 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo; 2584 } 2585 else { 2586 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK; 2587 if (STp->c_algo != 0) 2588 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */ 2589 } 2590 2591 retval = write_mode_page(STp, COMPRESSION_PAGE, 0); 2592 if (retval) { 2593 DEBC_printk(STp, "Compression change failed.\n"); 2594 return (-EIO); 2595 } 2596 DEBC_printk(STp, "Compression state changed to %d.\n", state); 2597 2598 STp->compression_changed = 1; 2599 return 0; 2600 } 2601 2602 2603 /* Process the load and unload commands (does unload if the load code is zero) */ 2604 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code) 2605 { 2606 int retval = (-EIO), timeout; 2607 unsigned char cmd[MAX_COMMAND_SIZE]; 2608 struct st_partstat *STps; 2609 struct st_request *SRpnt; 2610 2611 if (STp->ready != ST_READY && !load_code) { 2612 if (STp->ready == ST_NO_TAPE) 2613 return (-ENOMEDIUM); 2614 else 2615 return (-EIO); 2616 } 2617 2618 memset(cmd, 0, MAX_COMMAND_SIZE); 2619 cmd[0] = START_STOP; 2620 if (load_code) 2621 cmd[4] |= 1; 2622 /* 2623 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A 2624 */ 2625 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET 2626 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) { 2627 DEBC_printk(STp, " Enhanced %sload slot %2d.\n", 2628 (cmd[4]) ? "" : "un", 2629 load_code - MT_ST_HPLOADER_OFFSET); 2630 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */ 2631 } 2632 if (STp->immediate) { 2633 cmd[1] = 1; /* Don't wait for completion */ 2634 timeout = STp->device->request_queue->rq_timeout; 2635 } 2636 else 2637 timeout = STp->long_timeout; 2638 2639 DEBC( 2640 if (!load_code) 2641 st_printk(ST_DEB_MSG, STp, "Unloading tape.\n"); 2642 else 2643 st_printk(ST_DEB_MSG, STp, "Loading tape.\n"); 2644 ); 2645 2646 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE, 2647 timeout, MAX_RETRIES, 1); 2648 if (!SRpnt) 2649 return (STp->buffer)->syscall_result; 2650 2651 retval = (STp->buffer)->syscall_result; 2652 st_release_request(SRpnt); 2653 2654 if (!retval) { /* SCSI command successful */ 2655 2656 if (!load_code) { 2657 STp->rew_at_close = 0; 2658 STp->ready = ST_NO_TAPE; 2659 } 2660 else { 2661 STp->rew_at_close = STp->autorew_dev; 2662 retval = check_tape(STp, filp); 2663 if (retval > 0) 2664 retval = 0; 2665 } 2666 } 2667 else { 2668 STps = &(STp->ps[STp->partition]); 2669 STps->drv_file = STps->drv_block = (-1); 2670 } 2671 2672 return retval; 2673 } 2674 2675 #if DEBUG 2676 #define ST_DEB_FORWARD 0 2677 #define ST_DEB_BACKWARD 1 2678 static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd) 2679 { 2680 s32 sc; 2681 2682 if (!debugging) 2683 return; 2684 2685 sc = sign_extend32(get_unaligned_be24(&cmd[2]), 23); 2686 if (direction) 2687 sc = -sc; 2688 st_printk(ST_DEB_MSG, STp, "Spacing tape %s over %d %s.\n", 2689 direction ? "backward" : "forward", sc, units); 2690 } 2691 #else 2692 #define ST_DEB_FORWARD 0 2693 #define ST_DEB_BACKWARD 1 2694 static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd) {} 2695 #endif 2696 2697 2698 /* Internal ioctl function */ 2699 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg) 2700 { 2701 int timeout; 2702 long ltmp; 2703 int ioctl_result; 2704 int chg_eof = 1; 2705 unsigned char cmd[MAX_COMMAND_SIZE]; 2706 struct st_request *SRpnt; 2707 struct st_partstat *STps; 2708 int fileno, blkno, at_sm, undone; 2709 int datalen = 0, direction = DMA_NONE; 2710 2711 WARN_ON(STp->buffer->do_dio != 0); 2712 if (STp->ready != ST_READY) { 2713 if (STp->ready == ST_NO_TAPE) 2714 return (-ENOMEDIUM); 2715 else 2716 return (-EIO); 2717 } 2718 timeout = STp->long_timeout; 2719 STps = &(STp->ps[STp->partition]); 2720 fileno = STps->drv_file; 2721 blkno = STps->drv_block; 2722 at_sm = STps->at_sm; 2723 2724 memset(cmd, 0, MAX_COMMAND_SIZE); 2725 switch (cmd_in) { 2726 case MTFSFM: 2727 chg_eof = 0; /* Changed from the FSF after this */ 2728 fallthrough; 2729 case MTFSF: 2730 cmd[0] = SPACE; 2731 cmd[1] = 0x01; /* Space FileMarks */ 2732 cmd[2] = (arg >> 16); 2733 cmd[3] = (arg >> 8); 2734 cmd[4] = arg; 2735 deb_space_print(STp, ST_DEB_FORWARD, "filemarks", cmd); 2736 if (fileno >= 0) 2737 fileno += arg; 2738 blkno = 0; 2739 at_sm &= (arg == 0); 2740 break; 2741 case MTBSFM: 2742 chg_eof = 0; /* Changed from the FSF after this */ 2743 fallthrough; 2744 case MTBSF: 2745 cmd[0] = SPACE; 2746 cmd[1] = 0x01; /* Space FileMarks */ 2747 ltmp = (-arg); 2748 cmd[2] = (ltmp >> 16); 2749 cmd[3] = (ltmp >> 8); 2750 cmd[4] = ltmp; 2751 deb_space_print(STp, ST_DEB_BACKWARD, "filemarks", cmd); 2752 if (fileno >= 0) 2753 fileno -= arg; 2754 blkno = (-1); /* We can't know the block number */ 2755 at_sm &= (arg == 0); 2756 break; 2757 case MTFSR: 2758 cmd[0] = SPACE; 2759 cmd[1] = 0x00; /* Space Blocks */ 2760 cmd[2] = (arg >> 16); 2761 cmd[3] = (arg >> 8); 2762 cmd[4] = arg; 2763 deb_space_print(STp, ST_DEB_FORWARD, "blocks", cmd); 2764 if (blkno >= 0) 2765 blkno += arg; 2766 at_sm &= (arg == 0); 2767 break; 2768 case MTBSR: 2769 cmd[0] = SPACE; 2770 cmd[1] = 0x00; /* Space Blocks */ 2771 ltmp = (-arg); 2772 cmd[2] = (ltmp >> 16); 2773 cmd[3] = (ltmp >> 8); 2774 cmd[4] = ltmp; 2775 deb_space_print(STp, ST_DEB_BACKWARD, "blocks", cmd); 2776 if (blkno >= 0) 2777 blkno -= arg; 2778 at_sm &= (arg == 0); 2779 break; 2780 case MTFSS: 2781 cmd[0] = SPACE; 2782 cmd[1] = 0x04; /* Space Setmarks */ 2783 cmd[2] = (arg >> 16); 2784 cmd[3] = (arg >> 8); 2785 cmd[4] = arg; 2786 deb_space_print(STp, ST_DEB_FORWARD, "setmarks", cmd); 2787 if (arg != 0) { 2788 blkno = fileno = (-1); 2789 at_sm = 1; 2790 } 2791 break; 2792 case MTBSS: 2793 cmd[0] = SPACE; 2794 cmd[1] = 0x04; /* Space Setmarks */ 2795 ltmp = (-arg); 2796 cmd[2] = (ltmp >> 16); 2797 cmd[3] = (ltmp >> 8); 2798 cmd[4] = ltmp; 2799 deb_space_print(STp, ST_DEB_BACKWARD, "setmarks", cmd); 2800 if (arg != 0) { 2801 blkno = fileno = (-1); 2802 at_sm = 1; 2803 } 2804 break; 2805 case MTWEOF: 2806 case MTWEOFI: 2807 case MTWSM: 2808 if (STp->write_prot) 2809 return (-EACCES); 2810 cmd[0] = WRITE_FILEMARKS; 2811 if (cmd_in == MTWSM) 2812 cmd[1] = 2; 2813 if (cmd_in == MTWEOFI || 2814 (cmd_in == MTWEOF && STp->immediate_filemark)) 2815 cmd[1] |= 1; 2816 cmd[2] = (arg >> 16); 2817 cmd[3] = (arg >> 8); 2818 cmd[4] = arg; 2819 timeout = STp->device->request_queue->rq_timeout; 2820 DEBC( 2821 if (cmd_in != MTWSM) 2822 st_printk(ST_DEB_MSG, STp, 2823 "Writing %d filemarks.\n", 2824 cmd[2] * 65536 + 2825 cmd[3] * 256 + 2826 cmd[4]); 2827 else 2828 st_printk(ST_DEB_MSG, STp, 2829 "Writing %d setmarks.\n", 2830 cmd[2] * 65536 + 2831 cmd[3] * 256 + 2832 cmd[4]); 2833 ) 2834 if (fileno >= 0) 2835 fileno += arg; 2836 blkno = 0; 2837 at_sm = (cmd_in == MTWSM); 2838 break; 2839 case MTREW: 2840 cmd[0] = REZERO_UNIT; 2841 if (STp->immediate) { 2842 cmd[1] = 1; /* Don't wait for completion */ 2843 timeout = STp->device->request_queue->rq_timeout; 2844 } 2845 DEBC_printk(STp, "Rewinding tape.\n"); 2846 fileno = blkno = at_sm = 0; 2847 break; 2848 case MTNOP: 2849 DEBC_printk(STp, "No op on tape.\n"); 2850 return 0; /* Should do something ? */ 2851 case MTRETEN: 2852 cmd[0] = START_STOP; 2853 if (STp->immediate) { 2854 cmd[1] = 1; /* Don't wait for completion */ 2855 timeout = STp->device->request_queue->rq_timeout; 2856 } 2857 cmd[4] = 3; 2858 DEBC_printk(STp, "Retensioning tape.\n"); 2859 fileno = blkno = at_sm = 0; 2860 break; 2861 case MTEOM: 2862 if (!STp->fast_mteom) { 2863 /* space to the end of tape */ 2864 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff); 2865 fileno = STps->drv_file; 2866 if (STps->eof >= ST_EOD_1) 2867 return 0; 2868 /* The next lines would hide the number of spaced FileMarks 2869 That's why I inserted the previous lines. I had no luck 2870 with detecting EOM with FSF, so we go now to EOM. 2871 Joerg Weule */ 2872 } else 2873 fileno = (-1); 2874 cmd[0] = SPACE; 2875 cmd[1] = 3; 2876 DEBC_printk(STp, "Spacing to end of recorded medium.\n"); 2877 blkno = -1; 2878 at_sm = 0; 2879 break; 2880 case MTERASE: 2881 if (STp->write_prot) 2882 return (-EACCES); 2883 cmd[0] = ERASE; 2884 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */ 2885 if (STp->immediate) { 2886 cmd[1] |= 2; /* Don't wait for completion */ 2887 timeout = STp->device->request_queue->rq_timeout; 2888 } 2889 else 2890 timeout = STp->long_timeout * 8; 2891 2892 DEBC_printk(STp, "Erasing tape.\n"); 2893 fileno = blkno = at_sm = 0; 2894 break; 2895 case MTSETBLK: /* Set block length */ 2896 case MTSETDENSITY: /* Set tape density */ 2897 case MTSETDRVBUFFER: /* Set drive buffering */ 2898 case SET_DENS_AND_BLK: /* Set density and block size */ 2899 chg_eof = 0; 2900 if (STp->dirty || (STp->buffer)->buffer_bytes != 0) 2901 return (-EIO); /* Not allowed if data in buffer */ 2902 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) && 2903 (arg & MT_ST_BLKSIZE_MASK) != 0 && 2904 STp->max_block > 0 && 2905 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block || 2906 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) { 2907 st_printk(KERN_WARNING, STp, "Illegal block size.\n"); 2908 return (-EINVAL); 2909 } 2910 cmd[0] = MODE_SELECT; 2911 if ((STp->use_pf & USE_PF)) 2912 cmd[1] = MODE_SELECT_PAGE_FORMAT; 2913 cmd[4] = datalen = 12; 2914 direction = DMA_TO_DEVICE; 2915 2916 memset((STp->buffer)->b_data, 0, 12); 2917 if (cmd_in == MTSETDRVBUFFER) 2918 (STp->buffer)->b_data[2] = (arg & 7) << 4; 2919 else 2920 (STp->buffer)->b_data[2] = 2921 STp->drv_buffer << 4; 2922 (STp->buffer)->b_data[3] = 8; /* block descriptor length */ 2923 if (cmd_in == MTSETDENSITY) { 2924 (STp->buffer)->b_data[4] = arg; 2925 STp->density_changed = 1; /* At least we tried ;-) */ 2926 } else if (cmd_in == SET_DENS_AND_BLK) 2927 (STp->buffer)->b_data[4] = arg >> 24; 2928 else 2929 (STp->buffer)->b_data[4] = STp->density; 2930 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 2931 ltmp = arg & MT_ST_BLKSIZE_MASK; 2932 if (cmd_in == MTSETBLK) 2933 STp->blksize_changed = 1; /* At least we tried ;-) */ 2934 } else 2935 ltmp = STp->block_size; 2936 (STp->buffer)->b_data[9] = (ltmp >> 16); 2937 (STp->buffer)->b_data[10] = (ltmp >> 8); 2938 (STp->buffer)->b_data[11] = ltmp; 2939 timeout = STp->device->request_queue->rq_timeout; 2940 DEBC( 2941 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) 2942 st_printk(ST_DEB_MSG, STp, 2943 "Setting block size to %d bytes.\n", 2944 (STp->buffer)->b_data[9] * 65536 + 2945 (STp->buffer)->b_data[10] * 256 + 2946 (STp->buffer)->b_data[11]); 2947 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK) 2948 st_printk(ST_DEB_MSG, STp, 2949 "Setting density code to %x.\n", 2950 (STp->buffer)->b_data[4]); 2951 if (cmd_in == MTSETDRVBUFFER) 2952 st_printk(ST_DEB_MSG, STp, 2953 "Setting drive buffer code to %d.\n", 2954 ((STp->buffer)->b_data[2] >> 4) & 7); 2955 ) 2956 break; 2957 default: 2958 return (-ENOSYS); 2959 } 2960 2961 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction, 2962 timeout, MAX_RETRIES, 1); 2963 if (!SRpnt) 2964 return (STp->buffer)->syscall_result; 2965 2966 ioctl_result = (STp->buffer)->syscall_result; 2967 2968 if (!ioctl_result) { /* SCSI command successful */ 2969 st_release_request(SRpnt); 2970 SRpnt = NULL; 2971 STps->drv_block = blkno; 2972 STps->drv_file = fileno; 2973 STps->at_sm = at_sm; 2974 2975 if (cmd_in == MTBSFM) 2976 ioctl_result = st_int_ioctl(STp, MTFSF, 1); 2977 else if (cmd_in == MTFSFM) 2978 ioctl_result = st_int_ioctl(STp, MTBSF, 1); 2979 2980 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) { 2981 STp->block_size = arg & MT_ST_BLKSIZE_MASK; 2982 if (STp->block_size != 0) { 2983 (STp->buffer)->buffer_blocks = 2984 (STp->buffer)->buffer_size / STp->block_size; 2985 } 2986 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0; 2987 if (cmd_in == SET_DENS_AND_BLK) 2988 STp->density = arg >> MT_ST_DENSITY_SHIFT; 2989 } else if (cmd_in == MTSETDRVBUFFER) 2990 STp->drv_buffer = (arg & 7); 2991 else if (cmd_in == MTSETDENSITY) 2992 STp->density = arg; 2993 2994 if (cmd_in == MTEOM) 2995 STps->eof = ST_EOD; 2996 else if (cmd_in == MTFSF) 2997 STps->eof = ST_FM; 2998 else if (chg_eof) 2999 STps->eof = ST_NOEOF; 3000 3001 if (cmd_in == MTWEOF || cmd_in == MTWEOFI) 3002 STps->rw = ST_IDLE; /* prevent automatic WEOF at close */ 3003 } else { /* SCSI command was not completely successful. Don't return 3004 from this block without releasing the SCSI command block! */ 3005 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; 3006 3007 if (cmdstatp->flags & SENSE_EOM) { 3008 if (cmd_in != MTBSF && cmd_in != MTBSFM && 3009 cmd_in != MTBSR && cmd_in != MTBSS) 3010 STps->eof = ST_EOM_OK; 3011 STps->drv_block = 0; 3012 } 3013 3014 if (cmdstatp->remainder_valid) 3015 undone = (int)cmdstatp->uremainder64; 3016 else 3017 undone = 0; 3018 3019 if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) && 3020 cmdstatp->have_sense && 3021 (cmdstatp->flags & SENSE_EOM)) { 3022 if (cmdstatp->sense_hdr.sense_key == NO_SENSE || 3023 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) { 3024 ioctl_result = 0; /* EOF(s) written successfully at EOM */ 3025 STps->eof = ST_NOEOF; 3026 } else { /* Writing EOF(s) failed */ 3027 if (fileno >= 0) 3028 fileno -= undone; 3029 if (undone < arg) 3030 STps->eof = ST_NOEOF; 3031 } 3032 STps->drv_file = fileno; 3033 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) { 3034 if (fileno >= 0) 3035 STps->drv_file = fileno - undone; 3036 else 3037 STps->drv_file = fileno; 3038 STps->drv_block = -1; 3039 STps->eof = ST_NOEOF; 3040 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) { 3041 if (arg > 0 && undone < 0) /* Some drives get this wrong */ 3042 undone = (-undone); 3043 if (STps->drv_file >= 0) 3044 STps->drv_file = fileno + undone; 3045 STps->drv_block = 0; 3046 STps->eof = ST_NOEOF; 3047 } else if (cmd_in == MTFSR) { 3048 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 3049 if (STps->drv_file >= 0) 3050 STps->drv_file++; 3051 STps->drv_block = 0; 3052 STps->eof = ST_FM; 3053 } else { 3054 if (blkno >= undone) 3055 STps->drv_block = blkno - undone; 3056 else 3057 STps->drv_block = (-1); 3058 STps->eof = ST_NOEOF; 3059 } 3060 } else if (cmd_in == MTBSR) { 3061 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */ 3062 STps->drv_file--; 3063 STps->drv_block = (-1); 3064 } else { 3065 if (arg > 0 && undone < 0) /* Some drives get this wrong */ 3066 undone = (-undone); 3067 if (STps->drv_block >= 0) 3068 STps->drv_block = blkno + undone; 3069 } 3070 STps->eof = ST_NOEOF; 3071 } else if (cmd_in == MTEOM) { 3072 STps->drv_file = (-1); 3073 STps->drv_block = (-1); 3074 STps->eof = ST_EOD; 3075 } else if (cmd_in == MTSETBLK || 3076 cmd_in == MTSETDENSITY || 3077 cmd_in == MTSETDRVBUFFER || 3078 cmd_in == SET_DENS_AND_BLK) { 3079 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST && 3080 !(STp->use_pf & PF_TESTED)) { 3081 /* Try the other possible state of Page Format if not 3082 already tried */ 3083 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED; 3084 st_release_request(SRpnt); 3085 SRpnt = NULL; 3086 return st_int_ioctl(STp, cmd_in, arg); 3087 } 3088 } else if (chg_eof) 3089 STps->eof = ST_NOEOF; 3090 3091 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) 3092 STps->eof = ST_EOD; 3093 3094 st_release_request(SRpnt); 3095 SRpnt = NULL; 3096 } 3097 3098 return ioctl_result; 3099 } 3100 3101 3102 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc 3103 structure. */ 3104 3105 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition, 3106 int logical) 3107 { 3108 int result; 3109 unsigned char scmd[MAX_COMMAND_SIZE]; 3110 struct st_request *SRpnt; 3111 3112 if (STp->ready != ST_READY) 3113 return (-EIO); 3114 3115 memset(scmd, 0, MAX_COMMAND_SIZE); 3116 if ((STp->device)->scsi_level < SCSI_2) { 3117 scmd[0] = QFA_REQUEST_BLOCK; 3118 scmd[4] = 3; 3119 } else { 3120 scmd[0] = READ_POSITION; 3121 if (!logical && !STp->scsi2_logical) 3122 scmd[1] = 1; 3123 } 3124 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE, 3125 STp->device->request_queue->rq_timeout, 3126 MAX_READY_RETRIES, 1); 3127 if (!SRpnt) 3128 return (STp->buffer)->syscall_result; 3129 3130 if ((STp->buffer)->syscall_result != 0 || 3131 (STp->device->scsi_level >= SCSI_2 && 3132 ((STp->buffer)->b_data[0] & 4) != 0)) { 3133 *block = *partition = 0; 3134 DEBC_printk(STp, " Can't read tape position.\n"); 3135 result = (-EIO); 3136 } else { 3137 result = 0; 3138 if ((STp->device)->scsi_level < SCSI_2) { 3139 *block = ((STp->buffer)->b_data[0] << 16) 3140 + ((STp->buffer)->b_data[1] << 8) 3141 + (STp->buffer)->b_data[2]; 3142 *partition = 0; 3143 } else { 3144 *block = ((STp->buffer)->b_data[4] << 24) 3145 + ((STp->buffer)->b_data[5] << 16) 3146 + ((STp->buffer)->b_data[6] << 8) 3147 + (STp->buffer)->b_data[7]; 3148 *partition = (STp->buffer)->b_data[1]; 3149 if (((STp->buffer)->b_data[0] & 0x80) && 3150 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */ 3151 STp->ps[0].drv_block = STp->ps[0].drv_file = 0; 3152 } 3153 DEBC_printk(STp, "Got tape pos. blk %d part %d.\n", 3154 *block, *partition); 3155 } 3156 st_release_request(SRpnt); 3157 SRpnt = NULL; 3158 3159 return result; 3160 } 3161 3162 3163 /* Set the tape block and partition. Negative partition means that only the 3164 block should be set in vendor specific way. */ 3165 static int set_location(struct scsi_tape *STp, unsigned int block, int partition, 3166 int logical) 3167 { 3168 struct st_partstat *STps; 3169 int result, p; 3170 unsigned int blk; 3171 int timeout; 3172 unsigned char scmd[MAX_COMMAND_SIZE]; 3173 struct st_request *SRpnt; 3174 3175 if (STp->ready != ST_READY) 3176 return (-EIO); 3177 timeout = STp->long_timeout; 3178 STps = &(STp->ps[STp->partition]); 3179 3180 DEBC_printk(STp, "Setting block to %d and partition to %d.\n", 3181 block, partition); 3182 DEB(if (partition < 0) 3183 return (-EIO); ) 3184 3185 /* Update the location at the partition we are leaving */ 3186 if ((!STp->can_partitions && partition != 0) || 3187 partition >= ST_NBR_PARTITIONS) 3188 return (-EINVAL); 3189 if (partition != STp->partition) { 3190 if (get_location(STp, &blk, &p, 1)) 3191 STps->last_block_valid = 0; 3192 else { 3193 STps->last_block_valid = 1; 3194 STps->last_block_visited = blk; 3195 DEBC_printk(STp, "Visited block %d for " 3196 "partition %d saved.\n", 3197 blk, STp->partition); 3198 } 3199 } 3200 3201 memset(scmd, 0, MAX_COMMAND_SIZE); 3202 if ((STp->device)->scsi_level < SCSI_2) { 3203 scmd[0] = QFA_SEEK_BLOCK; 3204 scmd[2] = (block >> 16); 3205 scmd[3] = (block >> 8); 3206 scmd[4] = block; 3207 scmd[5] = 0; 3208 } else { 3209 scmd[0] = SEEK_10; 3210 scmd[3] = (block >> 24); 3211 scmd[4] = (block >> 16); 3212 scmd[5] = (block >> 8); 3213 scmd[6] = block; 3214 if (!logical && !STp->scsi2_logical) 3215 scmd[1] = 4; 3216 if (STp->partition != partition) { 3217 scmd[1] |= 2; 3218 scmd[8] = partition; 3219 DEBC_printk(STp, "Trying to change partition " 3220 "from %d to %d\n", STp->partition, 3221 partition); 3222 } 3223 } 3224 if (STp->immediate) { 3225 scmd[1] |= 1; /* Don't wait for completion */ 3226 timeout = STp->device->request_queue->rq_timeout; 3227 } 3228 3229 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE, 3230 timeout, MAX_READY_RETRIES, 1); 3231 if (!SRpnt) 3232 return (STp->buffer)->syscall_result; 3233 3234 STps->drv_block = STps->drv_file = (-1); 3235 STps->eof = ST_NOEOF; 3236 if ((STp->buffer)->syscall_result != 0) { 3237 result = (-EIO); 3238 if (STp->can_partitions && 3239 (STp->device)->scsi_level >= SCSI_2 && 3240 (p = find_partition(STp)) >= 0) 3241 STp->partition = p; 3242 } else { 3243 if (STp->can_partitions) { 3244 STp->partition = partition; 3245 STps = &(STp->ps[partition]); 3246 if (!STps->last_block_valid || 3247 STps->last_block_visited != block) { 3248 STps->at_sm = 0; 3249 STps->rw = ST_IDLE; 3250 } 3251 } else 3252 STps->at_sm = 0; 3253 if (block == 0) 3254 STps->drv_block = STps->drv_file = 0; 3255 result = 0; 3256 } 3257 3258 st_release_request(SRpnt); 3259 SRpnt = NULL; 3260 3261 return result; 3262 } 3263 3264 3265 /* Find the current partition number for the drive status. Called from open and 3266 returns either partition number of negative error code. */ 3267 static int find_partition(struct scsi_tape *STp) 3268 { 3269 int i, partition; 3270 unsigned int block; 3271 3272 if ((i = get_location(STp, &block, &partition, 1)) < 0) 3273 return i; 3274 if (partition >= ST_NBR_PARTITIONS) 3275 return (-EIO); 3276 return partition; 3277 } 3278 3279 3280 /* Change the partition if necessary */ 3281 static int switch_partition(struct scsi_tape *STp) 3282 { 3283 struct st_partstat *STps; 3284 3285 if (STp->partition == STp->new_partition) 3286 return 0; 3287 STps = &(STp->ps[STp->new_partition]); 3288 if (!STps->last_block_valid) 3289 STps->last_block_visited = 0; 3290 return set_location(STp, STps->last_block_visited, STp->new_partition, 1); 3291 } 3292 3293 /* Functions for reading and writing the medium partition mode page. */ 3294 3295 #define PART_PAGE 0x11 3296 #define PART_PAGE_FIXED_LENGTH 8 3297 3298 #define PP_OFF_MAX_ADD_PARTS 2 3299 #define PP_OFF_NBR_ADD_PARTS 3 3300 #define PP_OFF_FLAGS 4 3301 #define PP_OFF_PART_UNITS 6 3302 #define PP_OFF_RESERVED 7 3303 3304 #define PP_BIT_IDP 0x20 3305 #define PP_BIT_FDP 0x80 3306 #define PP_MSK_PSUM_MB 0x10 3307 #define PP_MSK_PSUM_UNITS 0x18 3308 #define PP_MSK_POFM 0x04 3309 3310 /* Get the number of partitions on the tape. As a side effect reads the 3311 mode page into the tape buffer. */ 3312 static int nbr_partitions(struct scsi_tape *STp) 3313 { 3314 int result; 3315 3316 if (STp->ready != ST_READY) 3317 return (-EIO); 3318 3319 result = read_mode_page(STp, PART_PAGE, 1); 3320 3321 if (result) { 3322 DEBC_printk(STp, "Can't read medium partition page.\n"); 3323 result = (-EIO); 3324 } else { 3325 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3326 PP_OFF_NBR_ADD_PARTS] + 1; 3327 DEBC_printk(STp, "Number of partitions %d.\n", result); 3328 } 3329 3330 return result; 3331 } 3332 3333 3334 static int format_medium(struct scsi_tape *STp, int format) 3335 { 3336 int result = 0; 3337 int timeout = STp->long_timeout; 3338 unsigned char scmd[MAX_COMMAND_SIZE]; 3339 struct st_request *SRpnt; 3340 3341 memset(scmd, 0, MAX_COMMAND_SIZE); 3342 scmd[0] = FORMAT_UNIT; 3343 scmd[2] = format; 3344 if (STp->immediate) { 3345 scmd[1] |= 1; /* Don't wait for completion */ 3346 timeout = STp->device->request_queue->rq_timeout; 3347 } 3348 DEBC_printk(STp, "Sending FORMAT MEDIUM\n"); 3349 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE, 3350 timeout, MAX_RETRIES, 1); 3351 if (!SRpnt) 3352 result = STp->buffer->syscall_result; 3353 return result; 3354 } 3355 3356 3357 /* Partition the tape into two partitions if size > 0 or one partition if 3358 size == 0. 3359 3360 The block descriptors are read and written because Sony SDT-7000 does not 3361 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>). 3362 3363 My HP C1533A drive returns only one partition size field. This is used to 3364 set the size of partition 1. There is no size field for the default partition. 3365 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is 3366 used to set the size of partition 1 (this is what the SCSI-3 standard specifies). 3367 The following algorithm is used to accommodate both drives: if the number of 3368 partition size fields is greater than the maximum number of additional partitions 3369 in the mode page, the second field is used. Otherwise the first field is used. 3370 3371 For Seagate DDS drives the page length must be 8 when no partitions is defined 3372 and 10 when 1 partition is defined (information from Eric Lee Green). This is 3373 is acceptable also to some other old drives and enforced if the first partition 3374 size field is used for the first additional partition size. 3375 3376 For drives that advertize SCSI-3 or newer, use the SSC-3 methods. 3377 */ 3378 static int partition_tape(struct scsi_tape *STp, int size) 3379 { 3380 int result; 3381 int target_partition; 3382 bool scsi3 = STp->device->scsi_level >= SCSI_3, needs_format = false; 3383 int pgo, psd_cnt, psdo; 3384 int psum = PP_MSK_PSUM_MB, units = 0; 3385 unsigned char *bp; 3386 3387 result = read_mode_page(STp, PART_PAGE, 0); 3388 if (result) { 3389 DEBC_printk(STp, "Can't read partition mode page.\n"); 3390 return result; 3391 } 3392 target_partition = 1; 3393 if (size < 0) { 3394 target_partition = 0; 3395 size = -size; 3396 } 3397 3398 /* The mode page is in the buffer. Let's modify it and write it. */ 3399 bp = (STp->buffer)->b_data; 3400 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH]; 3401 DEBC_printk(STp, "Partition page length is %d bytes.\n", 3402 bp[pgo + MP_OFF_PAGE_LENGTH] + 2); 3403 3404 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2; 3405 3406 if (scsi3) { 3407 needs_format = (bp[pgo + PP_OFF_FLAGS] & PP_MSK_POFM) != 0; 3408 if (needs_format && size == 0) { 3409 /* No need to write the mode page when clearing 3410 * partitioning 3411 */ 3412 DEBC_printk(STp, "Formatting tape with one partition.\n"); 3413 result = format_medium(STp, 0); 3414 goto out; 3415 } 3416 if (needs_format) /* Leave the old value for HP DATs claiming SCSI_3 */ 3417 psd_cnt = 2; 3418 if ((bp[pgo + PP_OFF_FLAGS] & PP_MSK_PSUM_UNITS) == PP_MSK_PSUM_UNITS) { 3419 /* Use units scaling for large partitions if the device 3420 * suggests it and no precision lost. Required for IBM 3421 * TS1140/50 drives that don't support MB units. 3422 */ 3423 if (size >= 1000 && (size % 1000) == 0) { 3424 size /= 1000; 3425 psum = PP_MSK_PSUM_UNITS; 3426 units = 9; /* GB */ 3427 } 3428 } 3429 /* Try it anyway if too large to specify in MB */ 3430 if (psum == PP_MSK_PSUM_MB && size >= 65534) { 3431 size /= 1000; 3432 psum = PP_MSK_PSUM_UNITS; 3433 units = 9; /* GB */ 3434 } 3435 } 3436 3437 if (size >= 65535 || /* Does not fit into two bytes */ 3438 (target_partition == 0 && psd_cnt < 2)) { 3439 result = -EINVAL; 3440 goto out; 3441 } 3442 3443 psdo = pgo + PART_PAGE_FIXED_LENGTH; 3444 /* The second condition is for HP DDS which use only one partition size 3445 * descriptor 3446 */ 3447 if (target_partition > 0 && 3448 (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS] || 3449 bp[pgo + PP_OFF_MAX_ADD_PARTS] != 1)) { 3450 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest to partition 0 */ 3451 psdo += 2; 3452 } 3453 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2); 3454 3455 DEBC_printk(STp, "psd_cnt %d, max.parts %d, nbr_parts %d\n", 3456 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS], 3457 bp[pgo + PP_OFF_NBR_ADD_PARTS]); 3458 3459 if (size == 0) { 3460 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0; 3461 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS]) 3462 bp[pgo + MP_OFF_PAGE_LENGTH] = 6; 3463 DEBC_printk(STp, "Formatting tape with one partition.\n"); 3464 } else { 3465 bp[psdo] = (size >> 8) & 0xff; 3466 bp[psdo + 1] = size & 0xff; 3467 if (target_partition == 0) 3468 bp[psdo + 2] = bp[psdo + 3] = 0xff; 3469 bp[pgo + 3] = 1; 3470 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8) 3471 bp[pgo + MP_OFF_PAGE_LENGTH] = 8; 3472 DEBC_printk(STp, 3473 "Formatting tape with two partitions (%i = %d MB).\n", 3474 target_partition, units > 0 ? size * 1000 : size); 3475 } 3476 bp[pgo + PP_OFF_PART_UNITS] = 0; 3477 bp[pgo + PP_OFF_RESERVED] = 0; 3478 if (size != 1 || units != 0) { 3479 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | psum | 3480 (bp[pgo + PP_OFF_FLAGS] & 0x07); 3481 bp[pgo + PP_OFF_PART_UNITS] = units; 3482 } else 3483 bp[pgo + PP_OFF_FLAGS] = PP_BIT_FDP | 3484 (bp[pgo + PP_OFF_FLAGS] & 0x1f); 3485 bp[pgo + MP_OFF_PAGE_LENGTH] = 6 + psd_cnt * 2; 3486 3487 result = write_mode_page(STp, PART_PAGE, 1); 3488 3489 if (!result && needs_format) 3490 result = format_medium(STp, 1); 3491 3492 if (result) { 3493 st_printk(KERN_INFO, STp, "Partitioning of tape failed.\n"); 3494 result = (-EIO); 3495 } 3496 3497 out: 3498 return result; 3499 } 3500 3501 3502 3503 /* The ioctl command */ 3504 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) 3505 { 3506 void __user *p = (void __user *)arg; 3507 int i, cmd_nr, cmd_type, bt; 3508 int retval = 0; 3509 unsigned int blk; 3510 struct scsi_tape *STp = file->private_data; 3511 struct st_modedef *STm; 3512 struct st_partstat *STps; 3513 3514 if (mutex_lock_interruptible(&STp->lock)) 3515 return -ERESTARTSYS; 3516 3517 DEB( 3518 if (debugging && !STp->in_use) { 3519 st_printk(ST_DEB_MSG, STp, "Incorrect device.\n"); 3520 retval = (-EIO); 3521 goto out; 3522 } ) /* end DEB */ 3523 3524 STm = &(STp->modes[STp->current_mode]); 3525 STps = &(STp->ps[STp->partition]); 3526 3527 /* 3528 * If we are in the middle of error recovery, don't let anyone 3529 * else try and use this device. Also, if error recovery fails, it 3530 * may try and take the device offline, in which case all further 3531 * access to the device is prohibited. 3532 */ 3533 retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in, 3534 file->f_flags & O_NDELAY); 3535 if (retval) 3536 goto out; 3537 3538 cmd_type = _IOC_TYPE(cmd_in); 3539 cmd_nr = _IOC_NR(cmd_in); 3540 3541 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) { 3542 struct mtop mtc; 3543 3544 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) { 3545 retval = (-EINVAL); 3546 goto out; 3547 } 3548 3549 i = copy_from_user(&mtc, p, sizeof(struct mtop)); 3550 if (i) { 3551 retval = (-EFAULT); 3552 goto out; 3553 } 3554 3555 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) { 3556 st_printk(KERN_WARNING, STp, 3557 "MTSETDRVBUFFER only allowed for root.\n"); 3558 retval = (-EPERM); 3559 goto out; 3560 } 3561 if (!STm->defined && 3562 (mtc.mt_op != MTSETDRVBUFFER && 3563 (mtc.mt_count & MT_ST_OPTIONS) == 0)) { 3564 retval = (-ENXIO); 3565 goto out; 3566 } 3567 3568 if (!STp->pos_unknown) { 3569 3570 if (STps->eof == ST_FM_HIT) { 3571 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 3572 mtc.mt_op == MTEOM) { 3573 mtc.mt_count -= 1; 3574 if (STps->drv_file >= 0) 3575 STps->drv_file += 1; 3576 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) { 3577 mtc.mt_count += 1; 3578 if (STps->drv_file >= 0) 3579 STps->drv_file += 1; 3580 } 3581 } 3582 3583 if (mtc.mt_op == MTSEEK) { 3584 /* Old position must be restored if partition will be 3585 changed */ 3586 i = !STp->can_partitions || 3587 (STp->new_partition != STp->partition); 3588 } else { 3589 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 3590 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM || 3591 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD || 3592 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 3593 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM || 3594 mtc.mt_op == MTCOMPRESSION; 3595 } 3596 i = flush_buffer(STp, i); 3597 if (i < 0) { 3598 retval = i; 3599 goto out; 3600 } 3601 if (STps->rw == ST_WRITING && 3602 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 3603 mtc.mt_op == MTSEEK || 3604 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) { 3605 i = st_int_ioctl(STp, MTWEOF, 1); 3606 if (i < 0) { 3607 retval = i; 3608 goto out; 3609 } 3610 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) 3611 mtc.mt_count++; 3612 STps->rw = ST_IDLE; 3613 } 3614 3615 } else { 3616 /* 3617 * If there was a bus reset, block further access 3618 * to this device. If the user wants to rewind the tape, 3619 * then reset the flag and allow access again. 3620 */ 3621 if (mtc.mt_op != MTREW && 3622 mtc.mt_op != MTOFFL && 3623 mtc.mt_op != MTRETEN && 3624 mtc.mt_op != MTERASE && 3625 mtc.mt_op != MTSEEK && 3626 mtc.mt_op != MTEOM) { 3627 retval = (-EIO); 3628 goto out; 3629 } 3630 reset_state(STp); 3631 /* remove this when the midlevel properly clears was_reset */ 3632 STp->device->was_reset = 0; 3633 } 3634 3635 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK && 3636 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM && 3637 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART) 3638 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */ 3639 3640 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED) 3641 do_door_lock(STp, 0); /* Ignore result! */ 3642 3643 if (mtc.mt_op == MTSETDRVBUFFER && 3644 (mtc.mt_count & MT_ST_OPTIONS) != 0) { 3645 retval = st_set_options(STp, mtc.mt_count); 3646 goto out; 3647 } 3648 3649 if (mtc.mt_op == MTSETPART) { 3650 if (!STp->can_partitions || 3651 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) { 3652 retval = (-EINVAL); 3653 goto out; 3654 } 3655 if (mtc.mt_count >= STp->nbr_partitions && 3656 (STp->nbr_partitions = nbr_partitions(STp)) < 0) { 3657 retval = (-EIO); 3658 goto out; 3659 } 3660 if (mtc.mt_count >= STp->nbr_partitions) { 3661 retval = (-EINVAL); 3662 goto out; 3663 } 3664 STp->new_partition = mtc.mt_count; 3665 retval = 0; 3666 goto out; 3667 } 3668 3669 if (mtc.mt_op == MTMKPART) { 3670 if (!STp->can_partitions) { 3671 retval = (-EINVAL); 3672 goto out; 3673 } 3674 i = do_load_unload(STp, file, 1); 3675 if (i < 0) { 3676 retval = i; 3677 goto out; 3678 } 3679 i = partition_tape(STp, mtc.mt_count); 3680 if (i < 0) { 3681 retval = i; 3682 goto out; 3683 } 3684 for (i = 0; i < ST_NBR_PARTITIONS; i++) { 3685 STp->ps[i].rw = ST_IDLE; 3686 STp->ps[i].at_sm = 0; 3687 STp->ps[i].last_block_valid = 0; 3688 } 3689 STp->partition = STp->new_partition = 0; 3690 STp->nbr_partitions = mtc.mt_count != 0 ? 2 : 1; 3691 STps->drv_block = STps->drv_file = 0; 3692 retval = 0; 3693 goto out; 3694 } 3695 3696 if (mtc.mt_op == MTSEEK) { 3697 i = set_location(STp, mtc.mt_count, STp->new_partition, 0); 3698 if (!STp->can_partitions) 3699 STp->ps[0].rw = ST_IDLE; 3700 retval = i; 3701 goto out; 3702 } 3703 3704 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) { 3705 retval = do_load_unload(STp, file, 0); 3706 goto out; 3707 } 3708 3709 if (mtc.mt_op == MTLOAD) { 3710 retval = do_load_unload(STp, file, max(1, mtc.mt_count)); 3711 goto out; 3712 } 3713 3714 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) { 3715 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK)); 3716 goto out; 3717 } 3718 3719 if (STp->can_partitions && STp->ready == ST_READY && 3720 (i = switch_partition(STp)) < 0) { 3721 retval = i; 3722 goto out; 3723 } 3724 3725 if (mtc.mt_op == MTCOMPRESSION) 3726 retval = st_compression(STp, (mtc.mt_count & 1)); 3727 else 3728 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count); 3729 goto out; 3730 } 3731 if (!STm->defined) { 3732 retval = (-ENXIO); 3733 goto out; 3734 } 3735 3736 if ((i = flush_buffer(STp, 0)) < 0) { 3737 retval = i; 3738 goto out; 3739 } 3740 if (STp->can_partitions && 3741 (i = switch_partition(STp)) < 0) { 3742 retval = i; 3743 goto out; 3744 } 3745 3746 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) { 3747 struct mtget mt_status; 3748 3749 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) { 3750 retval = (-EINVAL); 3751 goto out; 3752 } 3753 3754 mt_status.mt_type = STp->tape_type; 3755 mt_status.mt_dsreg = 3756 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | 3757 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK); 3758 mt_status.mt_blkno = STps->drv_block; 3759 mt_status.mt_fileno = STps->drv_file; 3760 if (STp->block_size != 0) { 3761 if (STps->rw == ST_WRITING) 3762 mt_status.mt_blkno += 3763 (STp->buffer)->buffer_bytes / STp->block_size; 3764 else if (STps->rw == ST_READING) 3765 mt_status.mt_blkno -= 3766 ((STp->buffer)->buffer_bytes + 3767 STp->block_size - 1) / STp->block_size; 3768 } 3769 3770 mt_status.mt_gstat = 0; 3771 if (STp->drv_write_prot) 3772 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff); 3773 if (mt_status.mt_blkno == 0) { 3774 if (mt_status.mt_fileno == 0) 3775 mt_status.mt_gstat |= GMT_BOT(0xffffffff); 3776 else 3777 mt_status.mt_gstat |= GMT_EOF(0xffffffff); 3778 } 3779 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT); 3780 mt_status.mt_resid = STp->partition; 3781 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR) 3782 mt_status.mt_gstat |= GMT_EOT(0xffffffff); 3783 else if (STps->eof >= ST_EOM_OK) 3784 mt_status.mt_gstat |= GMT_EOD(0xffffffff); 3785 if (STp->density == 1) 3786 mt_status.mt_gstat |= GMT_D_800(0xffffffff); 3787 else if (STp->density == 2) 3788 mt_status.mt_gstat |= GMT_D_1600(0xffffffff); 3789 else if (STp->density == 3) 3790 mt_status.mt_gstat |= GMT_D_6250(0xffffffff); 3791 if (STp->ready == ST_READY) 3792 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff); 3793 if (STp->ready == ST_NO_TAPE) 3794 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff); 3795 if (STps->at_sm) 3796 mt_status.mt_gstat |= GMT_SM(0xffffffff); 3797 if (STm->do_async_writes || 3798 (STm->do_buffer_writes && STp->block_size != 0) || 3799 STp->drv_buffer != 0) 3800 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff); 3801 if (STp->cleaning_req) 3802 mt_status.mt_gstat |= GMT_CLN(0xffffffff); 3803 3804 retval = put_user_mtget(p, &mt_status); 3805 if (retval) 3806 goto out; 3807 3808 STp->recover_reg = 0; /* Clear after read */ 3809 goto out; 3810 } /* End of MTIOCGET */ 3811 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) { 3812 struct mtpos mt_pos; 3813 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) { 3814 retval = (-EINVAL); 3815 goto out; 3816 } 3817 if ((i = get_location(STp, &blk, &bt, 0)) < 0) { 3818 retval = i; 3819 goto out; 3820 } 3821 mt_pos.mt_blkno = blk; 3822 retval = put_user_mtpos(p, &mt_pos); 3823 goto out; 3824 } 3825 mutex_unlock(&STp->lock); 3826 3827 switch (cmd_in) { 3828 case SG_IO: 3829 case SCSI_IOCTL_SEND_COMMAND: 3830 case CDROM_SEND_PACKET: 3831 if (!capable(CAP_SYS_RAWIO)) 3832 return -EPERM; 3833 break; 3834 default: 3835 break; 3836 } 3837 3838 retval = scsi_ioctl(STp->device, file->f_mode & FMODE_WRITE, cmd_in, p); 3839 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { 3840 /* unload */ 3841 STp->rew_at_close = 0; 3842 STp->ready = ST_NO_TAPE; 3843 } 3844 return retval; 3845 3846 out: 3847 mutex_unlock(&STp->lock); 3848 return retval; 3849 } 3850 3851 #ifdef CONFIG_COMPAT 3852 static long st_compat_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) 3853 { 3854 /* argument conversion is handled using put_user_mtpos/put_user_mtget */ 3855 switch (cmd_in) { 3856 case MTIOCPOS32: 3857 cmd_in = MTIOCPOS; 3858 break; 3859 case MTIOCGET32: 3860 cmd_in = MTIOCGET; 3861 break; 3862 } 3863 3864 return st_ioctl(file, cmd_in, arg); 3865 } 3866 #endif 3867 3868 3869 3870 /* Try to allocate a new tape buffer. Calling function must not hold 3871 dev_arr_lock. */ 3872 static struct st_buffer *new_tape_buffer(int max_sg) 3873 { 3874 struct st_buffer *tb; 3875 3876 tb = kzalloc(sizeof(struct st_buffer), GFP_KERNEL); 3877 if (!tb) { 3878 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n"); 3879 return NULL; 3880 } 3881 tb->frp_segs = 0; 3882 tb->use_sg = max_sg; 3883 tb->buffer_size = 0; 3884 3885 tb->reserved_pages = kcalloc(max_sg, sizeof(struct page *), 3886 GFP_KERNEL); 3887 if (!tb->reserved_pages) { 3888 kfree(tb); 3889 return NULL; 3890 } 3891 3892 return tb; 3893 } 3894 3895 3896 /* Try to allocate enough space in the tape buffer */ 3897 #define ST_MAX_ORDER 6 3898 3899 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size) 3900 { 3901 int segs, max_segs, b_size, order, got; 3902 gfp_t priority; 3903 3904 if (new_size <= STbuffer->buffer_size) 3905 return 1; 3906 3907 if (STbuffer->buffer_size <= PAGE_SIZE) 3908 normalize_buffer(STbuffer); /* Avoid extra segment */ 3909 3910 max_segs = STbuffer->use_sg; 3911 3912 priority = GFP_KERNEL | __GFP_NOWARN; 3913 3914 if (STbuffer->cleared) 3915 priority |= __GFP_ZERO; 3916 3917 if (STbuffer->frp_segs) { 3918 order = STbuffer->reserved_page_order; 3919 b_size = PAGE_SIZE << order; 3920 } else { 3921 for (b_size = PAGE_SIZE, order = 0; 3922 order < ST_MAX_ORDER && 3923 max_segs * (PAGE_SIZE << order) < new_size; 3924 order++, b_size *= 2) 3925 ; /* empty */ 3926 STbuffer->reserved_page_order = order; 3927 } 3928 if (max_segs * (PAGE_SIZE << order) < new_size) { 3929 if (order == ST_MAX_ORDER) 3930 return 0; 3931 normalize_buffer(STbuffer); 3932 return enlarge_buffer(STbuffer, new_size); 3933 } 3934 3935 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size; 3936 segs < max_segs && got < new_size;) { 3937 struct page *page; 3938 3939 page = alloc_pages(priority, order); 3940 if (!page) { 3941 DEB(STbuffer->buffer_size = got); 3942 normalize_buffer(STbuffer); 3943 return 0; 3944 } 3945 3946 STbuffer->frp_segs += 1; 3947 got += b_size; 3948 STbuffer->buffer_size = got; 3949 STbuffer->reserved_pages[segs] = page; 3950 segs++; 3951 } 3952 STbuffer->b_data = page_address(STbuffer->reserved_pages[0]); 3953 3954 return 1; 3955 } 3956 3957 3958 /* Make sure that no data from previous user is in the internal buffer */ 3959 static void clear_buffer(struct st_buffer * st_bp) 3960 { 3961 int i; 3962 3963 for (i=0; i < st_bp->frp_segs; i++) 3964 memset(page_address(st_bp->reserved_pages[i]), 0, 3965 PAGE_SIZE << st_bp->reserved_page_order); 3966 st_bp->cleared = 1; 3967 } 3968 3969 3970 /* Release the extra buffer */ 3971 static void normalize_buffer(struct st_buffer * STbuffer) 3972 { 3973 int i, order = STbuffer->reserved_page_order; 3974 3975 for (i = 0; i < STbuffer->frp_segs; i++) { 3976 __free_pages(STbuffer->reserved_pages[i], order); 3977 STbuffer->buffer_size -= (PAGE_SIZE << order); 3978 } 3979 STbuffer->frp_segs = 0; 3980 STbuffer->sg_segs = 0; 3981 STbuffer->reserved_page_order = 0; 3982 STbuffer->map_data.offset = 0; 3983 } 3984 3985 3986 /* Move data from the user buffer to the tape buffer. Returns zero (success) or 3987 negative error code. */ 3988 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count) 3989 { 3990 int i, cnt, res, offset; 3991 int length = PAGE_SIZE << st_bp->reserved_page_order; 3992 3993 for (i = 0, offset = st_bp->buffer_bytes; 3994 i < st_bp->frp_segs && offset >= length; i++) 3995 offset -= length; 3996 if (i == st_bp->frp_segs) { /* Should never happen */ 3997 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n"); 3998 return (-EIO); 3999 } 4000 for (; i < st_bp->frp_segs && do_count > 0; i++) { 4001 struct page *page = st_bp->reserved_pages[i]; 4002 cnt = length - offset < do_count ? length - offset : do_count; 4003 res = copy_from_user(page_address(page) + offset, ubp, cnt); 4004 if (res) 4005 return (-EFAULT); 4006 do_count -= cnt; 4007 st_bp->buffer_bytes += cnt; 4008 ubp += cnt; 4009 offset = 0; 4010 } 4011 if (do_count) /* Should never happen */ 4012 return (-EIO); 4013 4014 return 0; 4015 } 4016 4017 4018 /* Move data from the tape buffer to the user buffer. Returns zero (success) or 4019 negative error code. */ 4020 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count) 4021 { 4022 int i, cnt, res, offset; 4023 int length = PAGE_SIZE << st_bp->reserved_page_order; 4024 4025 for (i = 0, offset = st_bp->read_pointer; 4026 i < st_bp->frp_segs && offset >= length; i++) 4027 offset -= length; 4028 if (i == st_bp->frp_segs) { /* Should never happen */ 4029 printk(KERN_WARNING "st: from_buffer offset overflow.\n"); 4030 return (-EIO); 4031 } 4032 for (; i < st_bp->frp_segs && do_count > 0; i++) { 4033 struct page *page = st_bp->reserved_pages[i]; 4034 cnt = length - offset < do_count ? length - offset : do_count; 4035 res = copy_to_user(ubp, page_address(page) + offset, cnt); 4036 if (res) 4037 return (-EFAULT); 4038 do_count -= cnt; 4039 st_bp->buffer_bytes -= cnt; 4040 st_bp->read_pointer += cnt; 4041 ubp += cnt; 4042 offset = 0; 4043 } 4044 if (do_count) /* Should never happen */ 4045 return (-EIO); 4046 4047 return 0; 4048 } 4049 4050 4051 /* Move data towards start of buffer */ 4052 static void move_buffer_data(struct st_buffer * st_bp, int offset) 4053 { 4054 int src_seg, dst_seg, src_offset = 0, dst_offset; 4055 int count, total; 4056 int length = PAGE_SIZE << st_bp->reserved_page_order; 4057 4058 if (offset == 0) 4059 return; 4060 4061 total=st_bp->buffer_bytes - offset; 4062 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) { 4063 src_offset = offset; 4064 if (src_offset < length) 4065 break; 4066 offset -= length; 4067 } 4068 4069 st_bp->buffer_bytes = st_bp->read_pointer = total; 4070 for (dst_seg=dst_offset=0; total > 0; ) { 4071 struct page *dpage = st_bp->reserved_pages[dst_seg]; 4072 struct page *spage = st_bp->reserved_pages[src_seg]; 4073 4074 count = min(length - dst_offset, length - src_offset); 4075 memmove(page_address(dpage) + dst_offset, 4076 page_address(spage) + src_offset, count); 4077 src_offset += count; 4078 if (src_offset >= length) { 4079 src_seg++; 4080 src_offset = 0; 4081 } 4082 dst_offset += count; 4083 if (dst_offset >= length) { 4084 dst_seg++; 4085 dst_offset = 0; 4086 } 4087 total -= count; 4088 } 4089 } 4090 4091 /* Validate the options from command line or module parameters */ 4092 static void validate_options(void) 4093 { 4094 if (buffer_kbs > 0) 4095 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE; 4096 if (max_sg_segs >= ST_FIRST_SG) 4097 st_max_sg_segs = max_sg_segs; 4098 } 4099 4100 #ifndef MODULE 4101 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt. 4102 */ 4103 static int __init st_setup(char *str) 4104 { 4105 int i, len, ints[5]; 4106 char *stp; 4107 4108 stp = get_options(str, ARRAY_SIZE(ints), ints); 4109 4110 if (ints[0] > 0) { 4111 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++) 4112 if (parms[i].val) 4113 *parms[i].val = ints[i + 1]; 4114 } else { 4115 while (stp != NULL) { 4116 for (i = 0; i < ARRAY_SIZE(parms); i++) { 4117 len = strlen(parms[i].name); 4118 if (!strncmp(stp, parms[i].name, len) && 4119 (*(stp + len) == ':' || *(stp + len) == '=')) { 4120 if (parms[i].val) 4121 *parms[i].val = 4122 simple_strtoul(stp + len + 1, NULL, 0); 4123 else 4124 printk(KERN_WARNING "st: Obsolete parameter %s\n", 4125 parms[i].name); 4126 break; 4127 } 4128 } 4129 if (i >= ARRAY_SIZE(parms)) 4130 printk(KERN_WARNING "st: invalid parameter in '%s'\n", 4131 stp); 4132 stp = strchr(stp, ','); 4133 if (stp) 4134 stp++; 4135 } 4136 } 4137 4138 validate_options(); 4139 4140 return 1; 4141 } 4142 4143 __setup("st=", st_setup); 4144 4145 #endif 4146 4147 static const struct file_operations st_fops = 4148 { 4149 .owner = THIS_MODULE, 4150 .read = st_read, 4151 .write = st_write, 4152 .unlocked_ioctl = st_ioctl, 4153 #ifdef CONFIG_COMPAT 4154 .compat_ioctl = st_compat_ioctl, 4155 #endif 4156 .open = st_open, 4157 .flush = st_flush, 4158 .release = st_release, 4159 .llseek = noop_llseek, 4160 }; 4161 4162 static int create_one_cdev(struct scsi_tape *tape, int mode, int rew) 4163 { 4164 int i, error; 4165 dev_t cdev_devno; 4166 struct cdev *cdev; 4167 struct device *dev; 4168 struct st_modedef *STm = &(tape->modes[mode]); 4169 char name[10]; 4170 int dev_num = tape->index; 4171 4172 cdev_devno = MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, rew)); 4173 4174 cdev = cdev_alloc(); 4175 if (!cdev) { 4176 pr_err("st%d: out of memory. Device not attached.\n", dev_num); 4177 error = -ENOMEM; 4178 goto out; 4179 } 4180 cdev->owner = THIS_MODULE; 4181 cdev->ops = &st_fops; 4182 STm->cdevs[rew] = cdev; 4183 4184 error = cdev_add(cdev, cdev_devno, 1); 4185 if (error) { 4186 pr_err("st%d: Can't add %s-rewind mode %d\n", dev_num, 4187 rew ? "non" : "auto", mode); 4188 pr_err("st%d: Device not attached.\n", dev_num); 4189 goto out_free; 4190 } 4191 4192 i = mode << (4 - ST_NBR_MODE_BITS); 4193 snprintf(name, 10, "%s%s%s", rew ? "n" : "", 4194 tape->name, st_formats[i]); 4195 4196 dev = device_create(&st_sysfs_class, &tape->device->sdev_gendev, 4197 cdev_devno, &tape->modes[mode], "%s", name); 4198 if (IS_ERR(dev)) { 4199 pr_err("st%d: device_create failed\n", dev_num); 4200 error = PTR_ERR(dev); 4201 goto out_free; 4202 } 4203 4204 STm->devs[rew] = dev; 4205 4206 return 0; 4207 out_free: 4208 cdev_del(STm->cdevs[rew]); 4209 out: 4210 STm->cdevs[rew] = NULL; 4211 STm->devs[rew] = NULL; 4212 return error; 4213 } 4214 4215 static int create_cdevs(struct scsi_tape *tape) 4216 { 4217 int mode, error; 4218 for (mode = 0; mode < ST_NBR_MODES; ++mode) { 4219 error = create_one_cdev(tape, mode, 0); 4220 if (error) 4221 return error; 4222 error = create_one_cdev(tape, mode, 1); 4223 if (error) 4224 return error; 4225 } 4226 4227 return sysfs_create_link(&tape->device->sdev_gendev.kobj, 4228 &tape->modes[0].devs[0]->kobj, "tape"); 4229 } 4230 4231 static void remove_cdevs(struct scsi_tape *tape) 4232 { 4233 int mode, rew; 4234 sysfs_remove_link(&tape->device->sdev_gendev.kobj, "tape"); 4235 for (mode = 0; mode < ST_NBR_MODES; mode++) { 4236 struct st_modedef *STm = &(tape->modes[mode]); 4237 for (rew = 0; rew < 2; rew++) { 4238 if (STm->cdevs[rew]) 4239 cdev_del(STm->cdevs[rew]); 4240 if (STm->devs[rew]) 4241 device_unregister(STm->devs[rew]); 4242 } 4243 } 4244 } 4245 4246 static int st_probe(struct device *dev) 4247 { 4248 struct scsi_device *SDp = to_scsi_device(dev); 4249 struct scsi_tape *tpnt = NULL; 4250 struct st_modedef *STm; 4251 struct st_partstat *STps; 4252 struct st_buffer *buffer; 4253 int i, error; 4254 4255 if (SDp->type != TYPE_TAPE) 4256 return -ENODEV; 4257 if (st_incompatible(SDp)) { 4258 sdev_printk(KERN_INFO, SDp, 4259 "OnStream tapes are no longer supported;\n"); 4260 sdev_printk(KERN_INFO, SDp, 4261 "please mail to linux-scsi@vger.kernel.org.\n"); 4262 return -ENODEV; 4263 } 4264 4265 scsi_autopm_get_device(SDp); 4266 i = queue_max_segments(SDp->request_queue); 4267 if (st_max_sg_segs < i) 4268 i = st_max_sg_segs; 4269 buffer = new_tape_buffer(i); 4270 if (buffer == NULL) { 4271 sdev_printk(KERN_ERR, SDp, 4272 "st: Can't allocate new tape buffer. " 4273 "Device not attached.\n"); 4274 goto out; 4275 } 4276 4277 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_KERNEL); 4278 if (tpnt == NULL) { 4279 sdev_printk(KERN_ERR, SDp, 4280 "st: Can't allocate device descriptor.\n"); 4281 goto out_buffer_free; 4282 } 4283 kref_init(&tpnt->kref); 4284 4285 tpnt->device = SDp; 4286 if (SDp->scsi_level <= 2) 4287 tpnt->tape_type = MT_ISSCSI1; 4288 else 4289 tpnt->tape_type = MT_ISSCSI2; 4290 4291 tpnt->buffer = buffer; 4292 tpnt->buffer->last_SRpnt = NULL; 4293 4294 tpnt->inited = 0; 4295 tpnt->dirty = 0; 4296 tpnt->in_use = 0; 4297 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */ 4298 tpnt->use_pf = (SDp->scsi_level >= SCSI_2); 4299 tpnt->density = 0; 4300 tpnt->do_auto_lock = ST_AUTO_LOCK; 4301 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */ 4302 tpnt->can_partitions = 0; 4303 tpnt->two_fm = ST_TWO_FM; 4304 tpnt->fast_mteom = ST_FAST_MTEOM; 4305 tpnt->scsi2_logical = ST_SCSI2LOGICAL; 4306 tpnt->sili = ST_SILI; 4307 tpnt->immediate = ST_NOWAIT; 4308 tpnt->immediate_filemark = 0; 4309 tpnt->default_drvbuffer = 0xff; /* No forced buffering */ 4310 tpnt->partition = 0; 4311 tpnt->new_partition = 0; 4312 tpnt->nbr_partitions = 0; 4313 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT); 4314 tpnt->long_timeout = ST_LONG_TIMEOUT; 4315 tpnt->try_dio = try_direct_io; 4316 4317 for (i = 0; i < ST_NBR_MODES; i++) { 4318 STm = &(tpnt->modes[i]); 4319 STm->defined = 0; 4320 STm->sysv = ST_SYSV; 4321 STm->defaults_for_writes = 0; 4322 STm->do_async_writes = ST_ASYNC_WRITES; 4323 STm->do_buffer_writes = ST_BUFFER_WRITES; 4324 STm->do_read_ahead = ST_READ_AHEAD; 4325 STm->default_compression = ST_DONT_TOUCH; 4326 STm->default_blksize = (-1); /* No forced size */ 4327 STm->default_density = (-1); /* No forced density */ 4328 STm->tape = tpnt; 4329 } 4330 4331 for (i = 0; i < ST_NBR_PARTITIONS; i++) { 4332 STps = &(tpnt->ps[i]); 4333 STps->rw = ST_IDLE; 4334 STps->eof = ST_NOEOF; 4335 STps->at_sm = 0; 4336 STps->last_block_valid = 0; 4337 STps->drv_block = (-1); 4338 STps->drv_file = (-1); 4339 } 4340 4341 tpnt->current_mode = 0; 4342 tpnt->modes[0].defined = 1; 4343 4344 tpnt->density_changed = tpnt->compression_changed = 4345 tpnt->blksize_changed = 0; 4346 mutex_init(&tpnt->lock); 4347 4348 idr_preload(GFP_KERNEL); 4349 spin_lock(&st_index_lock); 4350 error = idr_alloc(&st_index_idr, tpnt, 0, ST_MAX_TAPES + 1, GFP_NOWAIT); 4351 spin_unlock(&st_index_lock); 4352 idr_preload_end(); 4353 if (error < 0) { 4354 pr_warn("st: idr allocation failed: %d\n", error); 4355 goto out_free_tape; 4356 } 4357 tpnt->index = error; 4358 sprintf(tpnt->name, "st%d", tpnt->index); 4359 tpnt->stats = kzalloc(sizeof(struct scsi_tape_stats), GFP_KERNEL); 4360 if (tpnt->stats == NULL) { 4361 sdev_printk(KERN_ERR, SDp, 4362 "st: Can't allocate statistics.\n"); 4363 goto out_idr_remove; 4364 } 4365 4366 dev_set_drvdata(dev, tpnt); 4367 4368 4369 error = create_cdevs(tpnt); 4370 if (error) 4371 goto out_remove_devs; 4372 scsi_autopm_put_device(SDp); 4373 4374 sdev_printk(KERN_NOTICE, SDp, 4375 "Attached scsi tape %s\n", tpnt->name); 4376 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n", 4377 tpnt->name, tpnt->try_dio ? "yes" : "no", 4378 queue_dma_alignment(SDp->request_queue) + 1); 4379 4380 return 0; 4381 4382 out_remove_devs: 4383 remove_cdevs(tpnt); 4384 kfree(tpnt->stats); 4385 out_idr_remove: 4386 spin_lock(&st_index_lock); 4387 idr_remove(&st_index_idr, tpnt->index); 4388 spin_unlock(&st_index_lock); 4389 out_free_tape: 4390 kfree(tpnt); 4391 out_buffer_free: 4392 kfree(buffer); 4393 out: 4394 scsi_autopm_put_device(SDp); 4395 return -ENODEV; 4396 }; 4397 4398 4399 static int st_remove(struct device *dev) 4400 { 4401 struct scsi_tape *tpnt = dev_get_drvdata(dev); 4402 int index = tpnt->index; 4403 4404 scsi_autopm_get_device(to_scsi_device(dev)); 4405 remove_cdevs(tpnt); 4406 4407 mutex_lock(&st_ref_mutex); 4408 kref_put(&tpnt->kref, scsi_tape_release); 4409 mutex_unlock(&st_ref_mutex); 4410 spin_lock(&st_index_lock); 4411 idr_remove(&st_index_idr, index); 4412 spin_unlock(&st_index_lock); 4413 return 0; 4414 } 4415 4416 /** 4417 * scsi_tape_release - Called to free the Scsi_Tape structure 4418 * @kref: pointer to embedded kref 4419 * 4420 * st_ref_mutex must be held entering this routine. Because it is 4421 * called on last put, you should always use the scsi_tape_get() 4422 * scsi_tape_put() helpers which manipulate the semaphore directly 4423 * and never do a direct kref_put(). 4424 **/ 4425 static void scsi_tape_release(struct kref *kref) 4426 { 4427 struct scsi_tape *tpnt = to_scsi_tape(kref); 4428 4429 tpnt->device = NULL; 4430 4431 if (tpnt->buffer) { 4432 normalize_buffer(tpnt->buffer); 4433 kfree(tpnt->buffer->reserved_pages); 4434 kfree(tpnt->buffer); 4435 } 4436 4437 kfree(tpnt->stats); 4438 kfree(tpnt); 4439 return; 4440 } 4441 4442 static struct class st_sysfs_class = { 4443 .name = "scsi_tape", 4444 .dev_groups = st_dev_groups, 4445 }; 4446 4447 static int __init init_st(void) 4448 { 4449 int err; 4450 4451 validate_options(); 4452 4453 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n", 4454 verstr, st_fixed_buffer_size, st_max_sg_segs); 4455 4456 debugging = (debug_flag > 0) ? debug_flag : NO_DEBUG; 4457 if (debugging) { 4458 printk(KERN_INFO "st: Debugging enabled debug_flag = %d\n", 4459 debugging); 4460 } 4461 4462 err = class_register(&st_sysfs_class); 4463 if (err) { 4464 pr_err("Unable register sysfs class for SCSI tapes\n"); 4465 return err; 4466 } 4467 4468 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 4469 ST_MAX_TAPE_ENTRIES, "st"); 4470 if (err) { 4471 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", 4472 SCSI_TAPE_MAJOR); 4473 goto err_class; 4474 } 4475 4476 err = scsi_register_driver(&st_template.gendrv); 4477 if (err) 4478 goto err_chrdev; 4479 4480 return 0; 4481 4482 err_chrdev: 4483 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 4484 ST_MAX_TAPE_ENTRIES); 4485 err_class: 4486 class_unregister(&st_sysfs_class); 4487 return err; 4488 } 4489 4490 static void __exit exit_st(void) 4491 { 4492 scsi_unregister_driver(&st_template.gendrv); 4493 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 4494 ST_MAX_TAPE_ENTRIES); 4495 class_unregister(&st_sysfs_class); 4496 idr_destroy(&st_index_idr); 4497 printk(KERN_INFO "st: Unloaded.\n"); 4498 } 4499 4500 module_init(init_st); 4501 module_exit(exit_st); 4502 4503 4504 /* The sysfs driver interface. Read-only at the moment */ 4505 static ssize_t try_direct_io_show(struct device_driver *ddp, char *buf) 4506 { 4507 return scnprintf(buf, PAGE_SIZE, "%d\n", try_direct_io); 4508 } 4509 static DRIVER_ATTR_RO(try_direct_io); 4510 4511 static ssize_t fixed_buffer_size_show(struct device_driver *ddp, char *buf) 4512 { 4513 return scnprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size); 4514 } 4515 static DRIVER_ATTR_RO(fixed_buffer_size); 4516 4517 static ssize_t max_sg_segs_show(struct device_driver *ddp, char *buf) 4518 { 4519 return scnprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs); 4520 } 4521 static DRIVER_ATTR_RO(max_sg_segs); 4522 4523 static ssize_t version_show(struct device_driver *ddd, char *buf) 4524 { 4525 return scnprintf(buf, PAGE_SIZE, "[%s]\n", verstr); 4526 } 4527 static DRIVER_ATTR_RO(version); 4528 4529 #if DEBUG 4530 static ssize_t debug_flag_store(struct device_driver *ddp, 4531 const char *buf, size_t count) 4532 { 4533 /* We only care what the first byte of the data is the rest is unused. 4534 * if it's a '1' we turn on debug and if it's a '0' we disable it. All 4535 * other values have -EINVAL returned if they are passed in. 4536 */ 4537 if (count > 0) { 4538 if (buf[0] == '0') { 4539 debugging = NO_DEBUG; 4540 return count; 4541 } else if (buf[0] == '1') { 4542 debugging = 1; 4543 return count; 4544 } 4545 } 4546 return -EINVAL; 4547 } 4548 4549 static ssize_t debug_flag_show(struct device_driver *ddp, char *buf) 4550 { 4551 return scnprintf(buf, PAGE_SIZE, "%d\n", debugging); 4552 } 4553 static DRIVER_ATTR_RW(debug_flag); 4554 #endif 4555 4556 static struct attribute *st_drv_attrs[] = { 4557 &driver_attr_try_direct_io.attr, 4558 &driver_attr_fixed_buffer_size.attr, 4559 &driver_attr_max_sg_segs.attr, 4560 &driver_attr_version.attr, 4561 #if DEBUG 4562 &driver_attr_debug_flag.attr, 4563 #endif 4564 NULL, 4565 }; 4566 ATTRIBUTE_GROUPS(st_drv); 4567 4568 /* The sysfs simple class interface */ 4569 static ssize_t 4570 defined_show(struct device *dev, struct device_attribute *attr, char *buf) 4571 { 4572 struct st_modedef *STm = dev_get_drvdata(dev); 4573 ssize_t l = 0; 4574 4575 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined); 4576 return l; 4577 } 4578 static DEVICE_ATTR_RO(defined); 4579 4580 static ssize_t 4581 default_blksize_show(struct device *dev, struct device_attribute *attr, 4582 char *buf) 4583 { 4584 struct st_modedef *STm = dev_get_drvdata(dev); 4585 ssize_t l = 0; 4586 4587 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize); 4588 return l; 4589 } 4590 static DEVICE_ATTR_RO(default_blksize); 4591 4592 static ssize_t 4593 default_density_show(struct device *dev, struct device_attribute *attr, 4594 char *buf) 4595 { 4596 struct st_modedef *STm = dev_get_drvdata(dev); 4597 ssize_t l = 0; 4598 char *fmt; 4599 4600 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n"; 4601 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density); 4602 return l; 4603 } 4604 static DEVICE_ATTR_RO(default_density); 4605 4606 static ssize_t 4607 default_compression_show(struct device *dev, struct device_attribute *attr, 4608 char *buf) 4609 { 4610 struct st_modedef *STm = dev_get_drvdata(dev); 4611 ssize_t l = 0; 4612 4613 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1); 4614 return l; 4615 } 4616 static DEVICE_ATTR_RO(default_compression); 4617 4618 static ssize_t 4619 options_show(struct device *dev, struct device_attribute *attr, char *buf) 4620 { 4621 struct st_modedef *STm = dev_get_drvdata(dev); 4622 struct scsi_tape *STp = STm->tape; 4623 int options; 4624 ssize_t l = 0; 4625 4626 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0; 4627 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0; 4628 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0; 4629 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 ); 4630 options |= STp->two_fm ? MT_ST_TWO_FM : 0; 4631 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0; 4632 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0; 4633 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0; 4634 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0; 4635 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0; 4636 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0; 4637 options |= STm->sysv ? MT_ST_SYSV : 0; 4638 options |= STp->immediate ? MT_ST_NOWAIT : 0; 4639 options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0; 4640 options |= STp->sili ? MT_ST_SILI : 0; 4641 4642 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options); 4643 return l; 4644 } 4645 static DEVICE_ATTR_RO(options); 4646 4647 /* Support for tape stats */ 4648 4649 /** 4650 * read_cnt_show - return read count - count of reads made from tape drive 4651 * @dev: struct device 4652 * @attr: attribute structure 4653 * @buf: buffer to return formatted data in 4654 */ 4655 static ssize_t read_cnt_show(struct device *dev, 4656 struct device_attribute *attr, char *buf) 4657 { 4658 struct st_modedef *STm = dev_get_drvdata(dev); 4659 4660 return sprintf(buf, "%lld", 4661 (long long)atomic64_read(&STm->tape->stats->read_cnt)); 4662 } 4663 static DEVICE_ATTR_RO(read_cnt); 4664 4665 /** 4666 * read_byte_cnt_show - return read byte count - tape drives 4667 * may use blocks less than 512 bytes this gives the raw byte count of 4668 * of data read from the tape drive. 4669 * @dev: struct device 4670 * @attr: attribute structure 4671 * @buf: buffer to return formatted data in 4672 */ 4673 static ssize_t read_byte_cnt_show(struct device *dev, 4674 struct device_attribute *attr, char *buf) 4675 { 4676 struct st_modedef *STm = dev_get_drvdata(dev); 4677 4678 return sprintf(buf, "%lld", 4679 (long long)atomic64_read(&STm->tape->stats->read_byte_cnt)); 4680 } 4681 static DEVICE_ATTR_RO(read_byte_cnt); 4682 4683 /** 4684 * read_ns_show - return read ns - overall time spent waiting on reads in ns. 4685 * @dev: struct device 4686 * @attr: attribute structure 4687 * @buf: buffer to return formatted data in 4688 */ 4689 static ssize_t read_ns_show(struct device *dev, 4690 struct device_attribute *attr, char *buf) 4691 { 4692 struct st_modedef *STm = dev_get_drvdata(dev); 4693 4694 return sprintf(buf, "%lld", 4695 (long long)atomic64_read(&STm->tape->stats->tot_read_time)); 4696 } 4697 static DEVICE_ATTR_RO(read_ns); 4698 4699 /** 4700 * write_cnt_show - write count - number of user calls 4701 * to write(2) that have written data to tape. 4702 * @dev: struct device 4703 * @attr: attribute structure 4704 * @buf: buffer to return formatted data in 4705 */ 4706 static ssize_t write_cnt_show(struct device *dev, 4707 struct device_attribute *attr, char *buf) 4708 { 4709 struct st_modedef *STm = dev_get_drvdata(dev); 4710 4711 return sprintf(buf, "%lld", 4712 (long long)atomic64_read(&STm->tape->stats->write_cnt)); 4713 } 4714 static DEVICE_ATTR_RO(write_cnt); 4715 4716 /** 4717 * write_byte_cnt_show - write byte count - raw count of 4718 * bytes written to tape. 4719 * @dev: struct device 4720 * @attr: attribute structure 4721 * @buf: buffer to return formatted data in 4722 */ 4723 static ssize_t write_byte_cnt_show(struct device *dev, 4724 struct device_attribute *attr, char *buf) 4725 { 4726 struct st_modedef *STm = dev_get_drvdata(dev); 4727 4728 return sprintf(buf, "%lld", 4729 (long long)atomic64_read(&STm->tape->stats->write_byte_cnt)); 4730 } 4731 static DEVICE_ATTR_RO(write_byte_cnt); 4732 4733 /** 4734 * write_ns_show - write ns - number of nanoseconds waiting on write 4735 * requests to complete. 4736 * @dev: struct device 4737 * @attr: attribute structure 4738 * @buf: buffer to return formatted data in 4739 */ 4740 static ssize_t write_ns_show(struct device *dev, 4741 struct device_attribute *attr, char *buf) 4742 { 4743 struct st_modedef *STm = dev_get_drvdata(dev); 4744 4745 return sprintf(buf, "%lld", 4746 (long long)atomic64_read(&STm->tape->stats->tot_write_time)); 4747 } 4748 static DEVICE_ATTR_RO(write_ns); 4749 4750 /** 4751 * in_flight_show - number of I/Os currently in flight - 4752 * in most cases this will be either 0 or 1. It may be higher if someone 4753 * has also issued other SCSI commands such as via an ioctl. 4754 * @dev: struct device 4755 * @attr: attribute structure 4756 * @buf: buffer to return formatted data in 4757 */ 4758 static ssize_t in_flight_show(struct device *dev, 4759 struct device_attribute *attr, char *buf) 4760 { 4761 struct st_modedef *STm = dev_get_drvdata(dev); 4762 4763 return sprintf(buf, "%lld", 4764 (long long)atomic64_read(&STm->tape->stats->in_flight)); 4765 } 4766 static DEVICE_ATTR_RO(in_flight); 4767 4768 /** 4769 * io_ns_show - io wait ns - this is the number of ns spent 4770 * waiting on all I/O to complete. This includes tape movement commands 4771 * such as rewinding, seeking to end of file or tape, it also includes 4772 * read and write. To determine the time spent on tape movement 4773 * subtract the read and write ns from this value. 4774 * @dev: struct device 4775 * @attr: attribute structure 4776 * @buf: buffer to return formatted data in 4777 */ 4778 static ssize_t io_ns_show(struct device *dev, 4779 struct device_attribute *attr, char *buf) 4780 { 4781 struct st_modedef *STm = dev_get_drvdata(dev); 4782 4783 return sprintf(buf, "%lld", 4784 (long long)atomic64_read(&STm->tape->stats->tot_io_time)); 4785 } 4786 static DEVICE_ATTR_RO(io_ns); 4787 4788 /** 4789 * other_cnt_show - other io count - this is the number of 4790 * I/O requests other than read and write requests. 4791 * Typically these are tape movement requests but will include driver 4792 * tape movement. This includes only requests issued by the st driver. 4793 * @dev: struct device 4794 * @attr: attribute structure 4795 * @buf: buffer to return formatted data in 4796 */ 4797 static ssize_t other_cnt_show(struct device *dev, 4798 struct device_attribute *attr, char *buf) 4799 { 4800 struct st_modedef *STm = dev_get_drvdata(dev); 4801 4802 return sprintf(buf, "%lld", 4803 (long long)atomic64_read(&STm->tape->stats->other_cnt)); 4804 } 4805 static DEVICE_ATTR_RO(other_cnt); 4806 4807 /** 4808 * resid_cnt_show - A count of the number of times we get a residual 4809 * count - this should indicate someone issuing reads larger than the 4810 * block size on tape. 4811 * @dev: struct device 4812 * @attr: attribute structure 4813 * @buf: buffer to return formatted data in 4814 */ 4815 static ssize_t resid_cnt_show(struct device *dev, 4816 struct device_attribute *attr, char *buf) 4817 { 4818 struct st_modedef *STm = dev_get_drvdata(dev); 4819 4820 return sprintf(buf, "%lld", 4821 (long long)atomic64_read(&STm->tape->stats->resid_cnt)); 4822 } 4823 static DEVICE_ATTR_RO(resid_cnt); 4824 4825 static struct attribute *st_dev_attrs[] = { 4826 &dev_attr_defined.attr, 4827 &dev_attr_default_blksize.attr, 4828 &dev_attr_default_density.attr, 4829 &dev_attr_default_compression.attr, 4830 &dev_attr_options.attr, 4831 NULL, 4832 }; 4833 4834 static struct attribute *st_stats_attrs[] = { 4835 &dev_attr_read_cnt.attr, 4836 &dev_attr_read_byte_cnt.attr, 4837 &dev_attr_read_ns.attr, 4838 &dev_attr_write_cnt.attr, 4839 &dev_attr_write_byte_cnt.attr, 4840 &dev_attr_write_ns.attr, 4841 &dev_attr_in_flight.attr, 4842 &dev_attr_io_ns.attr, 4843 &dev_attr_other_cnt.attr, 4844 &dev_attr_resid_cnt.attr, 4845 NULL, 4846 }; 4847 4848 static struct attribute_group stats_group = { 4849 .name = "stats", 4850 .attrs = st_stats_attrs, 4851 }; 4852 4853 static struct attribute_group st_group = { 4854 .attrs = st_dev_attrs, 4855 }; 4856 4857 static const struct attribute_group *st_dev_groups[] = { 4858 &st_group, 4859 &stats_group, 4860 NULL, 4861 }; 4862 4863 /* The following functions may be useful for a larger audience. */ 4864 static int sgl_map_user_pages(struct st_buffer *STbp, 4865 const unsigned int max_pages, unsigned long uaddr, 4866 size_t count, int rw) 4867 { 4868 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT; 4869 unsigned long start = uaddr >> PAGE_SHIFT; 4870 const int nr_pages = end - start; 4871 int res, i; 4872 struct page **pages; 4873 struct rq_map_data *mdata = &STbp->map_data; 4874 4875 /* User attempted Overflow! */ 4876 if ((uaddr + count) < uaddr) 4877 return -EINVAL; 4878 4879 /* Too big */ 4880 if (nr_pages > max_pages) 4881 return -ENOMEM; 4882 4883 /* Hmm? */ 4884 if (count == 0) 4885 return 0; 4886 4887 pages = kmalloc_array(max_pages, sizeof(*pages), GFP_KERNEL); 4888 if (pages == NULL) 4889 return -ENOMEM; 4890 4891 /* Try to fault in all of the necessary pages */ 4892 /* rw==READ means read from drive, write into memory area */ 4893 res = pin_user_pages_fast(uaddr, nr_pages, rw == READ ? FOLL_WRITE : 0, 4894 pages); 4895 4896 /* Errors and no page mapped should return here */ 4897 if (res < nr_pages) 4898 goto out_unmap; 4899 4900 for (i=0; i < nr_pages; i++) { 4901 /* FIXME: flush superflous for rw==READ, 4902 * probably wrong function for rw==WRITE 4903 */ 4904 flush_dcache_page(pages[i]); 4905 } 4906 4907 mdata->offset = uaddr & ~PAGE_MASK; 4908 STbp->mapped_pages = pages; 4909 4910 return nr_pages; 4911 out_unmap: 4912 if (res > 0) { 4913 unpin_user_pages(pages, res); 4914 res = 0; 4915 } 4916 kfree(pages); 4917 return res; 4918 } 4919 4920 4921 /* And unmap them... */ 4922 static int sgl_unmap_user_pages(struct st_buffer *STbp, 4923 const unsigned int nr_pages, int dirtied) 4924 { 4925 /* FIXME: cache flush missing for rw==READ */ 4926 unpin_user_pages_dirty_lock(STbp->mapped_pages, nr_pages, dirtied); 4927 4928 kfree(STbp->mapped_pages); 4929 STbp->mapped_pages = NULL; 4930 4931 return 0; 4932 } 4933