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