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