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