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