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