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