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