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