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_common(struct file *file, unsigned int cmd_in, void __user *p) 3498 { 3499 int i, cmd_nr, cmd_type, bt; 3500 int retval = 0; 3501 unsigned int blk; 3502 struct scsi_tape *STp = file->private_data; 3503 struct st_modedef *STm; 3504 struct st_partstat *STps; 3505 3506 if (mutex_lock_interruptible(&STp->lock)) 3507 return -ERESTARTSYS; 3508 3509 DEB( 3510 if (debugging && !STp->in_use) { 3511 st_printk(ST_DEB_MSG, STp, "Incorrect device.\n"); 3512 retval = (-EIO); 3513 goto out; 3514 } ) /* end DEB */ 3515 3516 STm = &(STp->modes[STp->current_mode]); 3517 STps = &(STp->ps[STp->partition]); 3518 3519 /* 3520 * If we are in the middle of error recovery, don't let anyone 3521 * else try and use this device. Also, if error recovery fails, it 3522 * may try and take the device offline, in which case all further 3523 * access to the device is prohibited. 3524 */ 3525 retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in, 3526 file->f_flags & O_NDELAY); 3527 if (retval) 3528 goto out; 3529 3530 cmd_type = _IOC_TYPE(cmd_in); 3531 cmd_nr = _IOC_NR(cmd_in); 3532 3533 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) { 3534 struct mtop mtc; 3535 3536 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) { 3537 retval = (-EINVAL); 3538 goto out; 3539 } 3540 3541 i = copy_from_user(&mtc, p, sizeof(struct mtop)); 3542 if (i) { 3543 retval = (-EFAULT); 3544 goto out; 3545 } 3546 3547 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) { 3548 st_printk(KERN_WARNING, STp, 3549 "MTSETDRVBUFFER only allowed for root.\n"); 3550 retval = (-EPERM); 3551 goto out; 3552 } 3553 if (!STm->defined && 3554 (mtc.mt_op != MTSETDRVBUFFER && 3555 (mtc.mt_count & MT_ST_OPTIONS) == 0)) { 3556 retval = (-ENXIO); 3557 goto out; 3558 } 3559 3560 if (!STp->pos_unknown) { 3561 3562 if (STps->eof == ST_FM_HIT) { 3563 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 3564 mtc.mt_op == MTEOM) { 3565 mtc.mt_count -= 1; 3566 if (STps->drv_file >= 0) 3567 STps->drv_file += 1; 3568 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) { 3569 mtc.mt_count += 1; 3570 if (STps->drv_file >= 0) 3571 STps->drv_file += 1; 3572 } 3573 } 3574 3575 if (mtc.mt_op == MTSEEK) { 3576 /* Old position must be restored if partition will be 3577 changed */ 3578 i = !STp->can_partitions || 3579 (STp->new_partition != STp->partition); 3580 } else { 3581 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 3582 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM || 3583 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD || 3584 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 3585 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM || 3586 mtc.mt_op == MTCOMPRESSION; 3587 } 3588 i = flush_buffer(STp, i); 3589 if (i < 0) { 3590 retval = i; 3591 goto out; 3592 } 3593 if (STps->rw == ST_WRITING && 3594 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 3595 mtc.mt_op == MTSEEK || 3596 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) { 3597 i = st_int_ioctl(STp, MTWEOF, 1); 3598 if (i < 0) { 3599 retval = i; 3600 goto out; 3601 } 3602 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) 3603 mtc.mt_count++; 3604 STps->rw = ST_IDLE; 3605 } 3606 3607 } else { 3608 /* 3609 * If there was a bus reset, block further access 3610 * to this device. If the user wants to rewind the tape, 3611 * then reset the flag and allow access again. 3612 */ 3613 if (mtc.mt_op != MTREW && 3614 mtc.mt_op != MTOFFL && 3615 mtc.mt_op != MTRETEN && 3616 mtc.mt_op != MTERASE && 3617 mtc.mt_op != MTSEEK && 3618 mtc.mt_op != MTEOM) { 3619 retval = (-EIO); 3620 goto out; 3621 } 3622 reset_state(STp); 3623 /* remove this when the midlevel properly clears was_reset */ 3624 STp->device->was_reset = 0; 3625 } 3626 3627 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK && 3628 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM && 3629 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART) 3630 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */ 3631 3632 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED) 3633 do_door_lock(STp, 0); /* Ignore result! */ 3634 3635 if (mtc.mt_op == MTSETDRVBUFFER && 3636 (mtc.mt_count & MT_ST_OPTIONS) != 0) { 3637 retval = st_set_options(STp, mtc.mt_count); 3638 goto out; 3639 } 3640 3641 if (mtc.mt_op == MTSETPART) { 3642 if (!STp->can_partitions || 3643 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) { 3644 retval = (-EINVAL); 3645 goto out; 3646 } 3647 if (mtc.mt_count >= STp->nbr_partitions && 3648 (STp->nbr_partitions = nbr_partitions(STp)) < 0) { 3649 retval = (-EIO); 3650 goto out; 3651 } 3652 if (mtc.mt_count >= STp->nbr_partitions) { 3653 retval = (-EINVAL); 3654 goto out; 3655 } 3656 STp->new_partition = mtc.mt_count; 3657 retval = 0; 3658 goto out; 3659 } 3660 3661 if (mtc.mt_op == MTMKPART) { 3662 if (!STp->can_partitions) { 3663 retval = (-EINVAL); 3664 goto out; 3665 } 3666 i = do_load_unload(STp, file, 1); 3667 if (i < 0) { 3668 retval = i; 3669 goto out; 3670 } 3671 i = partition_tape(STp, mtc.mt_count); 3672 if (i < 0) { 3673 retval = i; 3674 goto out; 3675 } 3676 for (i = 0; i < ST_NBR_PARTITIONS; i++) { 3677 STp->ps[i].rw = ST_IDLE; 3678 STp->ps[i].at_sm = 0; 3679 STp->ps[i].last_block_valid = 0; 3680 } 3681 STp->partition = STp->new_partition = 0; 3682 STp->nbr_partitions = mtc.mt_count != 0 ? 2 : 1; 3683 STps->drv_block = STps->drv_file = 0; 3684 retval = 0; 3685 goto out; 3686 } 3687 3688 if (mtc.mt_op == MTSEEK) { 3689 i = set_location(STp, mtc.mt_count, STp->new_partition, 0); 3690 if (!STp->can_partitions) 3691 STp->ps[0].rw = ST_IDLE; 3692 retval = i; 3693 goto out; 3694 } 3695 3696 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) { 3697 retval = do_load_unload(STp, file, 0); 3698 goto out; 3699 } 3700 3701 if (mtc.mt_op == MTLOAD) { 3702 retval = do_load_unload(STp, file, max(1, mtc.mt_count)); 3703 goto out; 3704 } 3705 3706 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) { 3707 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK)); 3708 goto out; 3709 } 3710 3711 if (STp->can_partitions && STp->ready == ST_READY && 3712 (i = switch_partition(STp)) < 0) { 3713 retval = i; 3714 goto out; 3715 } 3716 3717 if (mtc.mt_op == MTCOMPRESSION) 3718 retval = st_compression(STp, (mtc.mt_count & 1)); 3719 else 3720 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count); 3721 goto out; 3722 } 3723 if (!STm->defined) { 3724 retval = (-ENXIO); 3725 goto out; 3726 } 3727 3728 if ((i = flush_buffer(STp, 0)) < 0) { 3729 retval = i; 3730 goto out; 3731 } 3732 if (STp->can_partitions && 3733 (i = switch_partition(STp)) < 0) { 3734 retval = i; 3735 goto out; 3736 } 3737 3738 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) { 3739 struct mtget mt_status; 3740 3741 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) { 3742 retval = (-EINVAL); 3743 goto out; 3744 } 3745 3746 mt_status.mt_type = STp->tape_type; 3747 mt_status.mt_dsreg = 3748 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | 3749 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK); 3750 mt_status.mt_blkno = STps->drv_block; 3751 mt_status.mt_fileno = STps->drv_file; 3752 if (STp->block_size != 0) { 3753 if (STps->rw == ST_WRITING) 3754 mt_status.mt_blkno += 3755 (STp->buffer)->buffer_bytes / STp->block_size; 3756 else if (STps->rw == ST_READING) 3757 mt_status.mt_blkno -= 3758 ((STp->buffer)->buffer_bytes + 3759 STp->block_size - 1) / STp->block_size; 3760 } 3761 3762 mt_status.mt_gstat = 0; 3763 if (STp->drv_write_prot) 3764 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff); 3765 if (mt_status.mt_blkno == 0) { 3766 if (mt_status.mt_fileno == 0) 3767 mt_status.mt_gstat |= GMT_BOT(0xffffffff); 3768 else 3769 mt_status.mt_gstat |= GMT_EOF(0xffffffff); 3770 } 3771 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT); 3772 mt_status.mt_resid = STp->partition; 3773 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR) 3774 mt_status.mt_gstat |= GMT_EOT(0xffffffff); 3775 else if (STps->eof >= ST_EOM_OK) 3776 mt_status.mt_gstat |= GMT_EOD(0xffffffff); 3777 if (STp->density == 1) 3778 mt_status.mt_gstat |= GMT_D_800(0xffffffff); 3779 else if (STp->density == 2) 3780 mt_status.mt_gstat |= GMT_D_1600(0xffffffff); 3781 else if (STp->density == 3) 3782 mt_status.mt_gstat |= GMT_D_6250(0xffffffff); 3783 if (STp->ready == ST_READY) 3784 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff); 3785 if (STp->ready == ST_NO_TAPE) 3786 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff); 3787 if (STps->at_sm) 3788 mt_status.mt_gstat |= GMT_SM(0xffffffff); 3789 if (STm->do_async_writes || 3790 (STm->do_buffer_writes && STp->block_size != 0) || 3791 STp->drv_buffer != 0) 3792 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff); 3793 if (STp->cleaning_req) 3794 mt_status.mt_gstat |= GMT_CLN(0xffffffff); 3795 3796 retval = put_user_mtget(p, &mt_status); 3797 if (retval) 3798 goto out; 3799 3800 STp->recover_reg = 0; /* Clear after read */ 3801 goto out; 3802 } /* End of MTIOCGET */ 3803 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) { 3804 struct mtpos mt_pos; 3805 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) { 3806 retval = (-EINVAL); 3807 goto out; 3808 } 3809 if ((i = get_location(STp, &blk, &bt, 0)) < 0) { 3810 retval = i; 3811 goto out; 3812 } 3813 mt_pos.mt_blkno = blk; 3814 retval = put_user_mtpos(p, &mt_pos); 3815 goto out; 3816 } 3817 mutex_unlock(&STp->lock); 3818 switch (cmd_in) { 3819 case SCSI_IOCTL_STOP_UNIT: 3820 /* unload */ 3821 retval = scsi_ioctl(STp->device, cmd_in, p); 3822 if (!retval) { 3823 STp->rew_at_close = 0; 3824 STp->ready = ST_NO_TAPE; 3825 } 3826 return retval; 3827 3828 case SCSI_IOCTL_GET_IDLUN: 3829 case SCSI_IOCTL_GET_BUS_NUMBER: 3830 break; 3831 3832 default: 3833 if ((cmd_in == SG_IO || 3834 cmd_in == SCSI_IOCTL_SEND_COMMAND || 3835 cmd_in == CDROM_SEND_PACKET) && 3836 !capable(CAP_SYS_RAWIO)) 3837 i = -EPERM; 3838 else 3839 i = scsi_cmd_ioctl(STp->device->request_queue, 3840 NULL, file->f_mode, cmd_in, 3841 p); 3842 if (i != -ENOTTY) 3843 return i; 3844 break; 3845 } 3846 return -ENOTTY; 3847 3848 out: 3849 mutex_unlock(&STp->lock); 3850 return retval; 3851 } 3852 3853 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) 3854 { 3855 void __user *p = (void __user *)arg; 3856 struct scsi_tape *STp = file->private_data; 3857 int ret; 3858 3859 ret = st_ioctl_common(file, cmd_in, p); 3860 if (ret != -ENOTTY) 3861 return ret; 3862 3863 return scsi_ioctl(STp->device, cmd_in, p); 3864 } 3865 3866 #ifdef CONFIG_COMPAT 3867 static long st_compat_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) 3868 { 3869 void __user *p = compat_ptr(arg); 3870 struct scsi_tape *STp = file->private_data; 3871 int ret; 3872 3873 /* argument conversion is handled using put_user_mtpos/put_user_mtget */ 3874 switch (cmd_in) { 3875 case MTIOCPOS32: 3876 return st_ioctl_common(file, MTIOCPOS, p); 3877 case MTIOCGET32: 3878 return st_ioctl_common(file, MTIOCGET, p); 3879 } 3880 3881 ret = st_ioctl_common(file, cmd_in, p); 3882 if (ret != -ENOTTY) 3883 return ret; 3884 3885 return scsi_compat_ioctl(STp->device, cmd_in, p); 3886 } 3887 #endif 3888 3889 3890 3891 /* Try to allocate a new tape buffer. Calling function must not hold 3892 dev_arr_lock. */ 3893 static struct st_buffer *new_tape_buffer(int max_sg) 3894 { 3895 struct st_buffer *tb; 3896 3897 tb = kzalloc(sizeof(struct st_buffer), GFP_KERNEL); 3898 if (!tb) { 3899 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n"); 3900 return NULL; 3901 } 3902 tb->frp_segs = 0; 3903 tb->use_sg = max_sg; 3904 tb->buffer_size = 0; 3905 3906 tb->reserved_pages = kcalloc(max_sg, sizeof(struct page *), 3907 GFP_KERNEL); 3908 if (!tb->reserved_pages) { 3909 kfree(tb); 3910 return NULL; 3911 } 3912 3913 return tb; 3914 } 3915 3916 3917 /* Try to allocate enough space in the tape buffer */ 3918 #define ST_MAX_ORDER 6 3919 3920 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size) 3921 { 3922 int segs, max_segs, b_size, order, got; 3923 gfp_t priority; 3924 3925 if (new_size <= STbuffer->buffer_size) 3926 return 1; 3927 3928 if (STbuffer->buffer_size <= PAGE_SIZE) 3929 normalize_buffer(STbuffer); /* Avoid extra segment */ 3930 3931 max_segs = STbuffer->use_sg; 3932 3933 priority = GFP_KERNEL | __GFP_NOWARN; 3934 3935 if (STbuffer->cleared) 3936 priority |= __GFP_ZERO; 3937 3938 if (STbuffer->frp_segs) { 3939 order = STbuffer->reserved_page_order; 3940 b_size = PAGE_SIZE << order; 3941 } else { 3942 for (b_size = PAGE_SIZE, order = 0; 3943 order < ST_MAX_ORDER && 3944 max_segs * (PAGE_SIZE << order) < new_size; 3945 order++, b_size *= 2) 3946 ; /* empty */ 3947 STbuffer->reserved_page_order = order; 3948 } 3949 if (max_segs * (PAGE_SIZE << order) < new_size) { 3950 if (order == ST_MAX_ORDER) 3951 return 0; 3952 normalize_buffer(STbuffer); 3953 return enlarge_buffer(STbuffer, new_size); 3954 } 3955 3956 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size; 3957 segs < max_segs && got < new_size;) { 3958 struct page *page; 3959 3960 page = alloc_pages(priority, order); 3961 if (!page) { 3962 DEB(STbuffer->buffer_size = got); 3963 normalize_buffer(STbuffer); 3964 return 0; 3965 } 3966 3967 STbuffer->frp_segs += 1; 3968 got += b_size; 3969 STbuffer->buffer_size = got; 3970 STbuffer->reserved_pages[segs] = page; 3971 segs++; 3972 } 3973 STbuffer->b_data = page_address(STbuffer->reserved_pages[0]); 3974 3975 return 1; 3976 } 3977 3978 3979 /* Make sure that no data from previous user is in the internal buffer */ 3980 static void clear_buffer(struct st_buffer * st_bp) 3981 { 3982 int i; 3983 3984 for (i=0; i < st_bp->frp_segs; i++) 3985 memset(page_address(st_bp->reserved_pages[i]), 0, 3986 PAGE_SIZE << st_bp->reserved_page_order); 3987 st_bp->cleared = 1; 3988 } 3989 3990 3991 /* Release the extra buffer */ 3992 static void normalize_buffer(struct st_buffer * STbuffer) 3993 { 3994 int i, order = STbuffer->reserved_page_order; 3995 3996 for (i = 0; i < STbuffer->frp_segs; i++) { 3997 __free_pages(STbuffer->reserved_pages[i], order); 3998 STbuffer->buffer_size -= (PAGE_SIZE << order); 3999 } 4000 STbuffer->frp_segs = 0; 4001 STbuffer->sg_segs = 0; 4002 STbuffer->reserved_page_order = 0; 4003 STbuffer->map_data.offset = 0; 4004 } 4005 4006 4007 /* Move data from the user buffer to the tape buffer. Returns zero (success) or 4008 negative error code. */ 4009 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count) 4010 { 4011 int i, cnt, res, offset; 4012 int length = PAGE_SIZE << st_bp->reserved_page_order; 4013 4014 for (i = 0, offset = st_bp->buffer_bytes; 4015 i < st_bp->frp_segs && offset >= length; i++) 4016 offset -= length; 4017 if (i == st_bp->frp_segs) { /* Should never happen */ 4018 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n"); 4019 return (-EIO); 4020 } 4021 for (; i < st_bp->frp_segs && do_count > 0; i++) { 4022 struct page *page = st_bp->reserved_pages[i]; 4023 cnt = length - offset < do_count ? length - offset : do_count; 4024 res = copy_from_user(page_address(page) + offset, ubp, cnt); 4025 if (res) 4026 return (-EFAULT); 4027 do_count -= cnt; 4028 st_bp->buffer_bytes += cnt; 4029 ubp += cnt; 4030 offset = 0; 4031 } 4032 if (do_count) /* Should never happen */ 4033 return (-EIO); 4034 4035 return 0; 4036 } 4037 4038 4039 /* Move data from the tape buffer to the user buffer. Returns zero (success) or 4040 negative error code. */ 4041 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count) 4042 { 4043 int i, cnt, res, offset; 4044 int length = PAGE_SIZE << st_bp->reserved_page_order; 4045 4046 for (i = 0, offset = st_bp->read_pointer; 4047 i < st_bp->frp_segs && offset >= length; i++) 4048 offset -= length; 4049 if (i == st_bp->frp_segs) { /* Should never happen */ 4050 printk(KERN_WARNING "st: from_buffer offset overflow.\n"); 4051 return (-EIO); 4052 } 4053 for (; i < st_bp->frp_segs && do_count > 0; i++) { 4054 struct page *page = st_bp->reserved_pages[i]; 4055 cnt = length - offset < do_count ? length - offset : do_count; 4056 res = copy_to_user(ubp, page_address(page) + offset, cnt); 4057 if (res) 4058 return (-EFAULT); 4059 do_count -= cnt; 4060 st_bp->buffer_bytes -= cnt; 4061 st_bp->read_pointer += cnt; 4062 ubp += cnt; 4063 offset = 0; 4064 } 4065 if (do_count) /* Should never happen */ 4066 return (-EIO); 4067 4068 return 0; 4069 } 4070 4071 4072 /* Move data towards start of buffer */ 4073 static void move_buffer_data(struct st_buffer * st_bp, int offset) 4074 { 4075 int src_seg, dst_seg, src_offset = 0, dst_offset; 4076 int count, total; 4077 int length = PAGE_SIZE << st_bp->reserved_page_order; 4078 4079 if (offset == 0) 4080 return; 4081 4082 total=st_bp->buffer_bytes - offset; 4083 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) { 4084 src_offset = offset; 4085 if (src_offset < length) 4086 break; 4087 offset -= length; 4088 } 4089 4090 st_bp->buffer_bytes = st_bp->read_pointer = total; 4091 for (dst_seg=dst_offset=0; total > 0; ) { 4092 struct page *dpage = st_bp->reserved_pages[dst_seg]; 4093 struct page *spage = st_bp->reserved_pages[src_seg]; 4094 4095 count = min(length - dst_offset, length - src_offset); 4096 memmove(page_address(dpage) + dst_offset, 4097 page_address(spage) + src_offset, count); 4098 src_offset += count; 4099 if (src_offset >= length) { 4100 src_seg++; 4101 src_offset = 0; 4102 } 4103 dst_offset += count; 4104 if (dst_offset >= length) { 4105 dst_seg++; 4106 dst_offset = 0; 4107 } 4108 total -= count; 4109 } 4110 } 4111 4112 /* Validate the options from command line or module parameters */ 4113 static void validate_options(void) 4114 { 4115 if (buffer_kbs > 0) 4116 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE; 4117 if (max_sg_segs >= ST_FIRST_SG) 4118 st_max_sg_segs = max_sg_segs; 4119 } 4120 4121 #ifndef MODULE 4122 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt. 4123 */ 4124 static int __init st_setup(char *str) 4125 { 4126 int i, len, ints[5]; 4127 char *stp; 4128 4129 stp = get_options(str, ARRAY_SIZE(ints), ints); 4130 4131 if (ints[0] > 0) { 4132 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++) 4133 if (parms[i].val) 4134 *parms[i].val = ints[i + 1]; 4135 } else { 4136 while (stp != NULL) { 4137 for (i = 0; i < ARRAY_SIZE(parms); i++) { 4138 len = strlen(parms[i].name); 4139 if (!strncmp(stp, parms[i].name, len) && 4140 (*(stp + len) == ':' || *(stp + len) == '=')) { 4141 if (parms[i].val) 4142 *parms[i].val = 4143 simple_strtoul(stp + len + 1, NULL, 0); 4144 else 4145 printk(KERN_WARNING "st: Obsolete parameter %s\n", 4146 parms[i].name); 4147 break; 4148 } 4149 } 4150 if (i >= ARRAY_SIZE(parms)) 4151 printk(KERN_WARNING "st: invalid parameter in '%s'\n", 4152 stp); 4153 stp = strchr(stp, ','); 4154 if (stp) 4155 stp++; 4156 } 4157 } 4158 4159 validate_options(); 4160 4161 return 1; 4162 } 4163 4164 __setup("st=", st_setup); 4165 4166 #endif 4167 4168 static const struct file_operations st_fops = 4169 { 4170 .owner = THIS_MODULE, 4171 .read = st_read, 4172 .write = st_write, 4173 .unlocked_ioctl = st_ioctl, 4174 #ifdef CONFIG_COMPAT 4175 .compat_ioctl = st_compat_ioctl, 4176 #endif 4177 .open = st_open, 4178 .flush = st_flush, 4179 .release = st_release, 4180 .llseek = noop_llseek, 4181 }; 4182 4183 static int create_one_cdev(struct scsi_tape *tape, int mode, int rew) 4184 { 4185 int i, error; 4186 dev_t cdev_devno; 4187 struct cdev *cdev; 4188 struct device *dev; 4189 struct st_modedef *STm = &(tape->modes[mode]); 4190 char name[10]; 4191 int dev_num = tape->index; 4192 4193 cdev_devno = MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, rew)); 4194 4195 cdev = cdev_alloc(); 4196 if (!cdev) { 4197 pr_err("st%d: out of memory. Device not attached.\n", dev_num); 4198 error = -ENOMEM; 4199 goto out; 4200 } 4201 cdev->owner = THIS_MODULE; 4202 cdev->ops = &st_fops; 4203 STm->cdevs[rew] = cdev; 4204 4205 error = cdev_add(cdev, cdev_devno, 1); 4206 if (error) { 4207 pr_err("st%d: Can't add %s-rewind mode %d\n", dev_num, 4208 rew ? "non" : "auto", mode); 4209 pr_err("st%d: Device not attached.\n", dev_num); 4210 goto out_free; 4211 } 4212 4213 i = mode << (4 - ST_NBR_MODE_BITS); 4214 snprintf(name, 10, "%s%s%s", rew ? "n" : "", 4215 tape->name, st_formats[i]); 4216 4217 dev = device_create(&st_sysfs_class, &tape->device->sdev_gendev, 4218 cdev_devno, &tape->modes[mode], "%s", name); 4219 if (IS_ERR(dev)) { 4220 pr_err("st%d: device_create failed\n", dev_num); 4221 error = PTR_ERR(dev); 4222 goto out_free; 4223 } 4224 4225 STm->devs[rew] = dev; 4226 4227 return 0; 4228 out_free: 4229 cdev_del(STm->cdevs[rew]); 4230 out: 4231 STm->cdevs[rew] = NULL; 4232 STm->devs[rew] = NULL; 4233 return error; 4234 } 4235 4236 static int create_cdevs(struct scsi_tape *tape) 4237 { 4238 int mode, error; 4239 for (mode = 0; mode < ST_NBR_MODES; ++mode) { 4240 error = create_one_cdev(tape, mode, 0); 4241 if (error) 4242 return error; 4243 error = create_one_cdev(tape, mode, 1); 4244 if (error) 4245 return error; 4246 } 4247 4248 return sysfs_create_link(&tape->device->sdev_gendev.kobj, 4249 &tape->modes[0].devs[0]->kobj, "tape"); 4250 } 4251 4252 static void remove_cdevs(struct scsi_tape *tape) 4253 { 4254 int mode, rew; 4255 sysfs_remove_link(&tape->device->sdev_gendev.kobj, "tape"); 4256 for (mode = 0; mode < ST_NBR_MODES; mode++) { 4257 struct st_modedef *STm = &(tape->modes[mode]); 4258 for (rew = 0; rew < 2; rew++) { 4259 if (STm->cdevs[rew]) 4260 cdev_del(STm->cdevs[rew]); 4261 if (STm->devs[rew]) 4262 device_unregister(STm->devs[rew]); 4263 } 4264 } 4265 } 4266 4267 static int st_probe(struct device *dev) 4268 { 4269 struct scsi_device *SDp = to_scsi_device(dev); 4270 struct scsi_tape *tpnt = NULL; 4271 struct st_modedef *STm; 4272 struct st_partstat *STps; 4273 struct st_buffer *buffer; 4274 int i, error; 4275 char *stp; 4276 4277 if (SDp->type != TYPE_TAPE) 4278 return -ENODEV; 4279 if ((stp = st_incompatible(SDp))) { 4280 sdev_printk(KERN_INFO, SDp, 4281 "OnStream tapes are no longer supported;\n"); 4282 sdev_printk(KERN_INFO, SDp, 4283 "please mail to linux-scsi@vger.kernel.org.\n"); 4284 return -ENODEV; 4285 } 4286 4287 scsi_autopm_get_device(SDp); 4288 i = queue_max_segments(SDp->request_queue); 4289 if (st_max_sg_segs < i) 4290 i = st_max_sg_segs; 4291 buffer = new_tape_buffer(i); 4292 if (buffer == NULL) { 4293 sdev_printk(KERN_ERR, SDp, 4294 "st: Can't allocate new tape buffer. " 4295 "Device not attached.\n"); 4296 goto out; 4297 } 4298 4299 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_KERNEL); 4300 if (tpnt == NULL) { 4301 sdev_printk(KERN_ERR, SDp, 4302 "st: Can't allocate device descriptor.\n"); 4303 goto out_buffer_free; 4304 } 4305 kref_init(&tpnt->kref); 4306 tpnt->driver = &st_template; 4307 4308 tpnt->device = SDp; 4309 if (SDp->scsi_level <= 2) 4310 tpnt->tape_type = MT_ISSCSI1; 4311 else 4312 tpnt->tape_type = MT_ISSCSI2; 4313 4314 tpnt->buffer = buffer; 4315 tpnt->buffer->last_SRpnt = NULL; 4316 4317 tpnt->inited = 0; 4318 tpnt->dirty = 0; 4319 tpnt->in_use = 0; 4320 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */ 4321 tpnt->use_pf = (SDp->scsi_level >= SCSI_2); 4322 tpnt->density = 0; 4323 tpnt->do_auto_lock = ST_AUTO_LOCK; 4324 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */ 4325 tpnt->can_partitions = 0; 4326 tpnt->two_fm = ST_TWO_FM; 4327 tpnt->fast_mteom = ST_FAST_MTEOM; 4328 tpnt->scsi2_logical = ST_SCSI2LOGICAL; 4329 tpnt->sili = ST_SILI; 4330 tpnt->immediate = ST_NOWAIT; 4331 tpnt->immediate_filemark = 0; 4332 tpnt->default_drvbuffer = 0xff; /* No forced buffering */ 4333 tpnt->partition = 0; 4334 tpnt->new_partition = 0; 4335 tpnt->nbr_partitions = 0; 4336 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT); 4337 tpnt->long_timeout = ST_LONG_TIMEOUT; 4338 tpnt->try_dio = try_direct_io; 4339 4340 for (i = 0; i < ST_NBR_MODES; i++) { 4341 STm = &(tpnt->modes[i]); 4342 STm->defined = 0; 4343 STm->sysv = ST_SYSV; 4344 STm->defaults_for_writes = 0; 4345 STm->do_async_writes = ST_ASYNC_WRITES; 4346 STm->do_buffer_writes = ST_BUFFER_WRITES; 4347 STm->do_read_ahead = ST_READ_AHEAD; 4348 STm->default_compression = ST_DONT_TOUCH; 4349 STm->default_blksize = (-1); /* No forced size */ 4350 STm->default_density = (-1); /* No forced density */ 4351 STm->tape = tpnt; 4352 } 4353 4354 for (i = 0; i < ST_NBR_PARTITIONS; i++) { 4355 STps = &(tpnt->ps[i]); 4356 STps->rw = ST_IDLE; 4357 STps->eof = ST_NOEOF; 4358 STps->at_sm = 0; 4359 STps->last_block_valid = 0; 4360 STps->drv_block = (-1); 4361 STps->drv_file = (-1); 4362 } 4363 4364 tpnt->current_mode = 0; 4365 tpnt->modes[0].defined = 1; 4366 4367 tpnt->density_changed = tpnt->compression_changed = 4368 tpnt->blksize_changed = 0; 4369 mutex_init(&tpnt->lock); 4370 4371 idr_preload(GFP_KERNEL); 4372 spin_lock(&st_index_lock); 4373 error = idr_alloc(&st_index_idr, tpnt, 0, ST_MAX_TAPES + 1, GFP_NOWAIT); 4374 spin_unlock(&st_index_lock); 4375 idr_preload_end(); 4376 if (error < 0) { 4377 pr_warn("st: idr allocation failed: %d\n", error); 4378 goto out_free_tape; 4379 } 4380 tpnt->index = error; 4381 sprintf(tpnt->name, "st%d", tpnt->index); 4382 tpnt->stats = kzalloc(sizeof(struct scsi_tape_stats), GFP_KERNEL); 4383 if (tpnt->stats == NULL) { 4384 sdev_printk(KERN_ERR, SDp, 4385 "st: Can't allocate statistics.\n"); 4386 goto out_idr_remove; 4387 } 4388 4389 dev_set_drvdata(dev, tpnt); 4390 4391 4392 error = create_cdevs(tpnt); 4393 if (error) 4394 goto out_remove_devs; 4395 scsi_autopm_put_device(SDp); 4396 4397 sdev_printk(KERN_NOTICE, SDp, 4398 "Attached scsi tape %s\n", tpnt->name); 4399 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n", 4400 tpnt->name, tpnt->try_dio ? "yes" : "no", 4401 queue_dma_alignment(SDp->request_queue) + 1); 4402 4403 return 0; 4404 4405 out_remove_devs: 4406 remove_cdevs(tpnt); 4407 kfree(tpnt->stats); 4408 out_idr_remove: 4409 spin_lock(&st_index_lock); 4410 idr_remove(&st_index_idr, tpnt->index); 4411 spin_unlock(&st_index_lock); 4412 out_free_tape: 4413 kfree(tpnt); 4414 out_buffer_free: 4415 kfree(buffer); 4416 out: 4417 scsi_autopm_put_device(SDp); 4418 return -ENODEV; 4419 }; 4420 4421 4422 static int st_remove(struct device *dev) 4423 { 4424 struct scsi_tape *tpnt = dev_get_drvdata(dev); 4425 int index = tpnt->index; 4426 4427 scsi_autopm_get_device(to_scsi_device(dev)); 4428 remove_cdevs(tpnt); 4429 4430 mutex_lock(&st_ref_mutex); 4431 kref_put(&tpnt->kref, scsi_tape_release); 4432 mutex_unlock(&st_ref_mutex); 4433 spin_lock(&st_index_lock); 4434 idr_remove(&st_index_idr, index); 4435 spin_unlock(&st_index_lock); 4436 return 0; 4437 } 4438 4439 /** 4440 * scsi_tape_release - Called to free the Scsi_Tape structure 4441 * @kref: pointer to embedded kref 4442 * 4443 * st_ref_mutex must be held entering this routine. Because it is 4444 * called on last put, you should always use the scsi_tape_get() 4445 * scsi_tape_put() helpers which manipulate the semaphore directly 4446 * and never do a direct kref_put(). 4447 **/ 4448 static void scsi_tape_release(struct kref *kref) 4449 { 4450 struct scsi_tape *tpnt = to_scsi_tape(kref); 4451 4452 tpnt->device = NULL; 4453 4454 if (tpnt->buffer) { 4455 normalize_buffer(tpnt->buffer); 4456 kfree(tpnt->buffer->reserved_pages); 4457 kfree(tpnt->buffer); 4458 } 4459 4460 kfree(tpnt->stats); 4461 kfree(tpnt); 4462 return; 4463 } 4464 4465 static struct class st_sysfs_class = { 4466 .name = "scsi_tape", 4467 .dev_groups = st_dev_groups, 4468 }; 4469 4470 static int __init init_st(void) 4471 { 4472 int err; 4473 4474 validate_options(); 4475 4476 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n", 4477 verstr, st_fixed_buffer_size, st_max_sg_segs); 4478 4479 debugging = (debug_flag > 0) ? debug_flag : NO_DEBUG; 4480 if (debugging) { 4481 printk(KERN_INFO "st: Debugging enabled debug_flag = %d\n", 4482 debugging); 4483 } 4484 4485 err = class_register(&st_sysfs_class); 4486 if (err) { 4487 pr_err("Unable register sysfs class for SCSI tapes\n"); 4488 return err; 4489 } 4490 4491 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 4492 ST_MAX_TAPE_ENTRIES, "st"); 4493 if (err) { 4494 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", 4495 SCSI_TAPE_MAJOR); 4496 goto err_class; 4497 } 4498 4499 err = scsi_register_driver(&st_template.gendrv); 4500 if (err) 4501 goto err_chrdev; 4502 4503 return 0; 4504 4505 err_chrdev: 4506 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 4507 ST_MAX_TAPE_ENTRIES); 4508 err_class: 4509 class_unregister(&st_sysfs_class); 4510 return err; 4511 } 4512 4513 static void __exit exit_st(void) 4514 { 4515 scsi_unregister_driver(&st_template.gendrv); 4516 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0), 4517 ST_MAX_TAPE_ENTRIES); 4518 class_unregister(&st_sysfs_class); 4519 idr_destroy(&st_index_idr); 4520 printk(KERN_INFO "st: Unloaded.\n"); 4521 } 4522 4523 module_init(init_st); 4524 module_exit(exit_st); 4525 4526 4527 /* The sysfs driver interface. Read-only at the moment */ 4528 static ssize_t try_direct_io_show(struct device_driver *ddp, char *buf) 4529 { 4530 return scnprintf(buf, PAGE_SIZE, "%d\n", try_direct_io); 4531 } 4532 static DRIVER_ATTR_RO(try_direct_io); 4533 4534 static ssize_t fixed_buffer_size_show(struct device_driver *ddp, char *buf) 4535 { 4536 return scnprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size); 4537 } 4538 static DRIVER_ATTR_RO(fixed_buffer_size); 4539 4540 static ssize_t max_sg_segs_show(struct device_driver *ddp, char *buf) 4541 { 4542 return scnprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs); 4543 } 4544 static DRIVER_ATTR_RO(max_sg_segs); 4545 4546 static ssize_t version_show(struct device_driver *ddd, char *buf) 4547 { 4548 return scnprintf(buf, PAGE_SIZE, "[%s]\n", verstr); 4549 } 4550 static DRIVER_ATTR_RO(version); 4551 4552 #if DEBUG 4553 static ssize_t debug_flag_store(struct device_driver *ddp, 4554 const char *buf, size_t count) 4555 { 4556 /* We only care what the first byte of the data is the rest is unused. 4557 * if it's a '1' we turn on debug and if it's a '0' we disable it. All 4558 * other values have -EINVAL returned if they are passed in. 4559 */ 4560 if (count > 0) { 4561 if (buf[0] == '0') { 4562 debugging = NO_DEBUG; 4563 return count; 4564 } else if (buf[0] == '1') { 4565 debugging = 1; 4566 return count; 4567 } 4568 } 4569 return -EINVAL; 4570 } 4571 4572 static ssize_t debug_flag_show(struct device_driver *ddp, char *buf) 4573 { 4574 return scnprintf(buf, PAGE_SIZE, "%d\n", debugging); 4575 } 4576 static DRIVER_ATTR_RW(debug_flag); 4577 #endif 4578 4579 static struct attribute *st_drv_attrs[] = { 4580 &driver_attr_try_direct_io.attr, 4581 &driver_attr_fixed_buffer_size.attr, 4582 &driver_attr_max_sg_segs.attr, 4583 &driver_attr_version.attr, 4584 #if DEBUG 4585 &driver_attr_debug_flag.attr, 4586 #endif 4587 NULL, 4588 }; 4589 ATTRIBUTE_GROUPS(st_drv); 4590 4591 /* The sysfs simple class interface */ 4592 static ssize_t 4593 defined_show(struct device *dev, struct device_attribute *attr, char *buf) 4594 { 4595 struct st_modedef *STm = dev_get_drvdata(dev); 4596 ssize_t l = 0; 4597 4598 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined); 4599 return l; 4600 } 4601 static DEVICE_ATTR_RO(defined); 4602 4603 static ssize_t 4604 default_blksize_show(struct device *dev, struct device_attribute *attr, 4605 char *buf) 4606 { 4607 struct st_modedef *STm = dev_get_drvdata(dev); 4608 ssize_t l = 0; 4609 4610 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize); 4611 return l; 4612 } 4613 static DEVICE_ATTR_RO(default_blksize); 4614 4615 static ssize_t 4616 default_density_show(struct device *dev, struct device_attribute *attr, 4617 char *buf) 4618 { 4619 struct st_modedef *STm = dev_get_drvdata(dev); 4620 ssize_t l = 0; 4621 char *fmt; 4622 4623 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n"; 4624 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density); 4625 return l; 4626 } 4627 static DEVICE_ATTR_RO(default_density); 4628 4629 static ssize_t 4630 default_compression_show(struct device *dev, struct device_attribute *attr, 4631 char *buf) 4632 { 4633 struct st_modedef *STm = dev_get_drvdata(dev); 4634 ssize_t l = 0; 4635 4636 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1); 4637 return l; 4638 } 4639 static DEVICE_ATTR_RO(default_compression); 4640 4641 static ssize_t 4642 options_show(struct device *dev, struct device_attribute *attr, char *buf) 4643 { 4644 struct st_modedef *STm = dev_get_drvdata(dev); 4645 struct scsi_tape *STp = STm->tape; 4646 int options; 4647 ssize_t l = 0; 4648 4649 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0; 4650 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0; 4651 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0; 4652 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 ); 4653 options |= STp->two_fm ? MT_ST_TWO_FM : 0; 4654 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0; 4655 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0; 4656 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0; 4657 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0; 4658 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0; 4659 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0; 4660 options |= STm->sysv ? MT_ST_SYSV : 0; 4661 options |= STp->immediate ? MT_ST_NOWAIT : 0; 4662 options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0; 4663 options |= STp->sili ? MT_ST_SILI : 0; 4664 4665 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options); 4666 return l; 4667 } 4668 static DEVICE_ATTR_RO(options); 4669 4670 /* Support for tape stats */ 4671 4672 /** 4673 * read_cnt_show - return read count - count of reads made from tape drive 4674 * @dev: struct device 4675 * @attr: attribute structure 4676 * @buf: buffer to return formatted data in 4677 */ 4678 static ssize_t read_cnt_show(struct device *dev, 4679 struct device_attribute *attr, char *buf) 4680 { 4681 struct st_modedef *STm = dev_get_drvdata(dev); 4682 4683 return sprintf(buf, "%lld", 4684 (long long)atomic64_read(&STm->tape->stats->read_cnt)); 4685 } 4686 static DEVICE_ATTR_RO(read_cnt); 4687 4688 /** 4689 * read_byte_cnt_show - return read byte count - tape drives 4690 * may use blocks less than 512 bytes this gives the raw byte count of 4691 * of data read from the tape drive. 4692 * @dev: struct device 4693 * @attr: attribute structure 4694 * @buf: buffer to return formatted data in 4695 */ 4696 static ssize_t read_byte_cnt_show(struct device *dev, 4697 struct device_attribute *attr, char *buf) 4698 { 4699 struct st_modedef *STm = dev_get_drvdata(dev); 4700 4701 return sprintf(buf, "%lld", 4702 (long long)atomic64_read(&STm->tape->stats->read_byte_cnt)); 4703 } 4704 static DEVICE_ATTR_RO(read_byte_cnt); 4705 4706 /** 4707 * read_ns_show - return read ns - overall time spent waiting on reads in ns. 4708 * @dev: struct device 4709 * @attr: attribute structure 4710 * @buf: buffer to return formatted data in 4711 */ 4712 static ssize_t read_ns_show(struct device *dev, 4713 struct device_attribute *attr, char *buf) 4714 { 4715 struct st_modedef *STm = dev_get_drvdata(dev); 4716 4717 return sprintf(buf, "%lld", 4718 (long long)atomic64_read(&STm->tape->stats->tot_read_time)); 4719 } 4720 static DEVICE_ATTR_RO(read_ns); 4721 4722 /** 4723 * write_cnt_show - write count - number of user calls 4724 * to write(2) that have written data to tape. 4725 * @dev: struct device 4726 * @attr: attribute structure 4727 * @buf: buffer to return formatted data in 4728 */ 4729 static ssize_t write_cnt_show(struct device *dev, 4730 struct device_attribute *attr, char *buf) 4731 { 4732 struct st_modedef *STm = dev_get_drvdata(dev); 4733 4734 return sprintf(buf, "%lld", 4735 (long long)atomic64_read(&STm->tape->stats->write_cnt)); 4736 } 4737 static DEVICE_ATTR_RO(write_cnt); 4738 4739 /** 4740 * write_byte_cnt_show - write byte count - raw count of 4741 * bytes written to tape. 4742 * @dev: struct device 4743 * @attr: attribute structure 4744 * @buf: buffer to return formatted data in 4745 */ 4746 static ssize_t write_byte_cnt_show(struct device *dev, 4747 struct device_attribute *attr, char *buf) 4748 { 4749 struct st_modedef *STm = dev_get_drvdata(dev); 4750 4751 return sprintf(buf, "%lld", 4752 (long long)atomic64_read(&STm->tape->stats->write_byte_cnt)); 4753 } 4754 static DEVICE_ATTR_RO(write_byte_cnt); 4755 4756 /** 4757 * write_ns_show - write ns - number of nanoseconds waiting on write 4758 * requests to complete. 4759 * @dev: struct device 4760 * @attr: attribute structure 4761 * @buf: buffer to return formatted data in 4762 */ 4763 static ssize_t write_ns_show(struct device *dev, 4764 struct device_attribute *attr, char *buf) 4765 { 4766 struct st_modedef *STm = dev_get_drvdata(dev); 4767 4768 return sprintf(buf, "%lld", 4769 (long long)atomic64_read(&STm->tape->stats->tot_write_time)); 4770 } 4771 static DEVICE_ATTR_RO(write_ns); 4772 4773 /** 4774 * in_flight_show - number of I/Os currently in flight - 4775 * in most cases this will be either 0 or 1. It may be higher if someone 4776 * has also issued other SCSI commands such as via an ioctl. 4777 * @dev: struct device 4778 * @attr: attribute structure 4779 * @buf: buffer to return formatted data in 4780 */ 4781 static ssize_t in_flight_show(struct device *dev, 4782 struct device_attribute *attr, char *buf) 4783 { 4784 struct st_modedef *STm = dev_get_drvdata(dev); 4785 4786 return sprintf(buf, "%lld", 4787 (long long)atomic64_read(&STm->tape->stats->in_flight)); 4788 } 4789 static DEVICE_ATTR_RO(in_flight); 4790 4791 /** 4792 * io_ns_show - io wait ns - this is the number of ns spent 4793 * waiting on all I/O to complete. This includes tape movement commands 4794 * such as rewinding, seeking to end of file or tape, it also includes 4795 * read and write. To determine the time spent on tape movement 4796 * subtract the read and write ns from this value. 4797 * @dev: struct device 4798 * @attr: attribute structure 4799 * @buf: buffer to return formatted data in 4800 */ 4801 static ssize_t io_ns_show(struct device *dev, 4802 struct device_attribute *attr, char *buf) 4803 { 4804 struct st_modedef *STm = dev_get_drvdata(dev); 4805 4806 return sprintf(buf, "%lld", 4807 (long long)atomic64_read(&STm->tape->stats->tot_io_time)); 4808 } 4809 static DEVICE_ATTR_RO(io_ns); 4810 4811 /** 4812 * other_cnt_show - other io count - this is the number of 4813 * I/O requests other than read and write requests. 4814 * Typically these are tape movement requests but will include driver 4815 * tape movement. This includes only requests issued by the st driver. 4816 * @dev: struct device 4817 * @attr: attribute structure 4818 * @buf: buffer to return formatted data in 4819 */ 4820 static ssize_t other_cnt_show(struct device *dev, 4821 struct device_attribute *attr, char *buf) 4822 { 4823 struct st_modedef *STm = dev_get_drvdata(dev); 4824 4825 return sprintf(buf, "%lld", 4826 (long long)atomic64_read(&STm->tape->stats->other_cnt)); 4827 } 4828 static DEVICE_ATTR_RO(other_cnt); 4829 4830 /** 4831 * resid_cnt_show - A count of the number of times we get a residual 4832 * count - this should indicate someone issuing reads larger than the 4833 * block size on tape. 4834 * @dev: struct device 4835 * @attr: attribute structure 4836 * @buf: buffer to return formatted data in 4837 */ 4838 static ssize_t resid_cnt_show(struct device *dev, 4839 struct device_attribute *attr, char *buf) 4840 { 4841 struct st_modedef *STm = dev_get_drvdata(dev); 4842 4843 return sprintf(buf, "%lld", 4844 (long long)atomic64_read(&STm->tape->stats->resid_cnt)); 4845 } 4846 static DEVICE_ATTR_RO(resid_cnt); 4847 4848 static struct attribute *st_dev_attrs[] = { 4849 &dev_attr_defined.attr, 4850 &dev_attr_default_blksize.attr, 4851 &dev_attr_default_density.attr, 4852 &dev_attr_default_compression.attr, 4853 &dev_attr_options.attr, 4854 NULL, 4855 }; 4856 4857 static struct attribute *st_stats_attrs[] = { 4858 &dev_attr_read_cnt.attr, 4859 &dev_attr_read_byte_cnt.attr, 4860 &dev_attr_read_ns.attr, 4861 &dev_attr_write_cnt.attr, 4862 &dev_attr_write_byte_cnt.attr, 4863 &dev_attr_write_ns.attr, 4864 &dev_attr_in_flight.attr, 4865 &dev_attr_io_ns.attr, 4866 &dev_attr_other_cnt.attr, 4867 &dev_attr_resid_cnt.attr, 4868 NULL, 4869 }; 4870 4871 static struct attribute_group stats_group = { 4872 .name = "stats", 4873 .attrs = st_stats_attrs, 4874 }; 4875 4876 static struct attribute_group st_group = { 4877 .attrs = st_dev_attrs, 4878 }; 4879 4880 static const struct attribute_group *st_dev_groups[] = { 4881 &st_group, 4882 &stats_group, 4883 NULL, 4884 }; 4885 4886 /* The following functions may be useful for a larger audience. */ 4887 static int sgl_map_user_pages(struct st_buffer *STbp, 4888 const unsigned int max_pages, unsigned long uaddr, 4889 size_t count, int rw) 4890 { 4891 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT; 4892 unsigned long start = uaddr >> PAGE_SHIFT; 4893 const int nr_pages = end - start; 4894 int res, i; 4895 struct page **pages; 4896 struct rq_map_data *mdata = &STbp->map_data; 4897 4898 /* User attempted Overflow! */ 4899 if ((uaddr + count) < uaddr) 4900 return -EINVAL; 4901 4902 /* Too big */ 4903 if (nr_pages > max_pages) 4904 return -ENOMEM; 4905 4906 /* Hmm? */ 4907 if (count == 0) 4908 return 0; 4909 4910 pages = kmalloc_array(max_pages, sizeof(*pages), GFP_KERNEL); 4911 if (pages == NULL) 4912 return -ENOMEM; 4913 4914 /* Try to fault in all of the necessary pages */ 4915 /* rw==READ means read from drive, write into memory area */ 4916 res = pin_user_pages_fast(uaddr, nr_pages, rw == READ ? FOLL_WRITE : 0, 4917 pages); 4918 4919 /* Errors and no page mapped should return here */ 4920 if (res < nr_pages) 4921 goto out_unmap; 4922 4923 for (i=0; i < nr_pages; i++) { 4924 /* FIXME: flush superflous for rw==READ, 4925 * probably wrong function for rw==WRITE 4926 */ 4927 flush_dcache_page(pages[i]); 4928 } 4929 4930 mdata->offset = uaddr & ~PAGE_MASK; 4931 STbp->mapped_pages = pages; 4932 4933 return nr_pages; 4934 out_unmap: 4935 if (res > 0) { 4936 unpin_user_pages(pages, res); 4937 res = 0; 4938 } 4939 kfree(pages); 4940 return res; 4941 } 4942 4943 4944 /* And unmap them... */ 4945 static int sgl_unmap_user_pages(struct st_buffer *STbp, 4946 const unsigned int nr_pages, int dirtied) 4947 { 4948 /* FIXME: cache flush missing for rw==READ */ 4949 unpin_user_pages_dirty_lock(STbp->mapped_pages, nr_pages, dirtied); 4950 4951 kfree(STbp->mapped_pages); 4952 STbp->mapped_pages = NULL; 4953 4954 return 0; 4955 } 4956