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