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