osst.c revision f27b087b81b70513b8c61ec20596c868f7b93474
1/* 2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying 3 file Documentation/scsi/st.txt for more information. 4 5 History: 6 7 OnStream SCSI Tape support (osst) cloned from st.c by 8 Willem Riede (osst@riede.org) Feb 2000 9 Fixes ... Kurt Garloff <garloff@suse.de> Mar 2000 10 11 Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara. 12 Contribution and ideas from several people including (in alphabetical 13 order) Klaus Ehrenfried, Wolfgang Denk, Steve Hirsch, Andreas Koppenh"ofer, 14 Michael Leodolter, Eyal Lebedinsky, J"org Weule, and Eric Youngdale. 15 16 Copyright 1992 - 2002 Kai Makisara / 2000 - 2006 Willem Riede 17 email osst@riede.org 18 19 $Header: /cvsroot/osst/Driver/osst.c,v 1.73 2005/01/01 21:13:34 wriede Exp $ 20 21 Microscopic alterations - Rik Ling, 2000/12/21 22 Last st.c sync: Tue Oct 15 22:01:04 2002 by makisara 23 Some small formal changes - aeb, 950809 24*/ 25 26static const char * cvsid = "$Id: osst.c,v 1.73 2005/01/01 21:13:34 wriede Exp $"; 27static const char * osst_version = "0.99.4"; 28 29/* The "failure to reconnect" firmware bug */ 30#define OSST_FW_NEED_POLL_MIN 10601 /*(107A)*/ 31#define OSST_FW_NEED_POLL_MAX 10704 /*(108D)*/ 32#define OSST_FW_NEED_POLL(x,d) ((x) >= OSST_FW_NEED_POLL_MIN && (x) <= OSST_FW_NEED_POLL_MAX && d->host->this_id != 7) 33 34#include <linux/module.h> 35 36#include <linux/fs.h> 37#include <linux/kernel.h> 38#include <linux/sched.h> 39#include <linux/proc_fs.h> 40#include <linux/mm.h> 41#include <linux/slab.h> 42#include <linux/init.h> 43#include <linux/string.h> 44#include <linux/errno.h> 45#include <linux/mtio.h> 46#include <linux/ioctl.h> 47#include <linux/fcntl.h> 48#include <linux/spinlock.h> 49#include <linux/vmalloc.h> 50#include <linux/blkdev.h> 51#include <linux/moduleparam.h> 52#include <linux/delay.h> 53#include <linux/jiffies.h> 54#include <linux/mutex.h> 55#include <asm/uaccess.h> 56#include <asm/dma.h> 57 58/* The driver prints some debugging information on the console if DEBUG 59 is defined and non-zero. */ 60#define DEBUG 0 61 62/* The message level for the debug messages is currently set to KERN_NOTICE 63 so that people can easily see the messages. Later when the debugging messages 64 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */ 65#define OSST_DEB_MSG KERN_NOTICE 66 67#include <scsi/scsi.h> 68#include <scsi/scsi_dbg.h> 69#include <scsi/scsi_device.h> 70#include <scsi/scsi_driver.h> 71#include <scsi/scsi_eh.h> 72#include <scsi/scsi_host.h> 73#include <scsi/scsi_ioctl.h> 74 75#define ST_KILOBYTE 1024 76 77#include "st.h" 78#include "osst.h" 79#include "osst_options.h" 80#include "osst_detect.h" 81 82static DEFINE_MUTEX(osst_int_mutex); 83static int max_dev = 0; 84static int write_threshold_kbs = 0; 85static int max_sg_segs = 0; 86 87#ifdef MODULE 88MODULE_AUTHOR("Willem Riede"); 89MODULE_DESCRIPTION("OnStream {DI-|FW-|SC-|USB}{30|50} Tape Driver"); 90MODULE_LICENSE("GPL"); 91MODULE_ALIAS_CHARDEV_MAJOR(OSST_MAJOR); 92MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE); 93 94module_param(max_dev, int, 0444); 95MODULE_PARM_DESC(max_dev, "Maximum number of OnStream Tape Drives to attach (4)"); 96 97module_param(write_threshold_kbs, int, 0644); 98MODULE_PARM_DESC(write_threshold_kbs, "Asynchronous write threshold (KB; 32)"); 99 100module_param(max_sg_segs, int, 0644); 101MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (9)"); 102#else 103static struct osst_dev_parm { 104 char *name; 105 int *val; 106} parms[] __initdata = { 107 { "max_dev", &max_dev }, 108 { "write_threshold_kbs", &write_threshold_kbs }, 109 { "max_sg_segs", &max_sg_segs } 110}; 111#endif 112 113/* Some default definitions have been moved to osst_options.h */ 114#define OSST_BUFFER_SIZE (OSST_BUFFER_BLOCKS * ST_KILOBYTE) 115#define OSST_WRITE_THRESHOLD (OSST_WRITE_THRESHOLD_BLOCKS * ST_KILOBYTE) 116 117/* The buffer size should fit into the 24 bits for length in the 118 6-byte SCSI read and write commands. */ 119#if OSST_BUFFER_SIZE >= (2 << 24 - 1) 120#error "Buffer size should not exceed (2 << 24 - 1) bytes!" 121#endif 122 123#if DEBUG 124static int debugging = 1; 125/* uncomment define below to test error recovery */ 126// #define OSST_INJECT_ERRORS 1 127#endif 128 129/* Do not retry! The drive firmware already retries when appropriate, 130 and when it tries to tell us something, we had better listen... */ 131#define MAX_RETRIES 0 132 133#define NO_TAPE NOT_READY 134 135#define OSST_WAIT_POSITION_COMPLETE (HZ > 200 ? HZ / 200 : 1) 136#define OSST_WAIT_WRITE_COMPLETE (HZ / 12) 137#define OSST_WAIT_LONG_WRITE_COMPLETE (HZ / 2) 138 139#define OSST_TIMEOUT (200 * HZ) 140#define OSST_LONG_TIMEOUT (1800 * HZ) 141 142#define TAPE_NR(x) (iminor(x) & ~(-1 << ST_MODE_SHIFT)) 143#define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT) 144#define TAPE_REWIND(x) ((iminor(x) & 0x80) == 0) 145#define TAPE_IS_RAW(x) (TAPE_MODE(x) & (ST_NBR_MODES >> 1)) 146 147/* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower 148 24 bits) */ 149#define SET_DENS_AND_BLK 0x10001 150 151static int osst_buffer_size = OSST_BUFFER_SIZE; 152static int osst_write_threshold = OSST_WRITE_THRESHOLD; 153static int osst_max_sg_segs = OSST_MAX_SG; 154static int osst_max_dev = OSST_MAX_TAPES; 155static int osst_nr_dev; 156 157static struct osst_tape **os_scsi_tapes = NULL; 158static DEFINE_RWLOCK(os_scsi_tapes_lock); 159 160static int modes_defined = 0; 161 162static struct osst_buffer *new_tape_buffer(int, int, int); 163static int enlarge_buffer(struct osst_buffer *, int); 164static void normalize_buffer(struct osst_buffer *); 165static int append_to_buffer(const char __user *, struct osst_buffer *, int); 166static int from_buffer(struct osst_buffer *, char __user *, int); 167static int osst_zero_buffer_tail(struct osst_buffer *); 168static int osst_copy_to_buffer(struct osst_buffer *, unsigned char *); 169static int osst_copy_from_buffer(struct osst_buffer *, unsigned char *); 170 171static int osst_probe(struct device *); 172static int osst_remove(struct device *); 173 174static struct scsi_driver osst_template = { 175 .owner = THIS_MODULE, 176 .gendrv = { 177 .name = "osst", 178 .probe = osst_probe, 179 .remove = osst_remove, 180 } 181}; 182 183static int osst_int_ioctl(struct osst_tape *STp, struct osst_request ** aSRpnt, 184 unsigned int cmd_in, unsigned long arg); 185 186static int osst_set_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt, int frame, int skip); 187 188static int osst_get_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt); 189 190static int osst_flush_write_buffer(struct osst_tape *STp, struct osst_request ** aSRpnt); 191 192static int osst_write_error_recovery(struct osst_tape * STp, struct osst_request ** aSRpnt, int pending); 193 194static inline char *tape_name(struct osst_tape *tape) 195{ 196 return tape->drive->disk_name; 197} 198 199/* Routines that handle the interaction with mid-layer SCSI routines */ 200 201 202/* Normalize Sense */ 203static void osst_analyze_sense(struct osst_request *SRpnt, struct st_cmdstatus *s) 204{ 205 const u8 *ucp; 206 const u8 *sense = SRpnt->sense; 207 208 s->have_sense = scsi_normalize_sense(SRpnt->sense, 209 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr); 210 s->flags = 0; 211 212 if (s->have_sense) { 213 s->deferred = 0; 214 s->remainder_valid = 215 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64); 216 switch (sense[0] & 0x7f) { 217 case 0x71: 218 s->deferred = 1; 219 case 0x70: 220 s->fixed_format = 1; 221 s->flags = sense[2] & 0xe0; 222 break; 223 case 0x73: 224 s->deferred = 1; 225 case 0x72: 226 s->fixed_format = 0; 227 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4); 228 s->flags = ucp ? (ucp[3] & 0xe0) : 0; 229 break; 230 } 231 } 232} 233 234/* Convert the result to success code */ 235static int osst_chk_result(struct osst_tape * STp, struct osst_request * SRpnt) 236{ 237 char *name = tape_name(STp); 238 int result = SRpnt->result; 239 u8 * sense = SRpnt->sense, scode; 240#if DEBUG 241 const char *stp; 242#endif 243 struct st_cmdstatus *cmdstatp; 244 245 if (!result) 246 return 0; 247 248 cmdstatp = &STp->buffer->cmdstat; 249 osst_analyze_sense(SRpnt, cmdstatp); 250 251 if (cmdstatp->have_sense) 252 scode = STp->buffer->cmdstat.sense_hdr.sense_key; 253 else 254 scode = 0; 255#if DEBUG 256 if (debugging) { 257 printk(OSST_DEB_MSG "%s:D: Error: %x, cmd: %x %x %x %x %x %x\n", 258 name, result, 259 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2], 260 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]); 261 if (scode) printk(OSST_DEB_MSG "%s:D: Sense: %02x, ASC: %02x, ASCQ: %02x\n", 262 name, scode, sense[12], sense[13]); 263 if (cmdstatp->have_sense) 264 __scsi_print_sense("osst ", SRpnt->sense, SCSI_SENSE_BUFFERSIZE); 265 } 266 else 267#endif 268 if (cmdstatp->have_sense && ( 269 scode != NO_SENSE && 270 scode != RECOVERED_ERROR && 271/* scode != UNIT_ATTENTION && */ 272 scode != BLANK_CHECK && 273 scode != VOLUME_OVERFLOW && 274 SRpnt->cmd[0] != MODE_SENSE && 275 SRpnt->cmd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */ 276 if (cmdstatp->have_sense) { 277 printk(KERN_WARNING "%s:W: Command with sense data:\n", name); 278 __scsi_print_sense("osst ", SRpnt->sense, SCSI_SENSE_BUFFERSIZE); 279 } 280 else { 281 static int notyetprinted = 1; 282 283 printk(KERN_WARNING 284 "%s:W: Warning %x (driver bt 0x%x, host bt 0x%x).\n", 285 name, result, driver_byte(result), 286 host_byte(result)); 287 if (notyetprinted) { 288 notyetprinted = 0; 289 printk(KERN_INFO 290 "%s:I: This warning may be caused by your scsi controller,\n", name); 291 printk(KERN_INFO 292 "%s:I: it has been reported with some Buslogic cards.\n", name); 293 } 294 } 295 } 296 STp->pos_unknown |= STp->device->was_reset; 297 298 if (cmdstatp->have_sense && scode == RECOVERED_ERROR) { 299 STp->recover_count++; 300 STp->recover_erreg++; 301#if DEBUG 302 if (debugging) { 303 if (SRpnt->cmd[0] == READ_6) 304 stp = "read"; 305 else if (SRpnt->cmd[0] == WRITE_6) 306 stp = "write"; 307 else 308 stp = "ioctl"; 309 printk(OSST_DEB_MSG "%s:D: Recovered %s error (%d).\n", name, stp, 310 STp->recover_count); 311 } 312#endif 313 if ((sense[2] & 0xe0) == 0) 314 return 0; 315 } 316 return (-EIO); 317} 318 319 320/* Wakeup from interrupt */ 321static void osst_end_async(struct request *req, int update) 322{ 323 struct osst_request *SRpnt = req->end_io_data; 324 struct osst_tape *STp = SRpnt->stp; 325 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data; 326 327 STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors; 328#if DEBUG 329 STp->write_pending = 0; 330#endif 331 if (SRpnt->waiting) 332 complete(SRpnt->waiting); 333 334 if (SRpnt->bio) { 335 kfree(mdata->pages); 336 blk_rq_unmap_user(SRpnt->bio); 337 } 338 339 __blk_put_request(req->q, req); 340} 341 342/* osst_request memory management */ 343static struct osst_request *osst_allocate_request(void) 344{ 345 return kzalloc(sizeof(struct osst_request), GFP_KERNEL); 346} 347 348static void osst_release_request(struct osst_request *streq) 349{ 350 kfree(streq); 351} 352 353static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd, 354 int cmd_len, int data_direction, void *buffer, unsigned bufflen, 355 int use_sg, int timeout, int retries) 356{ 357 struct request *req; 358 struct page **pages = NULL; 359 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data; 360 361 int err = 0; 362 int write = (data_direction == DMA_TO_DEVICE); 363 364 req = blk_get_request(SRpnt->stp->device->request_queue, write, GFP_KERNEL); 365 if (!req) 366 return DRIVER_ERROR << 24; 367 368 blk_rq_set_block_pc(req); 369 req->cmd_flags |= REQ_QUIET; 370 371 SRpnt->bio = NULL; 372 373 if (use_sg) { 374 struct scatterlist *sg, *sgl = (struct scatterlist *)buffer; 375 int i; 376 377 pages = kzalloc(use_sg * sizeof(struct page *), GFP_KERNEL); 378 if (!pages) 379 goto free_req; 380 381 for_each_sg(sgl, sg, use_sg, i) 382 pages[i] = sg_page(sg); 383 384 mdata->null_mapped = 1; 385 386 mdata->page_order = get_order(sgl[0].length); 387 mdata->nr_entries = 388 DIV_ROUND_UP(bufflen, PAGE_SIZE << mdata->page_order); 389 mdata->offset = 0; 390 391 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen, GFP_KERNEL); 392 if (err) { 393 kfree(pages); 394 goto free_req; 395 } 396 SRpnt->bio = req->bio; 397 mdata->pages = pages; 398 399 } else if (bufflen) { 400 err = blk_rq_map_kern(req->q, req, buffer, bufflen, GFP_KERNEL); 401 if (err) 402 goto free_req; 403 } 404 405 req->cmd_len = cmd_len; 406 memset(req->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */ 407 memcpy(req->cmd, cmd, req->cmd_len); 408 req->sense = SRpnt->sense; 409 req->sense_len = 0; 410 req->timeout = timeout; 411 req->retries = retries; 412 req->end_io_data = SRpnt; 413 414 blk_execute_rq_nowait(req->q, NULL, req, 1, osst_end_async); 415 return 0; 416free_req: 417 blk_put_request(req); 418 return DRIVER_ERROR << 24; 419} 420 421/* Do the scsi command. Waits until command performed if do_wait is true. 422 Otherwise osst_write_behind_check() is used to check that the command 423 has finished. */ 424static struct osst_request * osst_do_scsi(struct osst_request *SRpnt, struct osst_tape *STp, 425 unsigned char *cmd, int bytes, int direction, int timeout, int retries, int do_wait) 426{ 427 unsigned char *bp; 428 unsigned short use_sg; 429#ifdef OSST_INJECT_ERRORS 430 static int inject = 0; 431 static int repeat = 0; 432#endif 433 struct completion *waiting; 434 435 /* if async, make sure there's no command outstanding */ 436 if (!do_wait && ((STp->buffer)->last_SRpnt)) { 437 printk(KERN_ERR "%s: Async command already active.\n", 438 tape_name(STp)); 439 if (signal_pending(current)) 440 (STp->buffer)->syscall_result = (-EINTR); 441 else 442 (STp->buffer)->syscall_result = (-EBUSY); 443 return NULL; 444 } 445 446 if (SRpnt == NULL) { 447 SRpnt = osst_allocate_request(); 448 if (SRpnt == NULL) { 449 printk(KERN_ERR "%s: Can't allocate SCSI request.\n", 450 tape_name(STp)); 451 if (signal_pending(current)) 452 (STp->buffer)->syscall_result = (-EINTR); 453 else 454 (STp->buffer)->syscall_result = (-EBUSY); 455 return NULL; 456 } 457 SRpnt->stp = STp; 458 } 459 460 /* If async IO, set last_SRpnt. This ptr tells write_behind_check 461 which IO is outstanding. It's nulled out when the IO completes. */ 462 if (!do_wait) 463 (STp->buffer)->last_SRpnt = SRpnt; 464 465 waiting = &STp->wait; 466 init_completion(waiting); 467 SRpnt->waiting = waiting; 468 469 use_sg = (bytes > STp->buffer->sg[0].length) ? STp->buffer->use_sg : 0; 470 if (use_sg) { 471 bp = (char *)&(STp->buffer->sg[0]); 472 if (STp->buffer->sg_segs < use_sg) 473 use_sg = STp->buffer->sg_segs; 474 } 475 else 476 bp = (STp->buffer)->b_data; 477 478 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd)); 479 STp->buffer->cmdstat.have_sense = 0; 480 STp->buffer->syscall_result = 0; 481 482 if (osst_execute(SRpnt, cmd, COMMAND_SIZE(cmd[0]), direction, bp, bytes, 483 use_sg, timeout, retries)) 484 /* could not allocate the buffer or request was too large */ 485 (STp->buffer)->syscall_result = (-EBUSY); 486 else if (do_wait) { 487 wait_for_completion(waiting); 488 SRpnt->waiting = NULL; 489 STp->buffer->syscall_result = osst_chk_result(STp, SRpnt); 490#ifdef OSST_INJECT_ERRORS 491 if (STp->buffer->syscall_result == 0 && 492 cmd[0] == READ_6 && 493 cmd[4] && 494 ( (++ inject % 83) == 29 || 495 (STp->first_frame_position == 240 496 /* or STp->read_error_frame to fail again on the block calculated above */ && 497 ++repeat < 3))) { 498 printk(OSST_DEB_MSG "%s:D: Injecting read error\n", tape_name(STp)); 499 STp->buffer->last_result_fatal = 1; 500 } 501#endif 502 } 503 return SRpnt; 504} 505 506 507/* Handle the write-behind checking (downs the semaphore) */ 508static void osst_write_behind_check(struct osst_tape *STp) 509{ 510 struct osst_buffer * STbuffer; 511 512 STbuffer = STp->buffer; 513 514#if DEBUG 515 if (STp->write_pending) 516 STp->nbr_waits++; 517 else 518 STp->nbr_finished++; 519#endif 520 wait_for_completion(&(STp->wait)); 521 STp->buffer->last_SRpnt->waiting = NULL; 522 523 STp->buffer->syscall_result = osst_chk_result(STp, STp->buffer->last_SRpnt); 524 525 if (STp->buffer->syscall_result) 526 STp->buffer->syscall_result = 527 osst_write_error_recovery(STp, &(STp->buffer->last_SRpnt), 1); 528 else 529 STp->first_frame_position++; 530 531 osst_release_request(STp->buffer->last_SRpnt); 532 533 if (STbuffer->writing < STbuffer->buffer_bytes) 534 printk(KERN_WARNING "osst :A: write_behind_check: something left in buffer!\n"); 535 536 STbuffer->last_SRpnt = NULL; 537 STbuffer->buffer_bytes -= STbuffer->writing; 538 STbuffer->writing = 0; 539 540 return; 541} 542 543 544 545/* Onstream specific Routines */ 546/* 547 * Initialize the OnStream AUX 548 */ 549static void osst_init_aux(struct osst_tape * STp, int frame_type, int frame_seq_number, 550 int logical_blk_num, int blk_sz, int blk_cnt) 551{ 552 os_aux_t *aux = STp->buffer->aux; 553 os_partition_t *par = &aux->partition; 554 os_dat_t *dat = &aux->dat; 555 556 if (STp->raw) return; 557 558 memset(aux, 0, sizeof(*aux)); 559 aux->format_id = htonl(0); 560 memcpy(aux->application_sig, "LIN4", 4); 561 aux->hdwr = htonl(0); 562 aux->frame_type = frame_type; 563 564 switch (frame_type) { 565 case OS_FRAME_TYPE_HEADER: 566 aux->update_frame_cntr = htonl(STp->update_frame_cntr); 567 par->partition_num = OS_CONFIG_PARTITION; 568 par->par_desc_ver = OS_PARTITION_VERSION; 569 par->wrt_pass_cntr = htons(0xffff); 570 /* 0-4 = reserved, 5-9 = header, 2990-2994 = header, 2995-2999 = reserved */ 571 par->first_frame_ppos = htonl(0); 572 par->last_frame_ppos = htonl(0xbb7); 573 aux->frame_seq_num = htonl(0); 574 aux->logical_blk_num_high = htonl(0); 575 aux->logical_blk_num = htonl(0); 576 aux->next_mark_ppos = htonl(STp->first_mark_ppos); 577 break; 578 case OS_FRAME_TYPE_DATA: 579 case OS_FRAME_TYPE_MARKER: 580 dat->dat_sz = 8; 581 dat->reserved1 = 0; 582 dat->entry_cnt = 1; 583 dat->reserved3 = 0; 584 dat->dat_list[0].blk_sz = htonl(blk_sz); 585 dat->dat_list[0].blk_cnt = htons(blk_cnt); 586 dat->dat_list[0].flags = frame_type==OS_FRAME_TYPE_MARKER? 587 OS_DAT_FLAGS_MARK:OS_DAT_FLAGS_DATA; 588 dat->dat_list[0].reserved = 0; 589 case OS_FRAME_TYPE_EOD: 590 aux->update_frame_cntr = htonl(0); 591 par->partition_num = OS_DATA_PARTITION; 592 par->par_desc_ver = OS_PARTITION_VERSION; 593 par->wrt_pass_cntr = htons(STp->wrt_pass_cntr); 594 par->first_frame_ppos = htonl(STp->first_data_ppos); 595 par->last_frame_ppos = htonl(STp->capacity); 596 aux->frame_seq_num = htonl(frame_seq_number); 597 aux->logical_blk_num_high = htonl(0); 598 aux->logical_blk_num = htonl(logical_blk_num); 599 break; 600 default: ; /* probably FILL */ 601 } 602 aux->filemark_cnt = htonl(STp->filemark_cnt); 603 aux->phys_fm = htonl(0xffffffff); 604 aux->last_mark_ppos = htonl(STp->last_mark_ppos); 605 aux->last_mark_lbn = htonl(STp->last_mark_lbn); 606} 607 608/* 609 * Verify that we have the correct tape frame 610 */ 611static int osst_verify_frame(struct osst_tape * STp, int frame_seq_number, int quiet) 612{ 613 char * name = tape_name(STp); 614 os_aux_t * aux = STp->buffer->aux; 615 os_partition_t * par = &(aux->partition); 616 struct st_partstat * STps = &(STp->ps[STp->partition]); 617 int blk_cnt, blk_sz, i; 618 619 if (STp->raw) { 620 if (STp->buffer->syscall_result) { 621 for (i=0; i < STp->buffer->sg_segs; i++) 622 memset(page_address(sg_page(&STp->buffer->sg[i])), 623 0, STp->buffer->sg[i].length); 624 strcpy(STp->buffer->b_data, "READ ERROR ON FRAME"); 625 } else 626 STp->buffer->buffer_bytes = OS_FRAME_SIZE; 627 return 1; 628 } 629 if (STp->buffer->syscall_result) { 630#if DEBUG 631 printk(OSST_DEB_MSG "%s:D: Skipping frame, read error\n", name); 632#endif 633 return 0; 634 } 635 if (ntohl(aux->format_id) != 0) { 636#if DEBUG 637 printk(OSST_DEB_MSG "%s:D: Skipping frame, format_id %u\n", name, ntohl(aux->format_id)); 638#endif 639 goto err_out; 640 } 641 if (memcmp(aux->application_sig, STp->application_sig, 4) != 0 && 642 (memcmp(aux->application_sig, "LIN3", 4) != 0 || STp->linux_media_version != 4)) { 643#if DEBUG 644 printk(OSST_DEB_MSG "%s:D: Skipping frame, incorrect application signature\n", name); 645#endif 646 goto err_out; 647 } 648 if (par->partition_num != OS_DATA_PARTITION) { 649 if (!STp->linux_media || STp->linux_media_version != 2) { 650#if DEBUG 651 printk(OSST_DEB_MSG "%s:D: Skipping frame, partition num %d\n", 652 name, par->partition_num); 653#endif 654 goto err_out; 655 } 656 } 657 if (par->par_desc_ver != OS_PARTITION_VERSION) { 658#if DEBUG 659 printk(OSST_DEB_MSG "%s:D: Skipping frame, partition version %d\n", name, par->par_desc_ver); 660#endif 661 goto err_out; 662 } 663 if (ntohs(par->wrt_pass_cntr) != STp->wrt_pass_cntr) { 664#if DEBUG 665 printk(OSST_DEB_MSG "%s:D: Skipping frame, wrt_pass_cntr %d (expected %d)\n", 666 name, ntohs(par->wrt_pass_cntr), STp->wrt_pass_cntr); 667#endif 668 goto err_out; 669 } 670 if (aux->frame_type != OS_FRAME_TYPE_DATA && 671 aux->frame_type != OS_FRAME_TYPE_EOD && 672 aux->frame_type != OS_FRAME_TYPE_MARKER) { 673 if (!quiet) { 674#if DEBUG 675 printk(OSST_DEB_MSG "%s:D: Skipping frame, frame type %x\n", name, aux->frame_type); 676#endif 677 } 678 goto err_out; 679 } 680 if (aux->frame_type == OS_FRAME_TYPE_EOD && 681 STp->first_frame_position < STp->eod_frame_ppos) { 682 printk(KERN_INFO "%s:I: Skipping premature EOD frame %d\n", name, 683 STp->first_frame_position); 684 goto err_out; 685 } 686 if (frame_seq_number != -1 && ntohl(aux->frame_seq_num) != frame_seq_number) { 687 if (!quiet) { 688#if DEBUG 689 printk(OSST_DEB_MSG "%s:D: Skipping frame, sequence number %u (expected %d)\n", 690 name, ntohl(aux->frame_seq_num), frame_seq_number); 691#endif 692 } 693 goto err_out; 694 } 695 if (aux->frame_type == OS_FRAME_TYPE_MARKER) { 696 STps->eof = ST_FM_HIT; 697 698 i = ntohl(aux->filemark_cnt); 699 if (STp->header_cache != NULL && i < OS_FM_TAB_MAX && (i > STp->filemark_cnt || 700 STp->first_frame_position - 1 != ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i]))) { 701#if DEBUG 702 printk(OSST_DEB_MSG "%s:D: %s filemark %d at frame pos %d\n", name, 703 STp->header_cache->dat_fm_tab.fm_tab_ent[i] == 0?"Learned":"Corrected", 704 i, STp->first_frame_position - 1); 705#endif 706 STp->header_cache->dat_fm_tab.fm_tab_ent[i] = htonl(STp->first_frame_position - 1); 707 if (i >= STp->filemark_cnt) 708 STp->filemark_cnt = i+1; 709 } 710 } 711 if (aux->frame_type == OS_FRAME_TYPE_EOD) { 712 STps->eof = ST_EOD_1; 713 STp->frame_in_buffer = 1; 714 } 715 if (aux->frame_type == OS_FRAME_TYPE_DATA) { 716 blk_cnt = ntohs(aux->dat.dat_list[0].blk_cnt); 717 blk_sz = ntohl(aux->dat.dat_list[0].blk_sz); 718 STp->buffer->buffer_bytes = blk_cnt * blk_sz; 719 STp->buffer->read_pointer = 0; 720 STp->frame_in_buffer = 1; 721 722 /* See what block size was used to write file */ 723 if (STp->block_size != blk_sz && blk_sz > 0) { 724 printk(KERN_INFO 725 "%s:I: File was written with block size %d%c, currently %d%c, adjusted to match.\n", 726 name, blk_sz<1024?blk_sz:blk_sz/1024,blk_sz<1024?'b':'k', 727 STp->block_size<1024?STp->block_size:STp->block_size/1024, 728 STp->block_size<1024?'b':'k'); 729 STp->block_size = blk_sz; 730 STp->buffer->buffer_blocks = OS_DATA_SIZE / blk_sz; 731 } 732 STps->eof = ST_NOEOF; 733 } 734 STp->frame_seq_number = ntohl(aux->frame_seq_num); 735 STp->logical_blk_num = ntohl(aux->logical_blk_num); 736 return 1; 737 738err_out: 739 if (STp->read_error_frame == 0) 740 STp->read_error_frame = STp->first_frame_position - 1; 741 return 0; 742} 743 744/* 745 * Wait for the unit to become Ready 746 */ 747static int osst_wait_ready(struct osst_tape * STp, struct osst_request ** aSRpnt, 748 unsigned timeout, int initial_delay) 749{ 750 unsigned char cmd[MAX_COMMAND_SIZE]; 751 struct osst_request * SRpnt; 752 unsigned long startwait = jiffies; 753#if DEBUG 754 int dbg = debugging; 755 char * name = tape_name(STp); 756 757 printk(OSST_DEB_MSG "%s:D: Reached onstream wait ready\n", name); 758#endif 759 760 if (initial_delay > 0) 761 msleep(jiffies_to_msecs(initial_delay)); 762 763 memset(cmd, 0, MAX_COMMAND_SIZE); 764 cmd[0] = TEST_UNIT_READY; 765 766 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1); 767 *aSRpnt = SRpnt; 768 if (!SRpnt) return (-EBUSY); 769 770 while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) && 771 (( SRpnt->sense[2] == 2 && SRpnt->sense[12] == 4 && 772 (SRpnt->sense[13] == 1 || SRpnt->sense[13] == 8) ) || 773 ( SRpnt->sense[2] == 6 && SRpnt->sense[12] == 0x28 && 774 SRpnt->sense[13] == 0 ) )) { 775#if DEBUG 776 if (debugging) { 777 printk(OSST_DEB_MSG "%s:D: Sleeping in onstream wait ready\n", name); 778 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name); 779 debugging = 0; 780 } 781#endif 782 msleep(100); 783 784 memset(cmd, 0, MAX_COMMAND_SIZE); 785 cmd[0] = TEST_UNIT_READY; 786 787 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1); 788 } 789 *aSRpnt = SRpnt; 790#if DEBUG 791 debugging = dbg; 792#endif 793 if ( STp->buffer->syscall_result && 794 osst_write_error_recovery(STp, aSRpnt, 0) ) { 795#if DEBUG 796 printk(OSST_DEB_MSG "%s:D: Abnormal exit from onstream wait ready\n", name); 797 printk(OSST_DEB_MSG "%s:D: Result = %d, Sense: 0=%02x, 2=%02x, 12=%02x, 13=%02x\n", name, 798 STp->buffer->syscall_result, SRpnt->sense[0], SRpnt->sense[2], 799 SRpnt->sense[12], SRpnt->sense[13]); 800#endif 801 return (-EIO); 802 } 803#if DEBUG 804 printk(OSST_DEB_MSG "%s:D: Normal exit from onstream wait ready\n", name); 805#endif 806 return 0; 807} 808 809/* 810 * Wait for a tape to be inserted in the unit 811 */ 812static int osst_wait_for_medium(struct osst_tape * STp, struct osst_request ** aSRpnt, unsigned timeout) 813{ 814 unsigned char cmd[MAX_COMMAND_SIZE]; 815 struct osst_request * SRpnt; 816 unsigned long startwait = jiffies; 817#if DEBUG 818 int dbg = debugging; 819 char * name = tape_name(STp); 820 821 printk(OSST_DEB_MSG "%s:D: Reached onstream wait for medium\n", name); 822#endif 823 824 memset(cmd, 0, MAX_COMMAND_SIZE); 825 cmd[0] = TEST_UNIT_READY; 826 827 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1); 828 *aSRpnt = SRpnt; 829 if (!SRpnt) return (-EBUSY); 830 831 while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) && 832 SRpnt->sense[2] == 2 && SRpnt->sense[12] == 0x3a && SRpnt->sense[13] == 0 ) { 833#if DEBUG 834 if (debugging) { 835 printk(OSST_DEB_MSG "%s:D: Sleeping in onstream wait medium\n", name); 836 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name); 837 debugging = 0; 838 } 839#endif 840 msleep(100); 841 842 memset(cmd, 0, MAX_COMMAND_SIZE); 843 cmd[0] = TEST_UNIT_READY; 844 845 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1); 846 } 847 *aSRpnt = SRpnt; 848#if DEBUG 849 debugging = dbg; 850#endif 851 if ( STp->buffer->syscall_result && SRpnt->sense[2] != 2 && 852 SRpnt->sense[12] != 4 && SRpnt->sense[13] == 1) { 853#if DEBUG 854 printk(OSST_DEB_MSG "%s:D: Abnormal exit from onstream wait medium\n", name); 855 printk(OSST_DEB_MSG "%s:D: Result = %d, Sense: 0=%02x, 2=%02x, 12=%02x, 13=%02x\n", name, 856 STp->buffer->syscall_result, SRpnt->sense[0], SRpnt->sense[2], 857 SRpnt->sense[12], SRpnt->sense[13]); 858#endif 859 return 0; 860 } 861#if DEBUG 862 printk(OSST_DEB_MSG "%s:D: Normal exit from onstream wait medium\n", name); 863#endif 864 return 1; 865} 866 867static int osst_position_tape_and_confirm(struct osst_tape * STp, struct osst_request ** aSRpnt, int frame) 868{ 869 int retval; 870 871 osst_wait_ready(STp, aSRpnt, 15 * 60, 0); /* TODO - can this catch a write error? */ 872 retval = osst_set_frame_position(STp, aSRpnt, frame, 0); 873 if (retval) return (retval); 874 osst_wait_ready(STp, aSRpnt, 15 * 60, OSST_WAIT_POSITION_COMPLETE); 875 return (osst_get_frame_position(STp, aSRpnt)); 876} 877 878/* 879 * Wait for write(s) to complete 880 */ 881static int osst_flush_drive_buffer(struct osst_tape * STp, struct osst_request ** aSRpnt) 882{ 883 unsigned char cmd[MAX_COMMAND_SIZE]; 884 struct osst_request * SRpnt; 885 int result = 0; 886 int delay = OSST_WAIT_WRITE_COMPLETE; 887#if DEBUG 888 char * name = tape_name(STp); 889 890 printk(OSST_DEB_MSG "%s:D: Reached onstream flush drive buffer (write filemark)\n", name); 891#endif 892 893 memset(cmd, 0, MAX_COMMAND_SIZE); 894 cmd[0] = WRITE_FILEMARKS; 895 cmd[1] = 1; 896 897 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1); 898 *aSRpnt = SRpnt; 899 if (!SRpnt) return (-EBUSY); 900 if (STp->buffer->syscall_result) { 901 if ((SRpnt->sense[2] & 0x0f) == 2 && SRpnt->sense[12] == 4) { 902 if (SRpnt->sense[13] == 8) { 903 delay = OSST_WAIT_LONG_WRITE_COMPLETE; 904 } 905 } else 906 result = osst_write_error_recovery(STp, aSRpnt, 0); 907 } 908 result |= osst_wait_ready(STp, aSRpnt, 5 * 60, delay); 909 STp->ps[STp->partition].rw = OS_WRITING_COMPLETE; 910 911 return (result); 912} 913 914#define OSST_POLL_PER_SEC 10 915static int osst_wait_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int curr, int minlast, int to) 916{ 917 unsigned long startwait = jiffies; 918 char * name = tape_name(STp); 919#if DEBUG 920 char notyetprinted = 1; 921#endif 922 if (minlast >= 0 && STp->ps[STp->partition].rw != ST_READING) 923 printk(KERN_ERR "%s:A: Waiting for frame without having initialized read!\n", name); 924 925 while (time_before (jiffies, startwait + to*HZ)) 926 { 927 int result; 928 result = osst_get_frame_position(STp, aSRpnt); 929 if (result == -EIO) 930 if ((result = osst_write_error_recovery(STp, aSRpnt, 0)) == 0) 931 return 0; /* successful recovery leaves drive ready for frame */ 932 if (result < 0) break; 933 if (STp->first_frame_position == curr && 934 ((minlast < 0 && 935 (signed)STp->last_frame_position > (signed)curr + minlast) || 936 (minlast >= 0 && STp->cur_frames > minlast) 937 ) && result >= 0) 938 { 939#if DEBUG 940 if (debugging || time_after_eq(jiffies, startwait + 2*HZ/OSST_POLL_PER_SEC)) 941 printk (OSST_DEB_MSG 942 "%s:D: Succ wait f fr %i (>%i): %i-%i %i (%i): %3li.%li s\n", 943 name, curr, curr+minlast, STp->first_frame_position, 944 STp->last_frame_position, STp->cur_frames, 945 result, (jiffies-startwait)/HZ, 946 (((jiffies-startwait)%HZ)*10)/HZ); 947#endif 948 return 0; 949 } 950#if DEBUG 951 if (time_after_eq(jiffies, startwait + 2*HZ/OSST_POLL_PER_SEC) && notyetprinted) 952 { 953 printk (OSST_DEB_MSG "%s:D: Wait for frame %i (>%i): %i-%i %i (%i)\n", 954 name, curr, curr+minlast, STp->first_frame_position, 955 STp->last_frame_position, STp->cur_frames, result); 956 notyetprinted--; 957 } 958#endif 959 msleep(1000 / OSST_POLL_PER_SEC); 960 } 961#if DEBUG 962 printk (OSST_DEB_MSG "%s:D: Fail wait f fr %i (>%i): %i-%i %i: %3li.%li s\n", 963 name, curr, curr+minlast, STp->first_frame_position, 964 STp->last_frame_position, STp->cur_frames, 965 (jiffies-startwait)/HZ, (((jiffies-startwait)%HZ)*10)/HZ); 966#endif 967 return -EBUSY; 968} 969 970static int osst_recover_wait_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int writing) 971{ 972 struct osst_request * SRpnt; 973 unsigned char cmd[MAX_COMMAND_SIZE]; 974 unsigned long startwait = jiffies; 975 int retval = 1; 976 char * name = tape_name(STp); 977 978 if (writing) { 979 char mybuf[24]; 980 char * olddata = STp->buffer->b_data; 981 int oldsize = STp->buffer->buffer_size; 982 983 /* write zero fm then read pos - if shows write error, try to recover - if no progress, wait */ 984 985 memset(cmd, 0, MAX_COMMAND_SIZE); 986 cmd[0] = WRITE_FILEMARKS; 987 cmd[1] = 1; 988 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, 989 MAX_RETRIES, 1); 990 991 while (retval && time_before (jiffies, startwait + 5*60*HZ)) { 992 993 if (STp->buffer->syscall_result && (SRpnt->sense[2] & 0x0f) != 2) { 994 995 /* some failure - not just not-ready */ 996 retval = osst_write_error_recovery(STp, aSRpnt, 0); 997 break; 998 } 999 schedule_timeout_interruptible(HZ / OSST_POLL_PER_SEC); 1000 1001 STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24; 1002 memset(cmd, 0, MAX_COMMAND_SIZE); 1003 cmd[0] = READ_POSITION; 1004 1005 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 20, DMA_FROM_DEVICE, STp->timeout, 1006 MAX_RETRIES, 1); 1007 1008 retval = ( STp->buffer->syscall_result || (STp->buffer)->b_data[15] > 25 ); 1009 STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize; 1010 } 1011 if (retval) 1012 printk(KERN_ERR "%s:E: Device did not succeed to write buffered data\n", name); 1013 } else 1014 /* TODO - figure out which error conditions can be handled */ 1015 if (STp->buffer->syscall_result) 1016 printk(KERN_WARNING 1017 "%s:W: Recover_wait_frame(read) cannot handle %02x:%02x:%02x\n", name, 1018 (*aSRpnt)->sense[ 2] & 0x0f, 1019 (*aSRpnt)->sense[12], 1020 (*aSRpnt)->sense[13]); 1021 1022 return retval; 1023} 1024 1025/* 1026 * Read the next OnStream tape frame at the current location 1027 */ 1028static int osst_read_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int timeout) 1029{ 1030 unsigned char cmd[MAX_COMMAND_SIZE]; 1031 struct osst_request * SRpnt; 1032 int retval = 0; 1033#if DEBUG 1034 os_aux_t * aux = STp->buffer->aux; 1035 char * name = tape_name(STp); 1036#endif 1037 1038 if (STp->poll) 1039 if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, 0, timeout)) 1040 retval = osst_recover_wait_frame(STp, aSRpnt, 0); 1041 1042 memset(cmd, 0, MAX_COMMAND_SIZE); 1043 cmd[0] = READ_6; 1044 cmd[1] = 1; 1045 cmd[4] = 1; 1046 1047#if DEBUG 1048 if (debugging) 1049 printk(OSST_DEB_MSG "%s:D: Reading frame from OnStream tape\n", name); 1050#endif 1051 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_FROM_DEVICE, 1052 STp->timeout, MAX_RETRIES, 1); 1053 *aSRpnt = SRpnt; 1054 if (!SRpnt) 1055 return (-EBUSY); 1056 1057 if ((STp->buffer)->syscall_result) { 1058 retval = 1; 1059 if (STp->read_error_frame == 0) { 1060 STp->read_error_frame = STp->first_frame_position; 1061#if DEBUG 1062 printk(OSST_DEB_MSG "%s:D: Recording read error at %d\n", name, STp->read_error_frame); 1063#endif 1064 } 1065#if DEBUG 1066 if (debugging) 1067 printk(OSST_DEB_MSG "%s:D: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", 1068 name, 1069 SRpnt->sense[0], SRpnt->sense[1], 1070 SRpnt->sense[2], SRpnt->sense[3], 1071 SRpnt->sense[4], SRpnt->sense[5], 1072 SRpnt->sense[6], SRpnt->sense[7]); 1073#endif 1074 } 1075 else 1076 STp->first_frame_position++; 1077#if DEBUG 1078 if (debugging) { 1079 char sig[8]; int i; 1080 for (i=0;i<4;i++) 1081 sig[i] = aux->application_sig[i]<32?'^':aux->application_sig[i]; 1082 sig[4] = '\0'; 1083 printk(OSST_DEB_MSG 1084 "%s:D: AUX: %s UpdFrCt#%d Wpass#%d %s FrSeq#%d LogBlk#%d Qty=%d Sz=%d\n", name, sig, 1085 ntohl(aux->update_frame_cntr), ntohs(aux->partition.wrt_pass_cntr), 1086 aux->frame_type==1?"EOD":aux->frame_type==2?"MARK": 1087 aux->frame_type==8?"HEADR":aux->frame_type==0x80?"DATA":"FILL", 1088 ntohl(aux->frame_seq_num), ntohl(aux->logical_blk_num), 1089 ntohs(aux->dat.dat_list[0].blk_cnt), ntohl(aux->dat.dat_list[0].blk_sz) ); 1090 if (aux->frame_type==2) 1091 printk(OSST_DEB_MSG "%s:D: mark_cnt=%d, last_mark_ppos=%d, last_mark_lbn=%d\n", name, 1092 ntohl(aux->filemark_cnt), ntohl(aux->last_mark_ppos), ntohl(aux->last_mark_lbn)); 1093 printk(OSST_DEB_MSG "%s:D: Exit read frame from OnStream tape with code %d\n", name, retval); 1094 } 1095#endif 1096 return (retval); 1097} 1098 1099static int osst_initiate_read(struct osst_tape * STp, struct osst_request ** aSRpnt) 1100{ 1101 struct st_partstat * STps = &(STp->ps[STp->partition]); 1102 struct osst_request * SRpnt ; 1103 unsigned char cmd[MAX_COMMAND_SIZE]; 1104 int retval = 0; 1105 char * name = tape_name(STp); 1106 1107 if (STps->rw != ST_READING) { /* Initialize read operation */ 1108 if (STps->rw == ST_WRITING || STp->dirty) { 1109 STp->write_type = OS_WRITE_DATA; 1110 osst_flush_write_buffer(STp, aSRpnt); 1111 osst_flush_drive_buffer(STp, aSRpnt); 1112 } 1113 STps->rw = ST_READING; 1114 STp->frame_in_buffer = 0; 1115 1116 /* 1117 * Issue a read 0 command to get the OnStream drive 1118 * read frames into its buffer. 1119 */ 1120 memset(cmd, 0, MAX_COMMAND_SIZE); 1121 cmd[0] = READ_6; 1122 cmd[1] = 1; 1123 1124#if DEBUG 1125 printk(OSST_DEB_MSG "%s:D: Start Read Ahead on OnStream tape\n", name); 1126#endif 1127 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1); 1128 *aSRpnt = SRpnt; 1129 if ((retval = STp->buffer->syscall_result)) 1130 printk(KERN_WARNING "%s:W: Error starting read ahead\n", name); 1131 } 1132 1133 return retval; 1134} 1135 1136static int osst_get_logical_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, 1137 int frame_seq_number, int quiet) 1138{ 1139 struct st_partstat * STps = &(STp->ps[STp->partition]); 1140 char * name = tape_name(STp); 1141 int cnt = 0, 1142 bad = 0, 1143 past = 0, 1144 x, 1145 position; 1146 1147 /* 1148 * If we want just any frame (-1) and there is a frame in the buffer, return it 1149 */ 1150 if (frame_seq_number == -1 && STp->frame_in_buffer) { 1151#if DEBUG 1152 printk(OSST_DEB_MSG "%s:D: Frame %d still in buffer\n", name, STp->frame_seq_number); 1153#endif 1154 return (STps->eof); 1155 } 1156 /* 1157 * Search and wait for the next logical tape frame 1158 */ 1159 while (1) { 1160 if (cnt++ > 400) { 1161 printk(KERN_ERR "%s:E: Couldn't find logical frame %d, aborting\n", 1162 name, frame_seq_number); 1163 if (STp->read_error_frame) { 1164 osst_set_frame_position(STp, aSRpnt, STp->read_error_frame, 0); 1165#if DEBUG 1166 printk(OSST_DEB_MSG "%s:D: Repositioning tape to bad frame %d\n", 1167 name, STp->read_error_frame); 1168#endif 1169 STp->read_error_frame = 0; 1170 STp->abort_count++; 1171 } 1172 return (-EIO); 1173 } 1174#if DEBUG 1175 if (debugging) 1176 printk(OSST_DEB_MSG "%s:D: Looking for frame %d, attempt %d\n", 1177 name, frame_seq_number, cnt); 1178#endif 1179 if ( osst_initiate_read(STp, aSRpnt) 1180 || ( (!STp->frame_in_buffer) && osst_read_frame(STp, aSRpnt, 30) ) ) { 1181 if (STp->raw) 1182 return (-EIO); 1183 position = osst_get_frame_position(STp, aSRpnt); 1184 if (position >= 0xbae && position < 0xbb8) 1185 position = 0xbb8; 1186 else if (position > STp->eod_frame_ppos || ++bad == 10) { 1187 position = STp->read_error_frame - 1; 1188 bad = 0; 1189 } 1190 else { 1191 position += 29; 1192 cnt += 19; 1193 } 1194#if DEBUG 1195 printk(OSST_DEB_MSG "%s:D: Bad frame detected, positioning tape to block %d\n", 1196 name, position); 1197#endif 1198 osst_set_frame_position(STp, aSRpnt, position, 0); 1199 continue; 1200 } 1201 if (osst_verify_frame(STp, frame_seq_number, quiet)) 1202 break; 1203 if (osst_verify_frame(STp, -1, quiet)) { 1204 x = ntohl(STp->buffer->aux->frame_seq_num); 1205 if (STp->fast_open) { 1206 printk(KERN_WARNING 1207 "%s:W: Found logical frame %d instead of %d after fast open\n", 1208 name, x, frame_seq_number); 1209 STp->header_ok = 0; 1210 STp->read_error_frame = 0; 1211 return (-EIO); 1212 } 1213 if (x > frame_seq_number) { 1214 if (++past > 3) { 1215 /* positioning backwards did not bring us to the desired frame */ 1216 position = STp->read_error_frame - 1; 1217 } 1218 else { 1219 position = osst_get_frame_position(STp, aSRpnt) 1220 + frame_seq_number - x - 1; 1221 1222 if (STp->first_frame_position >= 3000 && position < 3000) 1223 position -= 10; 1224 } 1225#if DEBUG 1226 printk(OSST_DEB_MSG 1227 "%s:D: Found logical frame %d while looking for %d: back up %d\n", 1228 name, x, frame_seq_number, 1229 STp->first_frame_position - position); 1230#endif 1231 osst_set_frame_position(STp, aSRpnt, position, 0); 1232 cnt += 10; 1233 } 1234 else 1235 past = 0; 1236 } 1237 if (osst_get_frame_position(STp, aSRpnt) == 0xbaf) { 1238#if DEBUG 1239 printk(OSST_DEB_MSG "%s:D: Skipping config partition\n", name); 1240#endif 1241 osst_set_frame_position(STp, aSRpnt, 0xbb8, 0); 1242 cnt--; 1243 } 1244 STp->frame_in_buffer = 0; 1245 } 1246 if (cnt > 1) { 1247 STp->recover_count++; 1248 STp->recover_erreg++; 1249 printk(KERN_WARNING "%s:I: Don't worry, Read error at position %d recovered\n", 1250 name, STp->read_error_frame); 1251 } 1252 STp->read_count++; 1253 1254#if DEBUG 1255 if (debugging || STps->eof) 1256 printk(OSST_DEB_MSG 1257 "%s:D: Exit get logical frame (%d=>%d) from OnStream tape with code %d\n", 1258 name, frame_seq_number, STp->frame_seq_number, STps->eof); 1259#endif 1260 STp->fast_open = 0; 1261 STp->read_error_frame = 0; 1262 return (STps->eof); 1263} 1264 1265static int osst_seek_logical_blk(struct osst_tape * STp, struct osst_request ** aSRpnt, int logical_blk_num) 1266{ 1267 struct st_partstat * STps = &(STp->ps[STp->partition]); 1268 char * name = tape_name(STp); 1269 int retries = 0; 1270 int frame_seq_estimate, ppos_estimate, move; 1271 1272 if (logical_blk_num < 0) logical_blk_num = 0; 1273#if DEBUG 1274 printk(OSST_DEB_MSG "%s:D: Seeking logical block %d (now at %d, size %d%c)\n", 1275 name, logical_blk_num, STp->logical_blk_num, 1276 STp->block_size<1024?STp->block_size:STp->block_size/1024, 1277 STp->block_size<1024?'b':'k'); 1278#endif 1279 /* Do we know where we are? */ 1280 if (STps->drv_block >= 0) { 1281 move = logical_blk_num - STp->logical_blk_num; 1282 if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1; 1283 move /= (OS_DATA_SIZE / STp->block_size); 1284 frame_seq_estimate = STp->frame_seq_number + move; 1285 } else 1286 frame_seq_estimate = logical_blk_num * STp->block_size / OS_DATA_SIZE; 1287 1288 if (frame_seq_estimate < 2980) ppos_estimate = frame_seq_estimate + 10; 1289 else ppos_estimate = frame_seq_estimate + 20; 1290 while (++retries < 10) { 1291 if (ppos_estimate > STp->eod_frame_ppos-2) { 1292 frame_seq_estimate += STp->eod_frame_ppos - 2 - ppos_estimate; 1293 ppos_estimate = STp->eod_frame_ppos - 2; 1294 } 1295 if (frame_seq_estimate < 0) { 1296 frame_seq_estimate = 0; 1297 ppos_estimate = 10; 1298 } 1299 osst_set_frame_position(STp, aSRpnt, ppos_estimate, 0); 1300 if (osst_get_logical_frame(STp, aSRpnt, frame_seq_estimate, 1) >= 0) { 1301 /* we've located the estimated frame, now does it have our block? */ 1302 if (logical_blk_num < STp->logical_blk_num || 1303 logical_blk_num >= STp->logical_blk_num + ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt)) { 1304 if (STps->eof == ST_FM_HIT) 1305 move = logical_blk_num < STp->logical_blk_num? -2 : 1; 1306 else { 1307 move = logical_blk_num - STp->logical_blk_num; 1308 if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1; 1309 move /= (OS_DATA_SIZE / STp->block_size); 1310 } 1311 if (!move) move = logical_blk_num > STp->logical_blk_num ? 1 : -1; 1312#if DEBUG 1313 printk(OSST_DEB_MSG 1314 "%s:D: Seek retry %d at ppos %d fsq %d (est %d) lbn %d (need %d) move %d\n", 1315 name, retries, ppos_estimate, STp->frame_seq_number, frame_seq_estimate, 1316 STp->logical_blk_num, logical_blk_num, move); 1317#endif 1318 frame_seq_estimate += move; 1319 ppos_estimate += move; 1320 continue; 1321 } else { 1322 STp->buffer->read_pointer = (logical_blk_num - STp->logical_blk_num) * STp->block_size; 1323 STp->buffer->buffer_bytes -= STp->buffer->read_pointer; 1324 STp->logical_blk_num = logical_blk_num; 1325#if DEBUG 1326 printk(OSST_DEB_MSG 1327 "%s:D: Seek success at ppos %d fsq %d in_buf %d, bytes %d, ptr %d*%d\n", 1328 name, ppos_estimate, STp->frame_seq_number, STp->frame_in_buffer, 1329 STp->buffer->buffer_bytes, STp->buffer->read_pointer / STp->block_size, 1330 STp->block_size); 1331#endif 1332 STps->drv_file = ntohl(STp->buffer->aux->filemark_cnt); 1333 if (STps->eof == ST_FM_HIT) { 1334 STps->drv_file++; 1335 STps->drv_block = 0; 1336 } else { 1337 STps->drv_block = ntohl(STp->buffer->aux->last_mark_lbn)? 1338 STp->logical_blk_num - 1339 (STps->drv_file ? ntohl(STp->buffer->aux->last_mark_lbn) + 1 : 0): 1340 -1; 1341 } 1342 STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_NOEOF; 1343 return 0; 1344 } 1345 } 1346 if (osst_get_logical_frame(STp, aSRpnt, -1, 1) < 0) 1347 goto error; 1348 /* we are not yet at the estimated frame, adjust our estimate of its physical position */ 1349#if DEBUG 1350 printk(OSST_DEB_MSG "%s:D: Seek retry %d at ppos %d fsq %d (est %d) lbn %d (need %d)\n", 1351 name, retries, ppos_estimate, STp->frame_seq_number, frame_seq_estimate, 1352 STp->logical_blk_num, logical_blk_num); 1353#endif 1354 if (frame_seq_estimate != STp->frame_seq_number) 1355 ppos_estimate += frame_seq_estimate - STp->frame_seq_number; 1356 else 1357 break; 1358 } 1359error: 1360 printk(KERN_ERR "%s:E: Couldn't seek to logical block %d (at %d), %d retries\n", 1361 name, logical_blk_num, STp->logical_blk_num, retries); 1362 return (-EIO); 1363} 1364 1365/* The values below are based on the OnStream frame payload size of 32K == 2**15, 1366 * that is, OSST_FRAME_SHIFT + OSST_SECTOR_SHIFT must be 15. With a minimum block 1367 * size of 512 bytes, we need to be able to resolve 32K/512 == 64 == 2**6 positions 1368 * inside each frame. Finally, OSST_SECTOR_MASK == 2**OSST_FRAME_SHIFT - 1. 1369 */ 1370#define OSST_FRAME_SHIFT 6 1371#define OSST_SECTOR_SHIFT 9 1372#define OSST_SECTOR_MASK 0x03F 1373 1374static int osst_get_sector(struct osst_tape * STp, struct osst_request ** aSRpnt) 1375{ 1376 int sector; 1377#if DEBUG 1378 char * name = tape_name(STp); 1379 1380 printk(OSST_DEB_MSG 1381 "%s:D: Positioned at ppos %d, frame %d, lbn %d, file %d, blk %d, %cptr %d, eof %d\n", 1382 name, STp->first_frame_position, STp->frame_seq_number, STp->logical_blk_num, 1383 STp->ps[STp->partition].drv_file, STp->ps[STp->partition].drv_block, 1384 STp->ps[STp->partition].rw == ST_WRITING?'w':'r', 1385 STp->ps[STp->partition].rw == ST_WRITING?STp->buffer->buffer_bytes: 1386 STp->buffer->read_pointer, STp->ps[STp->partition].eof); 1387#endif 1388 /* do we know where we are inside a file? */ 1389 if (STp->ps[STp->partition].drv_block >= 0) { 1390 sector = (STp->frame_in_buffer ? STp->first_frame_position-1 : 1391 STp->first_frame_position) << OSST_FRAME_SHIFT; 1392 if (STp->ps[STp->partition].rw == ST_WRITING) 1393 sector |= (STp->buffer->buffer_bytes >> OSST_SECTOR_SHIFT) & OSST_SECTOR_MASK; 1394 else 1395 sector |= (STp->buffer->read_pointer >> OSST_SECTOR_SHIFT) & OSST_SECTOR_MASK; 1396 } else { 1397 sector = osst_get_frame_position(STp, aSRpnt); 1398 if (sector > 0) 1399 sector <<= OSST_FRAME_SHIFT; 1400 } 1401 return sector; 1402} 1403 1404static int osst_seek_sector(struct osst_tape * STp, struct osst_request ** aSRpnt, int sector) 1405{ 1406 struct st_partstat * STps = &(STp->ps[STp->partition]); 1407 int frame = sector >> OSST_FRAME_SHIFT, 1408 offset = (sector & OSST_SECTOR_MASK) << OSST_SECTOR_SHIFT, 1409 r; 1410#if DEBUG 1411 char * name = tape_name(STp); 1412 1413 printk(OSST_DEB_MSG "%s:D: Seeking sector %d in frame %d at offset %d\n", 1414 name, sector, frame, offset); 1415#endif 1416 if (frame < 0 || frame >= STp->capacity) return (-ENXIO); 1417 1418 if (frame <= STp->first_data_ppos) { 1419 STp->frame_seq_number = STp->logical_blk_num = STps->drv_file = STps->drv_block = 0; 1420 return (osst_set_frame_position(STp, aSRpnt, frame, 0)); 1421 } 1422 r = osst_set_frame_position(STp, aSRpnt, offset?frame:frame-1, 0); 1423 if (r < 0) return r; 1424 1425 r = osst_get_logical_frame(STp, aSRpnt, -1, 1); 1426 if (r < 0) return r; 1427 1428 if (osst_get_frame_position(STp, aSRpnt) != (offset?frame+1:frame)) return (-EIO); 1429 1430 if (offset) { 1431 STp->logical_blk_num += offset / STp->block_size; 1432 STp->buffer->read_pointer = offset; 1433 STp->buffer->buffer_bytes -= offset; 1434 } else { 1435 STp->frame_seq_number++; 1436 STp->frame_in_buffer = 0; 1437 STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt); 1438 STp->buffer->buffer_bytes = STp->buffer->read_pointer = 0; 1439 } 1440 STps->drv_file = ntohl(STp->buffer->aux->filemark_cnt); 1441 if (STps->eof == ST_FM_HIT) { 1442 STps->drv_file++; 1443 STps->drv_block = 0; 1444 } else { 1445 STps->drv_block = ntohl(STp->buffer->aux->last_mark_lbn)? 1446 STp->logical_blk_num - 1447 (STps->drv_file ? ntohl(STp->buffer->aux->last_mark_lbn) + 1 : 0): 1448 -1; 1449 } 1450 STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_NOEOF; 1451#if DEBUG 1452 printk(OSST_DEB_MSG 1453 "%s:D: Now positioned at ppos %d, frame %d, lbn %d, file %d, blk %d, rptr %d, eof %d\n", 1454 name, STp->first_frame_position, STp->frame_seq_number, STp->logical_blk_num, 1455 STps->drv_file, STps->drv_block, STp->buffer->read_pointer, STps->eof); 1456#endif 1457 return 0; 1458} 1459 1460/* 1461 * Read back the drive's internal buffer contents, as a part 1462 * of the write error recovery mechanism for old OnStream 1463 * firmware revisions. 1464 * Precondition for this function to work: all frames in the 1465 * drive's buffer must be of one type (DATA, MARK or EOD)! 1466 */ 1467static int osst_read_back_buffer_and_rewrite(struct osst_tape * STp, struct osst_request ** aSRpnt, 1468 unsigned int frame, unsigned int skip, int pending) 1469{ 1470 struct osst_request * SRpnt = * aSRpnt; 1471 unsigned char * buffer, * p; 1472 unsigned char cmd[MAX_COMMAND_SIZE]; 1473 int flag, new_frame, i; 1474 int nframes = STp->cur_frames; 1475 int blks_per_frame = ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt); 1476 int frame_seq_number = ntohl(STp->buffer->aux->frame_seq_num) 1477 - (nframes + pending - 1); 1478 int logical_blk_num = ntohl(STp->buffer->aux->logical_blk_num) 1479 - (nframes + pending - 1) * blks_per_frame; 1480 char * name = tape_name(STp); 1481 unsigned long startwait = jiffies; 1482#if DEBUG 1483 int dbg = debugging; 1484#endif 1485 1486 if ((buffer = vmalloc((nframes + 1) * OS_DATA_SIZE)) == NULL) 1487 return (-EIO); 1488 1489 printk(KERN_INFO "%s:I: Reading back %d frames from drive buffer%s\n", 1490 name, nframes, pending?" and one that was pending":""); 1491 1492 osst_copy_from_buffer(STp->buffer, (p = &buffer[nframes * OS_DATA_SIZE])); 1493#if DEBUG 1494 if (pending && debugging) 1495 printk(OSST_DEB_MSG "%s:D: Pending frame %d (lblk %d), data %02x %02x %02x %02x\n", 1496 name, frame_seq_number + nframes, 1497 logical_blk_num + nframes * blks_per_frame, 1498 p[0], p[1], p[2], p[3]); 1499#endif 1500 for (i = 0, p = buffer; i < nframes; i++, p += OS_DATA_SIZE) { 1501 1502 memset(cmd, 0, MAX_COMMAND_SIZE); 1503 cmd[0] = 0x3C; /* Buffer Read */ 1504 cmd[1] = 6; /* Retrieve Faulty Block */ 1505 cmd[7] = 32768 >> 8; 1506 cmd[8] = 32768 & 0xff; 1507 1508 SRpnt = osst_do_scsi(SRpnt, STp, cmd, OS_FRAME_SIZE, DMA_FROM_DEVICE, 1509 STp->timeout, MAX_RETRIES, 1); 1510 1511 if ((STp->buffer)->syscall_result || !SRpnt) { 1512 printk(KERN_ERR "%s:E: Failed to read frame back from OnStream buffer\n", name); 1513 vfree(buffer); 1514 *aSRpnt = SRpnt; 1515 return (-EIO); 1516 } 1517 osst_copy_from_buffer(STp->buffer, p); 1518#if DEBUG 1519 if (debugging) 1520 printk(OSST_DEB_MSG "%s:D: Read back logical frame %d, data %02x %02x %02x %02x\n", 1521 name, frame_seq_number + i, p[0], p[1], p[2], p[3]); 1522#endif 1523 } 1524 *aSRpnt = SRpnt; 1525 osst_get_frame_position(STp, aSRpnt); 1526 1527#if DEBUG 1528 printk(OSST_DEB_MSG "%s:D: Frames left in buffer: %d\n", name, STp->cur_frames); 1529#endif 1530 /* Write synchronously so we can be sure we're OK again and don't have to recover recursively */ 1531 /* In the header we don't actually re-write the frames that fail, just the ones after them */ 1532 1533 for (flag=1, new_frame=frame, p=buffer, i=0; i < nframes + pending; ) { 1534 1535 if (flag) { 1536 if (STp->write_type == OS_WRITE_HEADER) { 1537 i += skip; 1538 p += skip * OS_DATA_SIZE; 1539 } 1540 else if (new_frame < 2990 && new_frame+skip+nframes+pending >= 2990) 1541 new_frame = 3000-i; 1542 else 1543 new_frame += skip; 1544#if DEBUG 1545 printk(OSST_DEB_MSG "%s:D: Position to frame %d, write fseq %d\n", 1546 name, new_frame+i, frame_seq_number+i); 1547#endif 1548 osst_set_frame_position(STp, aSRpnt, new_frame + i, 0); 1549 osst_wait_ready(STp, aSRpnt, 60, OSST_WAIT_POSITION_COMPLETE); 1550 osst_get_frame_position(STp, aSRpnt); 1551 SRpnt = * aSRpnt; 1552 1553 if (new_frame > frame + 1000) { 1554 printk(KERN_ERR "%s:E: Failed to find writable tape media\n", name); 1555 vfree(buffer); 1556 return (-EIO); 1557 } 1558 if ( i >= nframes + pending ) break; 1559 flag = 0; 1560 } 1561 osst_copy_to_buffer(STp->buffer, p); 1562 /* 1563 * IMPORTANT: for error recovery to work, _never_ queue frames with mixed frame type! 1564 */ 1565 osst_init_aux(STp, STp->buffer->aux->frame_type, frame_seq_number+i, 1566 logical_blk_num + i*blks_per_frame, 1567 ntohl(STp->buffer->aux->dat.dat_list[0].blk_sz), blks_per_frame); 1568 memset(cmd, 0, MAX_COMMAND_SIZE); 1569 cmd[0] = WRITE_6; 1570 cmd[1] = 1; 1571 cmd[4] = 1; 1572 1573#if DEBUG 1574 if (debugging) 1575 printk(OSST_DEB_MSG 1576 "%s:D: About to write frame %d, seq %d, lbn %d, data %02x %02x %02x %02x\n", 1577 name, new_frame+i, frame_seq_number+i, logical_blk_num + i*blks_per_frame, 1578 p[0], p[1], p[2], p[3]); 1579#endif 1580 SRpnt = osst_do_scsi(SRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE, 1581 STp->timeout, MAX_RETRIES, 1); 1582 1583 if (STp->buffer->syscall_result) 1584 flag = 1; 1585 else { 1586 p += OS_DATA_SIZE; i++; 1587 1588 /* if we just sent the last frame, wait till all successfully written */ 1589 if ( i == nframes + pending ) { 1590#if DEBUG 1591 printk(OSST_DEB_MSG "%s:D: Check re-write successful\n", name); 1592#endif 1593 memset(cmd, 0, MAX_COMMAND_SIZE); 1594 cmd[0] = WRITE_FILEMARKS; 1595 cmd[1] = 1; 1596 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, 1597 STp->timeout, MAX_RETRIES, 1); 1598#if DEBUG 1599 if (debugging) { 1600 printk(OSST_DEB_MSG "%s:D: Sleeping in re-write wait ready\n", name); 1601 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name); 1602 debugging = 0; 1603 } 1604#endif 1605 flag = STp->buffer->syscall_result; 1606 while ( !flag && time_before(jiffies, startwait + 60*HZ) ) { 1607 1608 memset(cmd, 0, MAX_COMMAND_SIZE); 1609 cmd[0] = TEST_UNIT_READY; 1610 1611 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, 1612 MAX_RETRIES, 1); 1613 1614 if (SRpnt->sense[2] == 2 && SRpnt->sense[12] == 4 && 1615 (SRpnt->sense[13] == 1 || SRpnt->sense[13] == 8)) { 1616 /* in the process of becoming ready */ 1617 msleep(100); 1618 continue; 1619 } 1620 if (STp->buffer->syscall_result) 1621 flag = 1; 1622 break; 1623 } 1624#if DEBUG 1625 debugging = dbg; 1626 printk(OSST_DEB_MSG "%s:D: Wait re-write finished\n", name); 1627#endif 1628 } 1629 } 1630 *aSRpnt = SRpnt; 1631 if (flag) { 1632 if ((SRpnt->sense[ 2] & 0x0f) == 13 && 1633 SRpnt->sense[12] == 0 && 1634 SRpnt->sense[13] == 2) { 1635 printk(KERN_ERR "%s:E: Volume overflow in write error recovery\n", name); 1636 vfree(buffer); 1637 return (-EIO); /* hit end of tape = fail */ 1638 } 1639 i = ((SRpnt->sense[3] << 24) | 1640 (SRpnt->sense[4] << 16) | 1641 (SRpnt->sense[5] << 8) | 1642 SRpnt->sense[6] ) - new_frame; 1643 p = &buffer[i * OS_DATA_SIZE]; 1644#if DEBUG 1645 printk(OSST_DEB_MSG "%s:D: Additional write error at %d\n", name, new_frame+i); 1646#endif 1647 osst_get_frame_position(STp, aSRpnt); 1648#if DEBUG 1649 printk(OSST_DEB_MSG "%s:D: reported frame positions: host = %d, tape = %d, buffer = %d\n", 1650 name, STp->first_frame_position, STp->last_frame_position, STp->cur_frames); 1651#endif 1652 } 1653 } 1654 if (flag) { 1655 /* error recovery did not successfully complete */ 1656 printk(KERN_ERR "%s:D: Write error recovery failed in %s\n", name, 1657 STp->write_type == OS_WRITE_HEADER?"header":"body"); 1658 } 1659 if (!pending) 1660 osst_copy_to_buffer(STp->buffer, p); /* so buffer content == at entry in all cases */ 1661 vfree(buffer); 1662 return 0; 1663} 1664 1665static int osst_reposition_and_retry(struct osst_tape * STp, struct osst_request ** aSRpnt, 1666 unsigned int frame, unsigned int skip, int pending) 1667{ 1668 unsigned char cmd[MAX_COMMAND_SIZE]; 1669 struct osst_request * SRpnt; 1670 char * name = tape_name(STp); 1671 int expected = 0; 1672 int attempts = 1000 / skip; 1673 int flag = 1; 1674 unsigned long startwait = jiffies; 1675#if DEBUG 1676 int dbg = debugging; 1677#endif 1678 1679 while (attempts && time_before(jiffies, startwait + 60*HZ)) { 1680 if (flag) { 1681#if DEBUG 1682 debugging = dbg; 1683#endif 1684 if (frame < 2990 && frame+skip+STp->cur_frames+pending >= 2990) 1685 frame = 3000-skip; 1686 expected = frame+skip+STp->cur_frames+pending; 1687#if DEBUG 1688 printk(OSST_DEB_MSG "%s:D: Position to fppos %d, re-write from fseq %d\n", 1689 name, frame+skip, STp->frame_seq_number-STp->cur_frames-pending); 1690#endif 1691 osst_set_frame_position(STp, aSRpnt, frame + skip, 1); 1692 flag = 0; 1693 attempts--; 1694 schedule_timeout_interruptible(msecs_to_jiffies(100)); 1695 } 1696 if (osst_get_frame_position(STp, aSRpnt) < 0) { /* additional write error */ 1697#if DEBUG 1698 printk(OSST_DEB_MSG "%s:D: Addl error, host %d, tape %d, buffer %d\n", 1699 name, STp->first_frame_position, 1700 STp->last_frame_position, STp->cur_frames); 1701#endif 1702 frame = STp->last_frame_position; 1703 flag = 1; 1704 continue; 1705 } 1706 if (pending && STp->cur_frames < 50) { 1707 1708 memset(cmd, 0, MAX_COMMAND_SIZE); 1709 cmd[0] = WRITE_6; 1710 cmd[1] = 1; 1711 cmd[4] = 1; 1712#if DEBUG 1713 printk(OSST_DEB_MSG "%s:D: About to write pending fseq %d at fppos %d\n", 1714 name, STp->frame_seq_number-1, STp->first_frame_position); 1715#endif 1716 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE, 1717 STp->timeout, MAX_RETRIES, 1); 1718 *aSRpnt = SRpnt; 1719 1720 if (STp->buffer->syscall_result) { /* additional write error */ 1721 if ((SRpnt->sense[ 2] & 0x0f) == 13 && 1722 SRpnt->sense[12] == 0 && 1723 SRpnt->sense[13] == 2) { 1724 printk(KERN_ERR 1725 "%s:E: Volume overflow in write error recovery\n", 1726 name); 1727 break; /* hit end of tape = fail */ 1728 } 1729 flag = 1; 1730 } 1731 else 1732 pending = 0; 1733 1734 continue; 1735 } 1736 if (STp->cur_frames == 0) { 1737#if DEBUG 1738 debugging = dbg; 1739 printk(OSST_DEB_MSG "%s:D: Wait re-write finished\n", name); 1740#endif 1741 if (STp->first_frame_position != expected) { 1742 printk(KERN_ERR "%s:A: Actual position %d - expected %d\n", 1743 name, STp->first_frame_position, expected); 1744 return (-EIO); 1745 } 1746 return 0; 1747 } 1748#if DEBUG 1749 if (debugging) { 1750 printk(OSST_DEB_MSG "%s:D: Sleeping in re-write wait ready\n", name); 1751 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name); 1752 debugging = 0; 1753 } 1754#endif 1755 schedule_timeout_interruptible(msecs_to_jiffies(100)); 1756 } 1757 printk(KERN_ERR "%s:E: Failed to find valid tape media\n", name); 1758#if DEBUG 1759 debugging = dbg; 1760#endif 1761 return (-EIO); 1762} 1763 1764/* 1765 * Error recovery algorithm for the OnStream tape. 1766 */ 1767 1768static int osst_write_error_recovery(struct osst_tape * STp, struct osst_request ** aSRpnt, int pending) 1769{ 1770 struct osst_request * SRpnt = * aSRpnt; 1771 struct st_partstat * STps = & STp->ps[STp->partition]; 1772 char * name = tape_name(STp); 1773 int retval = 0; 1774 int rw_state; 1775 unsigned int frame, skip; 1776 1777 rw_state = STps->rw; 1778 1779 if ((SRpnt->sense[ 2] & 0x0f) != 3 1780 || SRpnt->sense[12] != 12 1781 || SRpnt->sense[13] != 0) { 1782#if DEBUG 1783 printk(OSST_DEB_MSG "%s:D: Write error recovery cannot handle %02x:%02x:%02x\n", name, 1784 SRpnt->sense[2], SRpnt->sense[12], SRpnt->sense[13]); 1785#endif 1786 return (-EIO); 1787 } 1788 frame = (SRpnt->sense[3] << 24) | 1789 (SRpnt->sense[4] << 16) | 1790 (SRpnt->sense[5] << 8) | 1791 SRpnt->sense[6]; 1792 skip = SRpnt->sense[9]; 1793 1794#if DEBUG 1795 printk(OSST_DEB_MSG "%s:D: Detected physical bad frame at %u, advised to skip %d\n", name, frame, skip); 1796#endif 1797 osst_get_frame_position(STp, aSRpnt); 1798#if DEBUG 1799 printk(OSST_DEB_MSG "%s:D: reported frame positions: host = %d, tape = %d\n", 1800 name, STp->first_frame_position, STp->last_frame_position); 1801#endif 1802 switch (STp->write_type) { 1803 case OS_WRITE_DATA: 1804 case OS_WRITE_EOD: 1805 case OS_WRITE_NEW_MARK: 1806 printk(KERN_WARNING 1807 "%s:I: Relocating %d buffered logical frames from position %u to %u\n", 1808 name, STp->cur_frames, frame, (frame + skip > 3000 && frame < 3000)?3000:frame + skip); 1809 if (STp->os_fw_rev >= 10600) 1810 retval = osst_reposition_and_retry(STp, aSRpnt, frame, skip, pending); 1811 else 1812 retval = osst_read_back_buffer_and_rewrite(STp, aSRpnt, frame, skip, pending); 1813 printk(KERN_WARNING "%s:%s: %sWrite error%srecovered\n", name, 1814 retval?"E" :"I", 1815 retval?"" :"Don't worry, ", 1816 retval?" not ":" "); 1817 break; 1818 case OS_WRITE_LAST_MARK: 1819 printk(KERN_ERR "%s:E: Bad frame in update last marker, fatal\n", name); 1820 osst_set_frame_position(STp, aSRpnt, frame + STp->cur_frames + pending, 0); 1821 retval = -EIO; 1822 break; 1823 case OS_WRITE_HEADER: 1824 printk(KERN_WARNING "%s:I: Bad frame in header partition, skipped\n", name); 1825 retval = osst_read_back_buffer_and_rewrite(STp, aSRpnt, frame, 1, pending); 1826 break; 1827 default: 1828 printk(KERN_INFO "%s:I: Bad frame in filler, ignored\n", name); 1829 osst_set_frame_position(STp, aSRpnt, frame + STp->cur_frames + pending, 0); 1830 } 1831 osst_get_frame_position(STp, aSRpnt); 1832#if DEBUG 1833 printk(OSST_DEB_MSG "%s:D: Positioning complete, cur_frames %d, pos %d, tape pos %d\n", 1834 name, STp->cur_frames, STp->first_frame_position, STp->last_frame_position); 1835 printk(OSST_DEB_MSG "%s:D: next logical frame to write: %d\n", name, STp->logical_blk_num); 1836#endif 1837 if (retval == 0) { 1838 STp->recover_count++; 1839 STp->recover_erreg++; 1840 } else 1841 STp->abort_count++; 1842 1843 STps->rw = rw_state; 1844 return retval; 1845} 1846 1847static int osst_space_over_filemarks_backward(struct osst_tape * STp, struct osst_request ** aSRpnt, 1848 int mt_op, int mt_count) 1849{ 1850 char * name = tape_name(STp); 1851 int cnt; 1852 int last_mark_ppos = -1; 1853 1854#if DEBUG 1855 printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_backwards %d %d\n", name, mt_op, mt_count); 1856#endif 1857 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 1858#if DEBUG 1859 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_bwd\n", name); 1860#endif 1861 return -EIO; 1862 } 1863 if (STp->linux_media_version >= 4) { 1864 /* 1865 * direct lookup in header filemark list 1866 */ 1867 cnt = ntohl(STp->buffer->aux->filemark_cnt); 1868 if (STp->header_ok && 1869 STp->header_cache != NULL && 1870 (cnt - mt_count) >= 0 && 1871 (cnt - mt_count) < OS_FM_TAB_MAX && 1872 (cnt - mt_count) < STp->filemark_cnt && 1873 STp->header_cache->dat_fm_tab.fm_tab_ent[cnt-1] == STp->buffer->aux->last_mark_ppos) 1874 1875 last_mark_ppos = ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt - mt_count]); 1876#if DEBUG 1877 if (STp->header_cache == NULL || (cnt - mt_count) < 0 || (cnt - mt_count) >= OS_FM_TAB_MAX) 1878 printk(OSST_DEB_MSG "%s:D: Filemark lookup fail due to %s\n", name, 1879 STp->header_cache == NULL?"lack of header cache":"count out of range"); 1880 else 1881 printk(OSST_DEB_MSG "%s:D: Filemark lookup: prev mark %d (%s), skip %d to %d\n", 1882 name, cnt, 1883 ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) || 1884 (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt-1] == 1885 STp->buffer->aux->last_mark_ppos))?"match":"error", 1886 mt_count, last_mark_ppos); 1887#endif 1888 if (last_mark_ppos > 10 && last_mark_ppos < STp->eod_frame_ppos) { 1889 osst_position_tape_and_confirm(STp, aSRpnt, last_mark_ppos); 1890 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 1891#if DEBUG 1892 printk(OSST_DEB_MSG 1893 "%s:D: Couldn't get logical blk num in space_filemarks\n", name); 1894#endif 1895 return (-EIO); 1896 } 1897 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) { 1898 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n", 1899 name, last_mark_ppos); 1900 return (-EIO); 1901 } 1902 goto found; 1903 } 1904#if DEBUG 1905 printk(OSST_DEB_MSG "%s:D: Reverting to scan filemark backwards\n", name); 1906#endif 1907 } 1908 cnt = 0; 1909 while (cnt != mt_count) { 1910 last_mark_ppos = ntohl(STp->buffer->aux->last_mark_ppos); 1911 if (last_mark_ppos == -1) 1912 return (-EIO); 1913#if DEBUG 1914 printk(OSST_DEB_MSG "%s:D: Positioning to last mark at %d\n", name, last_mark_ppos); 1915#endif 1916 osst_position_tape_and_confirm(STp, aSRpnt, last_mark_ppos); 1917 cnt++; 1918 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 1919#if DEBUG 1920 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", name); 1921#endif 1922 return (-EIO); 1923 } 1924 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) { 1925 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n", 1926 name, last_mark_ppos); 1927 return (-EIO); 1928 } 1929 } 1930found: 1931 if (mt_op == MTBSFM) { 1932 STp->frame_seq_number++; 1933 STp->frame_in_buffer = 0; 1934 STp->buffer->buffer_bytes = 0; 1935 STp->buffer->read_pointer = 0; 1936 STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt); 1937 } 1938 return 0; 1939} 1940 1941/* 1942 * ADRL 1.1 compatible "slow" space filemarks fwd version 1943 * 1944 * Just scans for the filemark sequentially. 1945 */ 1946static int osst_space_over_filemarks_forward_slow(struct osst_tape * STp, struct osst_request ** aSRpnt, 1947 int mt_op, int mt_count) 1948{ 1949 int cnt = 0; 1950#if DEBUG 1951 char * name = tape_name(STp); 1952 1953 printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_forward_slow %d %d\n", name, mt_op, mt_count); 1954#endif 1955 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 1956#if DEBUG 1957 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_fwd\n", name); 1958#endif 1959 return (-EIO); 1960 } 1961 while (1) { 1962 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 1963#if DEBUG 1964 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", name); 1965#endif 1966 return (-EIO); 1967 } 1968 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER) 1969 cnt++; 1970 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_EOD) { 1971#if DEBUG 1972 printk(OSST_DEB_MSG "%s:D: space_fwd: EOD reached\n", name); 1973#endif 1974 if (STp->first_frame_position > STp->eod_frame_ppos+1) { 1975#if DEBUG 1976 printk(OSST_DEB_MSG "%s:D: EOD position corrected (%d=>%d)\n", 1977 name, STp->eod_frame_ppos, STp->first_frame_position-1); 1978#endif 1979 STp->eod_frame_ppos = STp->first_frame_position-1; 1980 } 1981 return (-EIO); 1982 } 1983 if (cnt == mt_count) 1984 break; 1985 STp->frame_in_buffer = 0; 1986 } 1987 if (mt_op == MTFSF) { 1988 STp->frame_seq_number++; 1989 STp->frame_in_buffer = 0; 1990 STp->buffer->buffer_bytes = 0; 1991 STp->buffer->read_pointer = 0; 1992 STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt); 1993 } 1994 return 0; 1995} 1996 1997/* 1998 * Fast linux specific version of OnStream FSF 1999 */ 2000static int osst_space_over_filemarks_forward_fast(struct osst_tape * STp, struct osst_request ** aSRpnt, 2001 int mt_op, int mt_count) 2002{ 2003 char * name = tape_name(STp); 2004 int cnt = 0, 2005 next_mark_ppos = -1; 2006 2007#if DEBUG 2008 printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_forward_fast %d %d\n", name, mt_op, mt_count); 2009#endif 2010 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 2011#if DEBUG 2012 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_fwd\n", name); 2013#endif 2014 return (-EIO); 2015 } 2016 2017 if (STp->linux_media_version >= 4) { 2018 /* 2019 * direct lookup in header filemark list 2020 */ 2021 cnt = ntohl(STp->buffer->aux->filemark_cnt) - 1; 2022 if (STp->header_ok && 2023 STp->header_cache != NULL && 2024 (cnt + mt_count) < OS_FM_TAB_MAX && 2025 (cnt + mt_count) < STp->filemark_cnt && 2026 ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) || 2027 (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt] == STp->buffer->aux->last_mark_ppos))) 2028 2029 next_mark_ppos = ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt + mt_count]); 2030#if DEBUG 2031 if (STp->header_cache == NULL || (cnt + mt_count) >= OS_FM_TAB_MAX) 2032 printk(OSST_DEB_MSG "%s:D: Filemark lookup fail due to %s\n", name, 2033 STp->header_cache == NULL?"lack of header cache":"count out of range"); 2034 else 2035 printk(OSST_DEB_MSG "%s:D: Filemark lookup: prev mark %d (%s), skip %d to %d\n", 2036 name, cnt, 2037 ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) || 2038 (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt] == 2039 STp->buffer->aux->last_mark_ppos))?"match":"error", 2040 mt_count, next_mark_ppos); 2041#endif 2042 if (next_mark_ppos <= 10 || next_mark_ppos > STp->eod_frame_ppos) { 2043#if DEBUG 2044 printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name); 2045#endif 2046 return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count); 2047 } else { 2048 osst_position_tape_and_confirm(STp, aSRpnt, next_mark_ppos); 2049 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 2050#if DEBUG 2051 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", 2052 name); 2053#endif 2054 return (-EIO); 2055 } 2056 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) { 2057 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n", 2058 name, next_mark_ppos); 2059 return (-EIO); 2060 } 2061 if (ntohl(STp->buffer->aux->filemark_cnt) != cnt + mt_count) { 2062 printk(KERN_WARNING "%s:W: Expected to find marker %d at ppos %d, not %d\n", 2063 name, cnt+mt_count, next_mark_ppos, 2064 ntohl(STp->buffer->aux->filemark_cnt)); 2065 return (-EIO); 2066 } 2067 } 2068 } else { 2069 /* 2070 * Find nearest (usually previous) marker, then jump from marker to marker 2071 */ 2072 while (1) { 2073 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER) 2074 break; 2075 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_EOD) { 2076#if DEBUG 2077 printk(OSST_DEB_MSG "%s:D: space_fwd: EOD reached\n", name); 2078#endif 2079 return (-EIO); 2080 } 2081 if (ntohl(STp->buffer->aux->filemark_cnt) == 0) { 2082 if (STp->first_mark_ppos == -1) { 2083#if DEBUG 2084 printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name); 2085#endif 2086 return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count); 2087 } 2088 osst_position_tape_and_confirm(STp, aSRpnt, STp->first_mark_ppos); 2089 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 2090#if DEBUG 2091 printk(OSST_DEB_MSG 2092 "%s:D: Couldn't get logical blk num in space_filemarks_fwd_fast\n", 2093 name); 2094#endif 2095 return (-EIO); 2096 } 2097 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) { 2098 printk(KERN_WARNING "%s:W: Expected to find filemark at %d\n", 2099 name, STp->first_mark_ppos); 2100 return (-EIO); 2101 } 2102 } else { 2103 if (osst_space_over_filemarks_backward(STp, aSRpnt, MTBSF, 1) < 0) 2104 return (-EIO); 2105 mt_count++; 2106 } 2107 } 2108 cnt++; 2109 while (cnt != mt_count) { 2110 next_mark_ppos = ntohl(STp->buffer->aux->next_mark_ppos); 2111 if (!next_mark_ppos || next_mark_ppos > STp->eod_frame_ppos) { 2112#if DEBUG 2113 printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name); 2114#endif 2115 return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count - cnt); 2116 } 2117#if DEBUG 2118 else printk(OSST_DEB_MSG "%s:D: Positioning to next mark at %d\n", name, next_mark_ppos); 2119#endif 2120 osst_position_tape_and_confirm(STp, aSRpnt, next_mark_ppos); 2121 cnt++; 2122 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 2123#if DEBUG 2124 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", 2125 name); 2126#endif 2127 return (-EIO); 2128 } 2129 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) { 2130 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n", 2131 name, next_mark_ppos); 2132 return (-EIO); 2133 } 2134 } 2135 } 2136 if (mt_op == MTFSF) { 2137 STp->frame_seq_number++; 2138 STp->frame_in_buffer = 0; 2139 STp->buffer->buffer_bytes = 0; 2140 STp->buffer->read_pointer = 0; 2141 STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt); 2142 } 2143 return 0; 2144} 2145 2146/* 2147 * In debug mode, we want to see as many errors as possible 2148 * to test the error recovery mechanism. 2149 */ 2150#if DEBUG 2151static void osst_set_retries(struct osst_tape * STp, struct osst_request ** aSRpnt, int retries) 2152{ 2153 unsigned char cmd[MAX_COMMAND_SIZE]; 2154 struct osst_request * SRpnt = * aSRpnt; 2155 char * name = tape_name(STp); 2156 2157 memset(cmd, 0, MAX_COMMAND_SIZE); 2158 cmd[0] = MODE_SELECT; 2159 cmd[1] = 0x10; 2160 cmd[4] = NUMBER_RETRIES_PAGE_LENGTH + MODE_HEADER_LENGTH; 2161 2162 (STp->buffer)->b_data[0] = cmd[4] - 1; 2163 (STp->buffer)->b_data[1] = 0; /* Medium Type - ignoring */ 2164 (STp->buffer)->b_data[2] = 0; /* Reserved */ 2165 (STp->buffer)->b_data[3] = 0; /* Block Descriptor Length */ 2166 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = NUMBER_RETRIES_PAGE | (1 << 7); 2167 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 2; 2168 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 4; 2169 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = retries; 2170 2171 if (debugging) 2172 printk(OSST_DEB_MSG "%s:D: Setting number of retries on OnStream tape to %d\n", name, retries); 2173 2174 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1); 2175 *aSRpnt = SRpnt; 2176 2177 if ((STp->buffer)->syscall_result) 2178 printk (KERN_ERR "%s:D: Couldn't set retries to %d\n", name, retries); 2179} 2180#endif 2181 2182 2183static int osst_write_filemark(struct osst_tape * STp, struct osst_request ** aSRpnt) 2184{ 2185 int result; 2186 int this_mark_ppos = STp->first_frame_position; 2187 int this_mark_lbn = STp->logical_blk_num; 2188#if DEBUG 2189 char * name = tape_name(STp); 2190#endif 2191 2192 if (STp->raw) return 0; 2193 2194 STp->write_type = OS_WRITE_NEW_MARK; 2195#if DEBUG 2196 printk(OSST_DEB_MSG "%s:D: Writing Filemark %i at fppos %d (fseq %d, lblk %d)\n", 2197 name, STp->filemark_cnt, this_mark_ppos, STp->frame_seq_number, this_mark_lbn); 2198#endif 2199 STp->dirty = 1; 2200 result = osst_flush_write_buffer(STp, aSRpnt); 2201 result |= osst_flush_drive_buffer(STp, aSRpnt); 2202 STp->last_mark_ppos = this_mark_ppos; 2203 STp->last_mark_lbn = this_mark_lbn; 2204 if (STp->header_cache != NULL && STp->filemark_cnt < OS_FM_TAB_MAX) 2205 STp->header_cache->dat_fm_tab.fm_tab_ent[STp->filemark_cnt] = htonl(this_mark_ppos); 2206 if (STp->filemark_cnt++ == 0) 2207 STp->first_mark_ppos = this_mark_ppos; 2208 return result; 2209} 2210 2211static int osst_write_eod(struct osst_tape * STp, struct osst_request ** aSRpnt) 2212{ 2213 int result; 2214#if DEBUG 2215 char * name = tape_name(STp); 2216#endif 2217 2218 if (STp->raw) return 0; 2219 2220 STp->write_type = OS_WRITE_EOD; 2221 STp->eod_frame_ppos = STp->first_frame_position; 2222#if DEBUG 2223 printk(OSST_DEB_MSG "%s:D: Writing EOD at fppos %d (fseq %d, lblk %d)\n", name, 2224 STp->eod_frame_ppos, STp->frame_seq_number, STp->logical_blk_num); 2225#endif 2226 STp->dirty = 1; 2227 2228 result = osst_flush_write_buffer(STp, aSRpnt); 2229 result |= osst_flush_drive_buffer(STp, aSRpnt); 2230 STp->eod_frame_lfa = --(STp->frame_seq_number); 2231 return result; 2232} 2233 2234static int osst_write_filler(struct osst_tape * STp, struct osst_request ** aSRpnt, int where, int count) 2235{ 2236 char * name = tape_name(STp); 2237 2238#if DEBUG 2239 printk(OSST_DEB_MSG "%s:D: Reached onstream write filler group %d\n", name, where); 2240#endif 2241 osst_wait_ready(STp, aSRpnt, 60 * 5, 0); 2242 osst_set_frame_position(STp, aSRpnt, where, 0); 2243 STp->write_type = OS_WRITE_FILLER; 2244 while (count--) { 2245 memcpy(STp->buffer->b_data, "Filler", 6); 2246 STp->buffer->buffer_bytes = 6; 2247 STp->dirty = 1; 2248 if (osst_flush_write_buffer(STp, aSRpnt)) { 2249 printk(KERN_INFO "%s:I: Couldn't write filler frame\n", name); 2250 return (-EIO); 2251 } 2252 } 2253#if DEBUG 2254 printk(OSST_DEB_MSG "%s:D: Exiting onstream write filler group\n", name); 2255#endif 2256 return osst_flush_drive_buffer(STp, aSRpnt); 2257} 2258 2259static int __osst_write_header(struct osst_tape * STp, struct osst_request ** aSRpnt, int where, int count) 2260{ 2261 char * name = tape_name(STp); 2262 int result; 2263 2264#if DEBUG 2265 printk(OSST_DEB_MSG "%s:D: Reached onstream write header group %d\n", name, where); 2266#endif 2267 osst_wait_ready(STp, aSRpnt, 60 * 5, 0); 2268 osst_set_frame_position(STp, aSRpnt, where, 0); 2269 STp->write_type = OS_WRITE_HEADER; 2270 while (count--) { 2271 osst_copy_to_buffer(STp->buffer, (unsigned char *)STp->header_cache); 2272 STp->buffer->buffer_bytes = sizeof(os_header_t); 2273 STp->dirty = 1; 2274 if (osst_flush_write_buffer(STp, aSRpnt)) { 2275 printk(KERN_INFO "%s:I: Couldn't write header frame\n", name); 2276 return (-EIO); 2277 } 2278 } 2279 result = osst_flush_drive_buffer(STp, aSRpnt); 2280#if DEBUG 2281 printk(OSST_DEB_MSG "%s:D: Write onstream header group %s\n", name, result?"failed":"done"); 2282#endif 2283 return result; 2284} 2285 2286static int osst_write_header(struct osst_tape * STp, struct osst_request ** aSRpnt, int locate_eod) 2287{ 2288 os_header_t * header; 2289 int result; 2290 char * name = tape_name(STp); 2291 2292#if DEBUG 2293 printk(OSST_DEB_MSG "%s:D: Writing tape header\n", name); 2294#endif 2295 if (STp->raw) return 0; 2296 2297 if (STp->header_cache == NULL) { 2298 if ((STp->header_cache = vmalloc(sizeof(os_header_t))) == NULL) { 2299 printk(KERN_ERR "%s:E: Failed to allocate header cache\n", name); 2300 return (-ENOMEM); 2301 } 2302 memset(STp->header_cache, 0, sizeof(os_header_t)); 2303#if DEBUG 2304 printk(OSST_DEB_MSG "%s:D: Allocated and cleared memory for header cache\n", name); 2305#endif 2306 } 2307 if (STp->header_ok) STp->update_frame_cntr++; 2308 else STp->update_frame_cntr = 0; 2309 2310 header = STp->header_cache; 2311 strcpy(header->ident_str, "ADR_SEQ"); 2312 header->major_rev = 1; 2313 header->minor_rev = 4; 2314 header->ext_trk_tb_off = htons(17192); 2315 header->pt_par_num = 1; 2316 header->partition[0].partition_num = OS_DATA_PARTITION; 2317 header->partition[0].par_desc_ver = OS_PARTITION_VERSION; 2318 header->partition[0].wrt_pass_cntr = htons(STp->wrt_pass_cntr); 2319 header->partition[0].first_frame_ppos = htonl(STp->first_data_ppos); 2320 header->partition[0].last_frame_ppos = htonl(STp->capacity); 2321 header->partition[0].eod_frame_ppos = htonl(STp->eod_frame_ppos); 2322 header->cfg_col_width = htonl(20); 2323 header->dat_col_width = htonl(1500); 2324 header->qfa_col_width = htonl(0); 2325 header->ext_track_tb.nr_stream_part = 1; 2326 header->ext_track_tb.et_ent_sz = 32; 2327 header->ext_track_tb.dat_ext_trk_ey.et_part_num = 0; 2328 header->ext_track_tb.dat_ext_trk_ey.fmt = 1; 2329 header->ext_track_tb.dat_ext_trk_ey.fm_tab_off = htons(17736); 2330 header->ext_track_tb.dat_ext_trk_ey.last_hlb_hi = 0; 2331 header->ext_track_tb.dat_ext_trk_ey.last_hlb = htonl(STp->eod_frame_lfa); 2332 header->ext_track_tb.dat_ext_trk_ey.last_pp = htonl(STp->eod_frame_ppos); 2333 header->dat_fm_tab.fm_part_num = 0; 2334 header->dat_fm_tab.fm_tab_ent_sz = 4; 2335 header->dat_fm_tab.fm_tab_ent_cnt = htons(STp->filemark_cnt<OS_FM_TAB_MAX? 2336 STp->filemark_cnt:OS_FM_TAB_MAX); 2337 2338 result = __osst_write_header(STp, aSRpnt, 0xbae, 5); 2339 if (STp->update_frame_cntr == 0) 2340 osst_write_filler(STp, aSRpnt, 0xbb3, 5); 2341 result &= __osst_write_header(STp, aSRpnt, 5, 5); 2342 2343 if (locate_eod) { 2344#if DEBUG 2345 printk(OSST_DEB_MSG "%s:D: Locating back to eod frame addr %d\n", name, STp->eod_frame_ppos); 2346#endif 2347 osst_set_frame_position(STp, aSRpnt, STp->eod_frame_ppos, 0); 2348 } 2349 if (result) 2350 printk(KERN_ERR "%s:E: Write header failed\n", name); 2351 else { 2352 memcpy(STp->application_sig, "LIN4", 4); 2353 STp->linux_media = 1; 2354 STp->linux_media_version = 4; 2355 STp->header_ok = 1; 2356 } 2357 return result; 2358} 2359 2360static int osst_reset_header(struct osst_tape * STp, struct osst_request ** aSRpnt) 2361{ 2362 if (STp->header_cache != NULL) 2363 memset(STp->header_cache, 0, sizeof(os_header_t)); 2364 2365 STp->logical_blk_num = STp->frame_seq_number = 0; 2366 STp->frame_in_buffer = 0; 2367 STp->eod_frame_ppos = STp->first_data_ppos = 0x0000000A; 2368 STp->filemark_cnt = 0; 2369 STp->first_mark_ppos = STp->last_mark_ppos = STp->last_mark_lbn = -1; 2370 return osst_write_header(STp, aSRpnt, 1); 2371} 2372 2373static int __osst_analyze_headers(struct osst_tape * STp, struct osst_request ** aSRpnt, int ppos) 2374{ 2375 char * name = tape_name(STp); 2376 os_header_t * header; 2377 os_aux_t * aux; 2378 char id_string[8]; 2379 int linux_media_version, 2380 update_frame_cntr; 2381 2382 if (STp->raw) 2383 return 1; 2384 2385 if (ppos == 5 || ppos == 0xbae || STp->buffer->syscall_result) { 2386 if (osst_set_frame_position(STp, aSRpnt, ppos, 0)) 2387 printk(KERN_WARNING "%s:W: Couldn't position tape\n", name); 2388 osst_wait_ready(STp, aSRpnt, 60 * 15, 0); 2389 if (osst_initiate_read (STp, aSRpnt)) { 2390 printk(KERN_WARNING "%s:W: Couldn't initiate read\n", name); 2391 return 0; 2392 } 2393 } 2394 if (osst_read_frame(STp, aSRpnt, 180)) { 2395#if DEBUG 2396 printk(OSST_DEB_MSG "%s:D: Couldn't read header frame\n", name); 2397#endif 2398 return 0; 2399 } 2400 header = (os_header_t *) STp->buffer->b_data; /* warning: only first segment addressable */ 2401 aux = STp->buffer->aux; 2402 if (aux->frame_type != OS_FRAME_TYPE_HEADER) { 2403#if DEBUG 2404 printk(OSST_DEB_MSG "%s:D: Skipping non-header frame (%d)\n", name, ppos); 2405#endif 2406 return 0; 2407 } 2408 if (ntohl(aux->frame_seq_num) != 0 || 2409 ntohl(aux->logical_blk_num) != 0 || 2410 aux->partition.partition_num != OS_CONFIG_PARTITION || 2411 ntohl(aux->partition.first_frame_ppos) != 0 || 2412 ntohl(aux->partition.last_frame_ppos) != 0xbb7 ) { 2413#if DEBUG 2414 printk(OSST_DEB_MSG "%s:D: Invalid header frame (%d,%d,%d,%d,%d)\n", name, 2415 ntohl(aux->frame_seq_num), ntohl(aux->logical_blk_num), 2416 aux->partition.partition_num, ntohl(aux->partition.first_frame_ppos), 2417 ntohl(aux->partition.last_frame_ppos)); 2418#endif 2419 return 0; 2420 } 2421 if (strncmp(header->ident_str, "ADR_SEQ", 7) != 0 && 2422 strncmp(header->ident_str, "ADR-SEQ", 7) != 0) { 2423 strlcpy(id_string, header->ident_str, 8); 2424#if DEBUG 2425 printk(OSST_DEB_MSG "%s:D: Invalid header identification string %s\n", name, id_string); 2426#endif 2427 return 0; 2428 } 2429 update_frame_cntr = ntohl(aux->update_frame_cntr); 2430 if (update_frame_cntr < STp->update_frame_cntr) { 2431#if DEBUG 2432 printk(OSST_DEB_MSG "%s:D: Skipping frame %d with update_frame_counter %d<%d\n", 2433 name, ppos, update_frame_cntr, STp->update_frame_cntr); 2434#endif 2435 return 0; 2436 } 2437 if (header->major_rev != 1 || header->minor_rev != 4 ) { 2438#if DEBUG 2439 printk(OSST_DEB_MSG "%s:D: %s revision %d.%d detected (1.4 supported)\n", 2440 name, (header->major_rev != 1 || header->minor_rev < 2 || 2441 header->minor_rev > 4 )? "Invalid" : "Warning:", 2442 header->major_rev, header->minor_rev); 2443#endif 2444 if (header->major_rev != 1 || header->minor_rev < 2 || header->minor_rev > 4) 2445 return 0; 2446 } 2447#if DEBUG 2448 if (header->pt_par_num != 1) 2449 printk(KERN_INFO "%s:W: %d partitions defined, only one supported\n", 2450 name, header->pt_par_num); 2451#endif 2452 memcpy(id_string, aux->application_sig, 4); 2453 id_string[4] = 0; 2454 if (memcmp(id_string, "LIN", 3) == 0) { 2455 STp->linux_media = 1; 2456 linux_media_version = id_string[3] - '0'; 2457 if (linux_media_version != 4) 2458 printk(KERN_INFO "%s:I: Linux media version %d detected (current 4)\n", 2459 name, linux_media_version); 2460 } else { 2461 printk(KERN_WARNING "%s:W: Non Linux media detected (%s)\n", name, id_string); 2462 return 0; 2463 } 2464 if (linux_media_version < STp->linux_media_version) { 2465#if DEBUG 2466 printk(OSST_DEB_MSG "%s:D: Skipping frame %d with linux_media_version %d\n", 2467 name, ppos, linux_media_version); 2468#endif 2469 return 0; 2470 } 2471 if (linux_media_version > STp->linux_media_version) { 2472#if DEBUG 2473 printk(OSST_DEB_MSG "%s:D: Frame %d sets linux_media_version to %d\n", 2474 name, ppos, linux_media_version); 2475#endif 2476 memcpy(STp->application_sig, id_string, 5); 2477 STp->linux_media_version = linux_media_version; 2478 STp->update_frame_cntr = -1; 2479 } 2480 if (update_frame_cntr > STp->update_frame_cntr) { 2481#if DEBUG 2482 printk(OSST_DEB_MSG "%s:D: Frame %d sets update_frame_counter to %d\n", 2483 name, ppos, update_frame_cntr); 2484#endif 2485 if (STp->header_cache == NULL) { 2486 if ((STp->header_cache = vmalloc(sizeof(os_header_t))) == NULL) { 2487 printk(KERN_ERR "%s:E: Failed to allocate header cache\n", name); 2488 return 0; 2489 } 2490#if DEBUG 2491 printk(OSST_DEB_MSG "%s:D: Allocated memory for header cache\n", name); 2492#endif 2493 } 2494 osst_copy_from_buffer(STp->buffer, (unsigned char *)STp->header_cache); 2495 header = STp->header_cache; /* further accesses from cached (full) copy */ 2496 2497 STp->wrt_pass_cntr = ntohs(header->partition[0].wrt_pass_cntr); 2498 STp->first_data_ppos = ntohl(header->partition[0].first_frame_ppos); 2499 STp->eod_frame_ppos = ntohl(header->partition[0].eod_frame_ppos); 2500 STp->eod_frame_lfa = ntohl(header->ext_track_tb.dat_ext_trk_ey.last_hlb); 2501 STp->filemark_cnt = ntohl(aux->filemark_cnt); 2502 STp->first_mark_ppos = ntohl(aux->next_mark_ppos); 2503 STp->last_mark_ppos = ntohl(aux->last_mark_ppos); 2504 STp->last_mark_lbn = ntohl(aux->last_mark_lbn); 2505 STp->update_frame_cntr = update_frame_cntr; 2506#if DEBUG 2507 printk(OSST_DEB_MSG "%s:D: Detected write pass %d, update frame counter %d, filemark counter %d\n", 2508 name, STp->wrt_pass_cntr, STp->update_frame_cntr, STp->filemark_cnt); 2509 printk(OSST_DEB_MSG "%s:D: first data frame on tape = %d, last = %d, eod frame = %d\n", name, 2510 STp->first_data_ppos, 2511 ntohl(header->partition[0].last_frame_ppos), 2512 ntohl(header->partition[0].eod_frame_ppos)); 2513 printk(OSST_DEB_MSG "%s:D: first mark on tape = %d, last = %d, eod frame = %d\n", 2514 name, STp->first_mark_ppos, STp->last_mark_ppos, STp->eod_frame_ppos); 2515#endif 2516 if (header->minor_rev < 4 && STp->linux_media_version == 4) { 2517#if DEBUG 2518 printk(OSST_DEB_MSG "%s:D: Moving filemark list to ADR 1.4 location\n", name); 2519#endif 2520 memcpy((void *)header->dat_fm_tab.fm_tab_ent, 2521 (void *)header->old_filemark_list, sizeof(header->dat_fm_tab.fm_tab_ent)); 2522 memset((void *)header->old_filemark_list, 0, sizeof(header->old_filemark_list)); 2523 } 2524 if (header->minor_rev == 4 && 2525 (header->ext_trk_tb_off != htons(17192) || 2526 header->partition[0].partition_num != OS_DATA_PARTITION || 2527 header->partition[0].par_desc_ver != OS_PARTITION_VERSION || 2528 header->partition[0].last_frame_ppos != htonl(STp->capacity) || 2529 header->cfg_col_width != htonl(20) || 2530 header->dat_col_width != htonl(1500) || 2531 header->qfa_col_width != htonl(0) || 2532 header->ext_track_tb.nr_stream_part != 1 || 2533 header->ext_track_tb.et_ent_sz != 32 || 2534 header->ext_track_tb.dat_ext_trk_ey.et_part_num != OS_DATA_PARTITION || 2535 header->ext_track_tb.dat_ext_trk_ey.fmt != 1 || 2536 header->ext_track_tb.dat_ext_trk_ey.fm_tab_off != htons(17736) || 2537 header->ext_track_tb.dat_ext_trk_ey.last_hlb_hi != 0 || 2538 header->ext_track_tb.dat_ext_trk_ey.last_pp != htonl(STp->eod_frame_ppos) || 2539 header->dat_fm_tab.fm_part_num != OS_DATA_PARTITION || 2540 header->dat_fm_tab.fm_tab_ent_sz != 4 || 2541 header->dat_fm_tab.fm_tab_ent_cnt != 2542 htons(STp->filemark_cnt<OS_FM_TAB_MAX?STp->filemark_cnt:OS_FM_TAB_MAX))) 2543 printk(KERN_WARNING "%s:W: Failed consistency check ADR 1.4 format\n", name); 2544 2545 } 2546 2547 return 1; 2548} 2549 2550static int osst_analyze_headers(struct osst_tape * STp, struct osst_request ** aSRpnt) 2551{ 2552 int position, ppos; 2553 int first, last; 2554 int valid = 0; 2555 char * name = tape_name(STp); 2556 2557 position = osst_get_frame_position(STp, aSRpnt); 2558 2559 if (STp->raw) { 2560 STp->header_ok = STp->linux_media = 1; 2561 STp->linux_media_version = 0; 2562 return 1; 2563 } 2564 STp->header_ok = STp->linux_media = STp->linux_media_version = 0; 2565 STp->wrt_pass_cntr = STp->update_frame_cntr = -1; 2566 STp->eod_frame_ppos = STp->first_data_ppos = -1; 2567 STp->first_mark_ppos = STp->last_mark_ppos = STp->last_mark_lbn = -1; 2568#if DEBUG 2569 printk(OSST_DEB_MSG "%s:D: Reading header\n", name); 2570#endif 2571 2572 /* optimization for speed - if we are positioned at ppos 10, read second group first */ 2573 /* TODO try the ADR 1.1 locations for the second group if we have no valid one yet... */ 2574 2575 first = position==10?0xbae: 5; 2576 last = position==10?0xbb3:10; 2577 2578 for (ppos = first; ppos < last; ppos++) 2579 if (__osst_analyze_headers(STp, aSRpnt, ppos)) 2580 valid = 1; 2581 2582 first = position==10? 5:0xbae; 2583 last = position==10?10:0xbb3; 2584 2585 for (ppos = first; ppos < last; ppos++) 2586 if (__osst_analyze_headers(STp, aSRpnt, ppos)) 2587 valid = 1; 2588 2589 if (!valid) { 2590 printk(KERN_ERR "%s:E: Failed to find valid ADRL header, new media?\n", name); 2591 STp->eod_frame_ppos = STp->first_data_ppos = 0; 2592 osst_set_frame_position(STp, aSRpnt, 10, 0); 2593 return 0; 2594 } 2595 if (position <= STp->first_data_ppos) { 2596 position = STp->first_data_ppos; 2597 STp->ps[0].drv_file = STp->ps[0].drv_block = STp->frame_seq_number = STp->logical_blk_num = 0; 2598 } 2599 osst_set_frame_position(STp, aSRpnt, position, 0); 2600 STp->header_ok = 1; 2601 2602 return 1; 2603} 2604 2605static int osst_verify_position(struct osst_tape * STp, struct osst_request ** aSRpnt) 2606{ 2607 int frame_position = STp->first_frame_position; 2608 int frame_seq_numbr = STp->frame_seq_number; 2609 int logical_blk_num = STp->logical_blk_num; 2610 int halfway_frame = STp->frame_in_buffer; 2611 int read_pointer = STp->buffer->read_pointer; 2612 int prev_mark_ppos = -1; 2613 int actual_mark_ppos, i, n; 2614#if DEBUG 2615 char * name = tape_name(STp); 2616 2617 printk(OSST_DEB_MSG "%s:D: Verify that the tape is really the one we think before writing\n", name); 2618#endif 2619 osst_set_frame_position(STp, aSRpnt, frame_position - 1, 0); 2620 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) { 2621#if DEBUG 2622 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in verify_position\n", name); 2623#endif 2624 return (-EIO); 2625 } 2626 if (STp->linux_media_version >= 4) { 2627 for (i=0; i<STp->filemark_cnt; i++) 2628 if ((n=ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i])) < frame_position) 2629 prev_mark_ppos = n; 2630 } else 2631 prev_mark_ppos = frame_position - 1; /* usually - we don't really know */ 2632 actual_mark_ppos = STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER ? 2633 frame_position - 1 : ntohl(STp->buffer->aux->last_mark_ppos); 2634 if (frame_position != STp->first_frame_position || 2635 frame_seq_numbr != STp->frame_seq_number + (halfway_frame?0:1) || 2636 prev_mark_ppos != actual_mark_ppos ) { 2637#if DEBUG 2638 printk(OSST_DEB_MSG "%s:D: Block mismatch: fppos %d-%d, fseq %d-%d, mark %d-%d\n", name, 2639 STp->first_frame_position, frame_position, 2640 STp->frame_seq_number + (halfway_frame?0:1), 2641 frame_seq_numbr, actual_mark_ppos, prev_mark_ppos); 2642#endif 2643 return (-EIO); 2644 } 2645 if (halfway_frame) { 2646 /* prepare buffer for append and rewrite on top of original */ 2647 osst_set_frame_position(STp, aSRpnt, frame_position - 1, 0); 2648 STp->buffer->buffer_bytes = read_pointer; 2649 STp->ps[STp->partition].rw = ST_WRITING; 2650 STp->dirty = 1; 2651 } 2652 STp->frame_in_buffer = halfway_frame; 2653 STp->frame_seq_number = frame_seq_numbr; 2654 STp->logical_blk_num = logical_blk_num; 2655 return 0; 2656} 2657 2658/* Acc. to OnStream, the vers. numbering is the following: 2659 * X.XX for released versions (X=digit), 2660 * XXXY for unreleased versions (Y=letter) 2661 * Ordering 1.05 < 106A < 106B < ... < 106a < ... < 1.06 2662 * This fn makes monoton numbers out of this scheme ... 2663 */ 2664static unsigned int osst_parse_firmware_rev (const char * str) 2665{ 2666 if (str[1] == '.') { 2667 return (str[0]-'0')*10000 2668 +(str[2]-'0')*1000 2669 +(str[3]-'0')*100; 2670 } else { 2671 return (str[0]-'0')*10000 2672 +(str[1]-'0')*1000 2673 +(str[2]-'0')*100 - 100 2674 +(str[3]-'@'); 2675 } 2676} 2677 2678/* 2679 * Configure the OnStream SCII tape drive for default operation 2680 */ 2681static int osst_configure_onstream(struct osst_tape *STp, struct osst_request ** aSRpnt) 2682{ 2683 unsigned char cmd[MAX_COMMAND_SIZE]; 2684 char * name = tape_name(STp); 2685 struct osst_request * SRpnt = * aSRpnt; 2686 osst_mode_parameter_header_t * header; 2687 osst_block_size_page_t * bs; 2688 osst_capabilities_page_t * cp; 2689 osst_tape_paramtr_page_t * prm; 2690 int drive_buffer_size; 2691 2692 if (STp->ready != ST_READY) { 2693#if DEBUG 2694 printk(OSST_DEB_MSG "%s:D: Not Ready\n", name); 2695#endif 2696 return (-EIO); 2697 } 2698 2699 if (STp->os_fw_rev < 10600) { 2700 printk(KERN_INFO "%s:I: Old OnStream firmware revision detected (%s),\n", name, STp->device->rev); 2701 printk(KERN_INFO "%s:I: an upgrade to version 1.06 or above is recommended\n", name); 2702 } 2703 2704 /* 2705 * Configure 32.5KB (data+aux) frame size. 2706 * Get the current frame size from the block size mode page 2707 */ 2708 memset(cmd, 0, MAX_COMMAND_SIZE); 2709 cmd[0] = MODE_SENSE; 2710 cmd[1] = 8; 2711 cmd[2] = BLOCK_SIZE_PAGE; 2712 cmd[4] = BLOCK_SIZE_PAGE_LENGTH + MODE_HEADER_LENGTH; 2713 2714 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1); 2715 if (SRpnt == NULL) { 2716#if DEBUG 2717 printk(OSST_DEB_MSG "osst :D: Busy\n"); 2718#endif 2719 return (-EBUSY); 2720 } 2721 *aSRpnt = SRpnt; 2722 if ((STp->buffer)->syscall_result != 0) { 2723 printk (KERN_ERR "%s:E: Can't get tape block size mode page\n", name); 2724 return (-EIO); 2725 } 2726 2727 header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data; 2728 bs = (osst_block_size_page_t *) ((STp->buffer)->b_data + sizeof(osst_mode_parameter_header_t) + header->bdl); 2729 2730#if DEBUG 2731 printk(OSST_DEB_MSG "%s:D: 32KB play back: %s\n", name, bs->play32 ? "Yes" : "No"); 2732 printk(OSST_DEB_MSG "%s:D: 32.5KB play back: %s\n", name, bs->play32_5 ? "Yes" : "No"); 2733 printk(OSST_DEB_MSG "%s:D: 32KB record: %s\n", name, bs->record32 ? "Yes" : "No"); 2734 printk(OSST_DEB_MSG "%s:D: 32.5KB record: %s\n", name, bs->record32_5 ? "Yes" : "No"); 2735#endif 2736 2737 /* 2738 * Configure default auto columns mode, 32.5KB transfer mode 2739 */ 2740 bs->one = 1; 2741 bs->play32 = 0; 2742 bs->play32_5 = 1; 2743 bs->record32 = 0; 2744 bs->record32_5 = 1; 2745 2746 memset(cmd, 0, MAX_COMMAND_SIZE); 2747 cmd[0] = MODE_SELECT; 2748 cmd[1] = 0x10; 2749 cmd[4] = BLOCK_SIZE_PAGE_LENGTH + MODE_HEADER_LENGTH; 2750 2751 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1); 2752 *aSRpnt = SRpnt; 2753 if ((STp->buffer)->syscall_result != 0) { 2754 printk (KERN_ERR "%s:E: Couldn't set tape block size mode page\n", name); 2755 return (-EIO); 2756 } 2757 2758#if DEBUG 2759 printk(KERN_INFO "%s:D: Drive Block Size changed to 32.5K\n", name); 2760 /* 2761 * In debug mode, we want to see as many errors as possible 2762 * to test the error recovery mechanism. 2763 */ 2764 osst_set_retries(STp, aSRpnt, 0); 2765 SRpnt = * aSRpnt; 2766#endif 2767 2768 /* 2769 * Set vendor name to 'LIN4' for "Linux support version 4". 2770 */ 2771 2772 memset(cmd, 0, MAX_COMMAND_SIZE); 2773 cmd[0] = MODE_SELECT; 2774 cmd[1] = 0x10; 2775 cmd[4] = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH; 2776 2777 header->mode_data_length = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH - 1; 2778 header->medium_type = 0; /* Medium Type - ignoring */ 2779 header->dsp = 0; /* Reserved */ 2780 header->bdl = 0; /* Block Descriptor Length */ 2781 2782 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = VENDOR_IDENT_PAGE | (1 << 7); 2783 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 6; 2784 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 'L'; 2785 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = 'I'; 2786 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 4] = 'N'; 2787 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 5] = '4'; 2788 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 6] = 0; 2789 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 7] = 0; 2790 2791 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1); 2792 *aSRpnt = SRpnt; 2793 2794 if ((STp->buffer)->syscall_result != 0) { 2795 printk (KERN_ERR "%s:E: Couldn't set vendor name to %s\n", name, 2796 (char *) ((STp->buffer)->b_data + MODE_HEADER_LENGTH + 2)); 2797 return (-EIO); 2798 } 2799 2800 memset(cmd, 0, MAX_COMMAND_SIZE); 2801 cmd[0] = MODE_SENSE; 2802 cmd[1] = 8; 2803 cmd[2] = CAPABILITIES_PAGE; 2804 cmd[4] = CAPABILITIES_PAGE_LENGTH + MODE_HEADER_LENGTH; 2805 2806 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1); 2807 *aSRpnt = SRpnt; 2808 2809 if ((STp->buffer)->syscall_result != 0) { 2810 printk (KERN_ERR "%s:E: Can't get capabilities page\n", name); 2811 return (-EIO); 2812 } 2813 2814 header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data; 2815 cp = (osst_capabilities_page_t *) ((STp->buffer)->b_data + 2816 sizeof(osst_mode_parameter_header_t) + header->bdl); 2817 2818 drive_buffer_size = ntohs(cp->buffer_size) / 2; 2819 2820 memset(cmd, 0, MAX_COMMAND_SIZE); 2821 cmd[0] = MODE_SENSE; 2822 cmd[1] = 8; 2823 cmd[2] = TAPE_PARAMTR_PAGE; 2824 cmd[4] = TAPE_PARAMTR_PAGE_LENGTH + MODE_HEADER_LENGTH; 2825 2826 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1); 2827 *aSRpnt = SRpnt; 2828 2829 if ((STp->buffer)->syscall_result != 0) { 2830 printk (KERN_ERR "%s:E: Can't get tape parameter page\n", name); 2831 return (-EIO); 2832 } 2833 2834 header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data; 2835 prm = (osst_tape_paramtr_page_t *) ((STp->buffer)->b_data + 2836 sizeof(osst_mode_parameter_header_t) + header->bdl); 2837 2838 STp->density = prm->density; 2839 STp->capacity = ntohs(prm->segtrk) * ntohs(prm->trks); 2840#if DEBUG 2841 printk(OSST_DEB_MSG "%s:D: Density %d, tape length: %dMB, drive buffer size: %dKB\n", 2842 name, STp->density, STp->capacity / 32, drive_buffer_size); 2843#endif 2844 2845 return 0; 2846 2847} 2848 2849 2850/* Step over EOF if it has been inadvertently crossed (ioctl not used because 2851 it messes up the block number). */ 2852static int cross_eof(struct osst_tape *STp, struct osst_request ** aSRpnt, int forward) 2853{ 2854 int result; 2855 char * name = tape_name(STp); 2856 2857#if DEBUG 2858 if (debugging) 2859 printk(OSST_DEB_MSG "%s:D: Stepping over filemark %s.\n", 2860 name, forward ? "forward" : "backward"); 2861#endif 2862 2863 if (forward) { 2864 /* assumes that the filemark is already read by the drive, so this is low cost */ 2865 result = osst_space_over_filemarks_forward_slow(STp, aSRpnt, MTFSF, 1); 2866 } 2867 else 2868 /* assumes this is only called if we just read the filemark! */ 2869 result = osst_seek_logical_blk(STp, aSRpnt, STp->logical_blk_num - 1); 2870 2871 if (result < 0) 2872 printk(KERN_WARNING "%s:W: Stepping over filemark %s failed.\n", 2873 name, forward ? "forward" : "backward"); 2874 2875 return result; 2876} 2877 2878 2879/* Get the tape position. */ 2880 2881static int osst_get_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt) 2882{ 2883 unsigned char scmd[MAX_COMMAND_SIZE]; 2884 struct osst_request * SRpnt; 2885 int result = 0; 2886 char * name = tape_name(STp); 2887 2888 /* KG: We want to be able to use it for checking Write Buffer availability 2889 * and thus don't want to risk to overwrite anything. Exchange buffers ... */ 2890 char mybuf[24]; 2891 char * olddata = STp->buffer->b_data; 2892 int oldsize = STp->buffer->buffer_size; 2893 2894 if (STp->ready != ST_READY) return (-EIO); 2895 2896 memset (scmd, 0, MAX_COMMAND_SIZE); 2897 scmd[0] = READ_POSITION; 2898 2899 STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24; 2900 SRpnt = osst_do_scsi(*aSRpnt, STp, scmd, 20, DMA_FROM_DEVICE, 2901 STp->timeout, MAX_RETRIES, 1); 2902 if (!SRpnt) { 2903 STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize; 2904 return (-EBUSY); 2905 } 2906 *aSRpnt = SRpnt; 2907 2908 if (STp->buffer->syscall_result) 2909 result = ((SRpnt->sense[2] & 0x0f) == 3) ? -EIO : -EINVAL; /* 3: Write Error */ 2910 2911 if (result == -EINVAL) 2912 printk(KERN_ERR "%s:E: Can't read tape position.\n", name); 2913 else { 2914 if (result == -EIO) { /* re-read position - this needs to preserve media errors */ 2915 unsigned char mysense[16]; 2916 memcpy (mysense, SRpnt->sense, 16); 2917 memset (scmd, 0, MAX_COMMAND_SIZE); 2918 scmd[0] = READ_POSITION; 2919 STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24; 2920 SRpnt = osst_do_scsi(SRpnt, STp, scmd, 20, DMA_FROM_DEVICE, 2921 STp->timeout, MAX_RETRIES, 1); 2922#if DEBUG 2923 printk(OSST_DEB_MSG "%s:D: Reread position, reason=[%02x:%02x:%02x], result=[%s%02x:%02x:%02x]\n", 2924 name, mysense[2], mysense[12], mysense[13], STp->buffer->syscall_result?"":"ok:", 2925 SRpnt->sense[2],SRpnt->sense[12],SRpnt->sense[13]); 2926#endif 2927 if (!STp->buffer->syscall_result) 2928 memcpy (SRpnt->sense, mysense, 16); 2929 else 2930 printk(KERN_WARNING "%s:W: Double error in get position\n", name); 2931 } 2932 STp->first_frame_position = ((STp->buffer)->b_data[4] << 24) 2933 + ((STp->buffer)->b_data[5] << 16) 2934 + ((STp->buffer)->b_data[6] << 8) 2935 + (STp->buffer)->b_data[7]; 2936 STp->last_frame_position = ((STp->buffer)->b_data[ 8] << 24) 2937 + ((STp->buffer)->b_data[ 9] << 16) 2938 + ((STp->buffer)->b_data[10] << 8) 2939 + (STp->buffer)->b_data[11]; 2940 STp->cur_frames = (STp->buffer)->b_data[15]; 2941#if DEBUG 2942 if (debugging) { 2943 printk(OSST_DEB_MSG "%s:D: Drive Positions: host %d, tape %d%s, buffer %d\n", name, 2944 STp->first_frame_position, STp->last_frame_position, 2945 ((STp->buffer)->b_data[0]&0x80)?" (BOP)": 2946 ((STp->buffer)->b_data[0]&0x40)?" (EOP)":"", 2947 STp->cur_frames); 2948 } 2949#endif 2950 if (STp->cur_frames == 0 && STp->first_frame_position != STp->last_frame_position) { 2951#if DEBUG 2952 printk(OSST_DEB_MSG "%s:D: Correcting read position %d, %d, %d\n", name, 2953 STp->first_frame_position, STp->last_frame_position, STp->cur_frames); 2954#endif 2955 STp->first_frame_position = STp->last_frame_position; 2956 } 2957 } 2958 STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize; 2959 2960 return (result == 0 ? STp->first_frame_position : result); 2961} 2962 2963 2964/* Set the tape block */ 2965static int osst_set_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt, int ppos, int skip) 2966{ 2967 unsigned char scmd[MAX_COMMAND_SIZE]; 2968 struct osst_request * SRpnt; 2969 struct st_partstat * STps; 2970 int result = 0; 2971 int pp = (ppos == 3000 && !skip)? 0 : ppos; 2972 char * name = tape_name(STp); 2973 2974 if (STp->ready != ST_READY) return (-EIO); 2975 2976 STps = &(STp->ps[STp->partition]); 2977 2978 if (ppos < 0 || ppos > STp->capacity) { 2979 printk(KERN_WARNING "%s:W: Reposition request %d out of range\n", name, ppos); 2980 pp = ppos = ppos < 0 ? 0 : (STp->capacity - 1); 2981 result = (-EINVAL); 2982 } 2983 2984 do { 2985#if DEBUG 2986 if (debugging) 2987 printk(OSST_DEB_MSG "%s:D: Setting ppos to %d.\n", name, pp); 2988#endif 2989 memset (scmd, 0, MAX_COMMAND_SIZE); 2990 scmd[0] = SEEK_10; 2991 scmd[1] = 1; 2992 scmd[3] = (pp >> 24); 2993 scmd[4] = (pp >> 16); 2994 scmd[5] = (pp >> 8); 2995 scmd[6] = pp; 2996 if (skip) 2997 scmd[9] = 0x80; 2998 2999 SRpnt = osst_do_scsi(*aSRpnt, STp, scmd, 0, DMA_NONE, STp->long_timeout, 3000 MAX_RETRIES, 1); 3001 if (!SRpnt) 3002 return (-EBUSY); 3003 *aSRpnt = SRpnt; 3004 3005 if ((STp->buffer)->syscall_result != 0) { 3006#if DEBUG 3007 printk(OSST_DEB_MSG "%s:D: SEEK command from %d to %d failed.\n", 3008 name, STp->first_frame_position, pp); 3009#endif 3010 result = (-EIO); 3011 } 3012 if (pp != ppos) 3013 osst_wait_ready(STp, aSRpnt, 5 * 60, OSST_WAIT_POSITION_COMPLETE); 3014 } while ((pp != ppos) && (pp = ppos)); 3015 STp->first_frame_position = STp->last_frame_position = ppos; 3016 STps->eof = ST_NOEOF; 3017 STps->at_sm = 0; 3018 STps->rw = ST_IDLE; 3019 STp->frame_in_buffer = 0; 3020 return result; 3021} 3022 3023static int osst_write_trailer(struct osst_tape *STp, struct osst_request ** aSRpnt, int leave_at_EOT) 3024{ 3025 struct st_partstat * STps = &(STp->ps[STp->partition]); 3026 int result = 0; 3027 3028 if (STp->write_type != OS_WRITE_NEW_MARK) { 3029 /* true unless the user wrote the filemark for us */ 3030 result = osst_flush_drive_buffer(STp, aSRpnt); 3031 if (result < 0) goto out; 3032 result = osst_write_filemark(STp, aSRpnt); 3033 if (result < 0) goto out; 3034 3035 if (STps->drv_file >= 0) 3036 STps->drv_file++ ; 3037 STps->drv_block = 0; 3038 } 3039 result = osst_write_eod(STp, aSRpnt); 3040 osst_write_header(STp, aSRpnt, leave_at_EOT); 3041 3042 STps->eof = ST_FM; 3043out: 3044 return result; 3045} 3046 3047/* osst versions of st functions - augmented and stripped to suit OnStream only */ 3048 3049/* Flush the write buffer (never need to write if variable blocksize). */ 3050static int osst_flush_write_buffer(struct osst_tape *STp, struct osst_request ** aSRpnt) 3051{ 3052 int offset, transfer, blks = 0; 3053 int result = 0; 3054 unsigned char cmd[MAX_COMMAND_SIZE]; 3055 struct osst_request * SRpnt = *aSRpnt; 3056 struct st_partstat * STps; 3057 char * name = tape_name(STp); 3058 3059 if ((STp->buffer)->writing) { 3060 if (SRpnt == (STp->buffer)->last_SRpnt) 3061#if DEBUG 3062 { printk(OSST_DEB_MSG 3063 "%s:D: aSRpnt points to osst_request that write_behind_check will release -- cleared\n", name); 3064#endif 3065 *aSRpnt = SRpnt = NULL; 3066#if DEBUG 3067 } else if (SRpnt) 3068 printk(OSST_DEB_MSG 3069 "%s:D: aSRpnt does not point to osst_request that write_behind_check will release -- strange\n", name); 3070#endif 3071 osst_write_behind_check(STp); 3072 if ((STp->buffer)->syscall_result) { 3073#if DEBUG 3074 if (debugging) 3075 printk(OSST_DEB_MSG "%s:D: Async write error (flush) %x.\n", 3076 name, (STp->buffer)->midlevel_result); 3077#endif 3078 if ((STp->buffer)->midlevel_result == INT_MAX) 3079 return (-ENOSPC); 3080 return (-EIO); 3081 } 3082 } 3083 3084 result = 0; 3085 if (STp->dirty == 1) { 3086 3087 STp->write_count++; 3088 STps = &(STp->ps[STp->partition]); 3089 STps->rw = ST_WRITING; 3090 offset = STp->buffer->buffer_bytes; 3091 blks = (offset + STp->block_size - 1) / STp->block_size; 3092 transfer = OS_FRAME_SIZE; 3093 3094 if (offset < OS_DATA_SIZE) 3095 osst_zero_buffer_tail(STp->buffer); 3096 3097 if (STp->poll) 3098 if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, -50, 120)) 3099 result = osst_recover_wait_frame(STp, aSRpnt, 1); 3100 3101 memset(cmd, 0, MAX_COMMAND_SIZE); 3102 cmd[0] = WRITE_6; 3103 cmd[1] = 1; 3104 cmd[4] = 1; 3105 3106 switch (STp->write_type) { 3107 case OS_WRITE_DATA: 3108#if DEBUG 3109 if (debugging) 3110 printk(OSST_DEB_MSG "%s:D: Writing %d blocks to frame %d, lblks %d-%d\n", 3111 name, blks, STp->frame_seq_number, 3112 STp->logical_blk_num - blks, STp->logical_blk_num - 1); 3113#endif 3114 osst_init_aux(STp, OS_FRAME_TYPE_DATA, STp->frame_seq_number++, 3115 STp->logical_blk_num - blks, STp->block_size, blks); 3116 break; 3117 case OS_WRITE_EOD: 3118 osst_init_aux(STp, OS_FRAME_TYPE_EOD, STp->frame_seq_number++, 3119 STp->logical_blk_num, 0, 0); 3120 break; 3121 case OS_WRITE_NEW_MARK: 3122 osst_init_aux(STp, OS_FRAME_TYPE_MARKER, STp->frame_seq_number++, 3123 STp->logical_blk_num++, 0, blks=1); 3124 break; 3125 case OS_WRITE_HEADER: 3126 osst_init_aux(STp, OS_FRAME_TYPE_HEADER, 0, 0, 0, blks=0); 3127 break; 3128 default: /* probably FILLER */ 3129 osst_init_aux(STp, OS_FRAME_TYPE_FILL, 0, 0, 0, 0); 3130 } 3131#if DEBUG 3132 if (debugging) 3133 printk(OSST_DEB_MSG "%s:D: Flushing %d bytes, Transferring %d bytes in %d lblocks.\n", 3134 name, offset, transfer, blks); 3135#endif 3136 3137 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, transfer, DMA_TO_DEVICE, 3138 STp->timeout, MAX_RETRIES, 1); 3139 *aSRpnt = SRpnt; 3140 if (!SRpnt) 3141 return (-EBUSY); 3142 3143 if ((STp->buffer)->syscall_result != 0) { 3144#if DEBUG 3145 printk(OSST_DEB_MSG 3146 "%s:D: write sense [0]=0x%02x [2]=%02x [12]=%02x [13]=%02x\n", 3147 name, SRpnt->sense[0], SRpnt->sense[2], 3148 SRpnt->sense[12], SRpnt->sense[13]); 3149#endif 3150 if ((SRpnt->sense[0] & 0x70) == 0x70 && 3151 (SRpnt->sense[2] & 0x40) && /* FIXME - SC-30 drive doesn't assert EOM bit */ 3152 (SRpnt->sense[2] & 0x0f) == NO_SENSE) { 3153 STp->dirty = 0; 3154 (STp->buffer)->buffer_bytes = 0; 3155 result = (-ENOSPC); 3156 } 3157 else { 3158 if (osst_write_error_recovery(STp, aSRpnt, 1)) { 3159 printk(KERN_ERR "%s:E: Error on flush write.\n", name); 3160 result = (-EIO); 3161 } 3162 } 3163 STps->drv_block = (-1); /* FIXME - even if write recovery succeeds? */ 3164 } 3165 else { 3166 STp->first_frame_position++; 3167 STp->dirty = 0; 3168 (STp->buffer)->buffer_bytes = 0; 3169 } 3170 } 3171#if DEBUG 3172 printk(OSST_DEB_MSG "%s:D: Exit flush write buffer with code %d\n", name, result); 3173#endif 3174 return result; 3175} 3176 3177 3178/* Flush the tape buffer. The tape will be positioned correctly unless 3179 seek_next is true. */ 3180static int osst_flush_buffer(struct osst_tape * STp, struct osst_request ** aSRpnt, int seek_next) 3181{ 3182 struct st_partstat * STps; 3183 int backspace = 0, result = 0; 3184#if DEBUG 3185 char * name = tape_name(STp); 3186#endif 3187 3188 /* 3189 * If there was a bus reset, block further access 3190 * to this device. 3191 */ 3192 if( STp->pos_unknown) 3193 return (-EIO); 3194 3195 if (STp->ready != ST_READY) 3196 return 0; 3197 3198 STps = &(STp->ps[STp->partition]); 3199 if (STps->rw == ST_WRITING || STp->dirty) { /* Writing */ 3200 STp->write_type = OS_WRITE_DATA; 3201 return osst_flush_write_buffer(STp, aSRpnt); 3202 } 3203 if (STp->block_size == 0) 3204 return 0; 3205 3206#if DEBUG 3207 printk(OSST_DEB_MSG "%s:D: Reached flush (read) buffer\n", name); 3208#endif 3209 3210 if (!STp->can_bsr) { 3211 backspace = ((STp->buffer)->buffer_bytes + (STp->buffer)->read_pointer) / STp->block_size - 3212 ((STp->buffer)->read_pointer + STp->block_size - 1 ) / STp->block_size ; 3213 (STp->buffer)->buffer_bytes = 0; 3214 (STp->buffer)->read_pointer = 0; 3215 STp->frame_in_buffer = 0; /* FIXME is this relevant w. OSST? */ 3216 } 3217 3218 if (!seek_next) { 3219 if (STps->eof == ST_FM_HIT) { 3220 result = cross_eof(STp, aSRpnt, 0); /* Back over the EOF hit */ 3221 if (!result) 3222 STps->eof = ST_NOEOF; 3223 else { 3224 if (STps->drv_file >= 0) 3225 STps->drv_file++; 3226 STps->drv_block = 0; 3227 } 3228 } 3229 if (!result && backspace > 0) /* TODO -- design and run a test case for this */ 3230 result = osst_seek_logical_blk(STp, aSRpnt, STp->logical_blk_num - backspace); 3231 } 3232 else if (STps->eof == ST_FM_HIT) { 3233 if (STps->drv_file >= 0) 3234 STps->drv_file++; 3235 STps->drv_block = 0; 3236 STps->eof = ST_NOEOF; 3237 } 3238 3239 return result; 3240} 3241 3242static int osst_write_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int synchronous) 3243{ 3244 unsigned char cmd[MAX_COMMAND_SIZE]; 3245 struct osst_request * SRpnt; 3246 int blks; 3247#if DEBUG 3248 char * name = tape_name(STp); 3249#endif 3250 3251 if ((!STp-> raw) && (STp->first_frame_position == 0xbae)) { /* _must_ preserve buffer! */ 3252#if DEBUG 3253 printk(OSST_DEB_MSG "%s:D: Reaching config partition.\n", name); 3254#endif 3255 if (osst_flush_drive_buffer(STp, aSRpnt) < 0) { 3256 return (-EIO); 3257 } 3258 /* error recovery may have bumped us past the header partition */ 3259 if (osst_get_frame_position(STp, aSRpnt) < 0xbb8) { 3260#if DEBUG 3261 printk(OSST_DEB_MSG "%s:D: Skipping over config partition.\n", name); 3262#endif 3263 osst_position_tape_and_confirm(STp, aSRpnt, 0xbb8); 3264 } 3265 } 3266 3267 if (STp->poll) 3268 if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, -48, 120)) 3269 if (osst_recover_wait_frame(STp, aSRpnt, 1)) 3270 return (-EIO); 3271 3272// osst_build_stats(STp, &SRpnt); 3273 3274 STp->ps[STp->partition].rw = ST_WRITING; 3275 STp->write_type = OS_WRITE_DATA; 3276 3277 memset(cmd, 0, MAX_COMMAND_SIZE); 3278 cmd[0] = WRITE_6; 3279 cmd[1] = 1; 3280 cmd[4] = 1; /* one frame at a time... */ 3281 blks = STp->buffer->buffer_bytes / STp->block_size; 3282#if DEBUG 3283 if (debugging) 3284 printk(OSST_DEB_MSG "%s:D: Writing %d blocks to frame %d, lblks %d-%d\n", name, blks, 3285 STp->frame_seq_number, STp->logical_blk_num - blks, STp->logical_blk_num - 1); 3286#endif 3287 osst_init_aux(STp, OS_FRAME_TYPE_DATA, STp->frame_seq_number++, 3288 STp->logical_blk_num - blks, STp->block_size, blks); 3289 3290#if DEBUG 3291 if (!synchronous) 3292 STp->write_pending = 1; 3293#endif 3294 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE, STp->timeout, 3295 MAX_RETRIES, synchronous); 3296 if (!SRpnt) 3297 return (-EBUSY); 3298 *aSRpnt = SRpnt; 3299 3300 if (synchronous) { 3301 if (STp->buffer->syscall_result != 0) { 3302#if DEBUG 3303 if (debugging) 3304 printk(OSST_DEB_MSG "%s:D: Error on write:\n", name); 3305#endif 3306 if ((SRpnt->sense[0] & 0x70) == 0x70 && 3307 (SRpnt->sense[2] & 0x40)) { 3308 if ((SRpnt->sense[2] & 0x0f) == VOLUME_OVERFLOW) 3309 return (-ENOSPC); 3310 } 3311 else { 3312 if (osst_write_error_recovery(STp, aSRpnt, 1)) 3313 return (-EIO); 3314 } 3315 } 3316 else 3317 STp->first_frame_position++; 3318 } 3319 3320 STp->write_count++; 3321 3322 return 0; 3323} 3324 3325/* Lock or unlock the drive door. Don't use when struct osst_request allocated. */ 3326static int do_door_lock(struct osst_tape * STp, int do_lock) 3327{ 3328 int retval, cmd; 3329 3330 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK; 3331#if DEBUG 3332 printk(OSST_DEB_MSG "%s:D: %socking drive door.\n", tape_name(STp), do_lock ? "L" : "Unl"); 3333#endif 3334 retval = scsi_ioctl(STp->device, cmd, NULL); 3335 if (!retval) { 3336 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED; 3337 } 3338 else { 3339 STp->door_locked = ST_LOCK_FAILS; 3340 } 3341 return retval; 3342} 3343 3344/* Set the internal state after reset */ 3345static void reset_state(struct osst_tape *STp) 3346{ 3347 int i; 3348 struct st_partstat *STps; 3349 3350 STp->pos_unknown = 0; 3351 for (i = 0; i < ST_NBR_PARTITIONS; i++) { 3352 STps = &(STp->ps[i]); 3353 STps->rw = ST_IDLE; 3354 STps->eof = ST_NOEOF; 3355 STps->at_sm = 0; 3356 STps->last_block_valid = 0; 3357 STps->drv_block = -1; 3358 STps->drv_file = -1; 3359 } 3360} 3361 3362 3363/* Entry points to osst */ 3364 3365/* Write command */ 3366static ssize_t osst_write(struct file * filp, const char __user * buf, size_t count, loff_t *ppos) 3367{ 3368 ssize_t total, retval = 0; 3369 ssize_t i, do_count, blks, transfer; 3370 int write_threshold; 3371 int doing_write = 0; 3372 const char __user * b_point; 3373 struct osst_request * SRpnt = NULL; 3374 struct st_modedef * STm; 3375 struct st_partstat * STps; 3376 struct osst_tape * STp = filp->private_data; 3377 char * name = tape_name(STp); 3378 3379 3380 if (mutex_lock_interruptible(&STp->lock)) 3381 return (-ERESTARTSYS); 3382 3383 /* 3384 * If we are in the middle of error recovery, don't let anyone 3385 * else try and use this device. Also, if error recovery fails, it 3386 * may try and take the device offline, in which case all further 3387 * access to the device is prohibited. 3388 */ 3389 if( !scsi_block_when_processing_errors(STp->device) ) { 3390 retval = (-ENXIO); 3391 goto out; 3392 } 3393 3394 if (STp->ready != ST_READY) { 3395 if (STp->ready == ST_NO_TAPE) 3396 retval = (-ENOMEDIUM); 3397 else 3398 retval = (-EIO); 3399 goto out; 3400 } 3401 STm = &(STp->modes[STp->current_mode]); 3402 if (!STm->defined) { 3403 retval = (-ENXIO); 3404 goto out; 3405 } 3406 if (count == 0) 3407 goto out; 3408 3409 /* 3410 * If there was a bus reset, block further access 3411 * to this device. 3412 */ 3413 if (STp->pos_unknown) { 3414 retval = (-EIO); 3415 goto out; 3416 } 3417 3418#if DEBUG 3419 if (!STp->in_use) { 3420 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name); 3421 retval = (-EIO); 3422 goto out; 3423 } 3424#endif 3425 3426 if (STp->write_prot) { 3427 retval = (-EACCES); 3428 goto out; 3429 } 3430 3431 /* Write must be integral number of blocks */ 3432 if (STp->block_size != 0 && (count % STp->block_size) != 0) { 3433 printk(KERN_ERR "%s:E: Write (%Zd bytes) not multiple of tape block size (%d%c).\n", 3434 name, count, STp->block_size<1024? 3435 STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k'); 3436 retval = (-EINVAL); 3437 goto out; 3438 } 3439 3440 if (STp->first_frame_position >= STp->capacity - OSST_EOM_RESERVE) { 3441 printk(KERN_ERR "%s:E: Write truncated at EOM early warning (frame %d).\n", 3442 name, STp->first_frame_position); 3443 retval = (-ENOSPC); 3444 goto out; 3445 } 3446 3447 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && !do_door_lock(STp, 1)) 3448 STp->door_locked = ST_LOCKED_AUTO; 3449 3450 STps = &(STp->ps[STp->partition]); 3451 3452 if (STps->rw == ST_READING) { 3453#if DEBUG 3454 printk(OSST_DEB_MSG "%s:D: Switching from read to write at file %d, block %d\n", name, 3455 STps->drv_file, STps->drv_block); 3456#endif 3457 retval = osst_flush_buffer(STp, &SRpnt, 0); 3458 if (retval) 3459 goto out; 3460 STps->rw = ST_IDLE; 3461 } 3462 if (STps->rw != ST_WRITING) { 3463 /* Are we totally rewriting this tape? */ 3464 if (!STp->header_ok || 3465 (STp->first_frame_position == STp->first_data_ppos && STps->drv_block < 0) || 3466 (STps->drv_file == 0 && STps->drv_block == 0)) { 3467 STp->wrt_pass_cntr++; 3468#if DEBUG 3469 printk(OSST_DEB_MSG "%s:D: Allocating next write pass counter: %d\n", 3470 name, STp->wrt_pass_cntr); 3471#endif 3472 osst_reset_header(STp, &SRpnt); 3473 STps->drv_file = STps->drv_block = 0; 3474 } 3475 /* Do we know where we'll be writing on the tape? */ 3476 else { 3477 if ((STp->fast_open && osst_verify_position(STp, &SRpnt)) || 3478 STps->drv_file < 0 || STps->drv_block < 0) { 3479 if (STp->first_frame_position == STp->eod_frame_ppos) { /* at EOD */ 3480 STps->drv_file = STp->filemark_cnt; 3481 STps->drv_block = 0; 3482 } 3483 else { 3484 /* We have no idea where the tape is positioned - give up */ 3485#if DEBUG 3486 printk(OSST_DEB_MSG 3487 "%s:D: Cannot write at indeterminate position.\n", name); 3488#endif 3489 retval = (-EIO); 3490 goto out; 3491 } 3492 } 3493 if ((STps->drv_file + STps->drv_block) > 0 && STps->drv_file < STp->filemark_cnt) { 3494 STp->filemark_cnt = STps->drv_file; 3495 STp->last_mark_ppos = 3496 ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[STp->filemark_cnt-1]); 3497 printk(KERN_WARNING 3498 "%s:W: Overwriting file %d with old write pass counter %d\n", 3499 name, STps->drv_file, STp->wrt_pass_cntr); 3500 printk(KERN_WARNING 3501 "%s:W: may lead to stale data being accepted on reading back!\n", 3502 name); 3503#if DEBUG 3504 printk(OSST_DEB_MSG 3505 "%s:D: resetting filemark count to %d and last mark ppos,lbn to %d,%d\n", 3506 name, STp->filemark_cnt, STp->last_mark_ppos, STp->last_mark_lbn); 3507#endif 3508 } 3509 } 3510 STp->fast_open = 0; 3511 } 3512 if (!STp->header_ok) { 3513#if DEBUG 3514 printk(OSST_DEB_MSG "%s:D: Write cannot proceed without valid headers\n", name); 3515#endif 3516 retval = (-EIO); 3517 goto out; 3518 } 3519 3520 if ((STp->buffer)->writing) { 3521if (SRpnt) printk(KERN_ERR "%s:A: Not supposed to have SRpnt at line %d\n", name, __LINE__); 3522 osst_write_behind_check(STp); 3523 if ((STp->buffer)->syscall_result) { 3524#if DEBUG 3525 if (debugging) 3526 printk(OSST_DEB_MSG "%s:D: Async write error (write) %x.\n", name, 3527 (STp->buffer)->midlevel_result); 3528#endif 3529 if ((STp->buffer)->midlevel_result == INT_MAX) 3530 STps->eof = ST_EOM_OK; 3531 else 3532 STps->eof = ST_EOM_ERROR; 3533 } 3534 } 3535 if (STps->eof == ST_EOM_OK) { 3536 retval = (-ENOSPC); 3537 goto out; 3538 } 3539 else if (STps->eof == ST_EOM_ERROR) { 3540 retval = (-EIO); 3541 goto out; 3542 } 3543 3544 /* Check the buffer readability in cases where copy_user might catch 3545 the problems after some tape movement. */ 3546 if ((copy_from_user(&i, buf, 1) != 0 || 3547 copy_from_user(&i, buf + count - 1, 1) != 0)) { 3548 retval = (-EFAULT); 3549 goto out; 3550 } 3551 3552 if (!STm->do_buffer_writes) { 3553 write_threshold = 1; 3554 } 3555 else 3556 write_threshold = (STp->buffer)->buffer_blocks * STp->block_size; 3557 if (!STm->do_async_writes) 3558 write_threshold--; 3559 3560 total = count; 3561#if DEBUG 3562 if (debugging) 3563 printk(OSST_DEB_MSG "%s:D: Writing %d bytes to file %d block %d lblk %d fseq %d fppos %d\n", 3564 name, (int) count, STps->drv_file, STps->drv_block, 3565 STp->logical_blk_num, STp->frame_seq_number, STp->first_frame_position); 3566#endif 3567 b_point = buf; 3568 while ((STp->buffer)->buffer_bytes + count > write_threshold) 3569 { 3570 doing_write = 1; 3571 do_count = (STp->buffer)->buffer_blocks * STp->block_size - 3572 (STp->buffer)->buffer_bytes; 3573 if (do_count > count) 3574 do_count = count; 3575 3576 i = append_to_buffer(b_point, STp->buffer, do_count); 3577 if (i) { 3578 retval = i; 3579 goto out; 3580 } 3581 3582 blks = do_count / STp->block_size; 3583 STp->logical_blk_num += blks; /* logical_blk_num is incremented as data is moved from user */ 3584 3585 i = osst_write_frame(STp, &SRpnt, 1); 3586 3587 if (i == (-ENOSPC)) { 3588 transfer = STp->buffer->writing; /* FIXME -- check this logic */ 3589 if (transfer <= do_count) { 3590 *ppos += do_count - transfer; 3591 count -= do_count - transfer; 3592 if (STps->drv_block >= 0) { 3593 STps->drv_block += (do_count - transfer) / STp->block_size; 3594 } 3595 STps->eof = ST_EOM_OK; 3596 retval = (-ENOSPC); /* EOM within current request */ 3597#if DEBUG 3598 if (debugging) 3599 printk(OSST_DEB_MSG "%s:D: EOM with %d bytes unwritten.\n", 3600 name, (int) transfer); 3601#endif 3602 } 3603 else { 3604 STps->eof = ST_EOM_ERROR; 3605 STps->drv_block = (-1); /* Too cautious? */ 3606 retval = (-EIO); /* EOM for old data */ 3607#if DEBUG 3608 if (debugging) 3609 printk(OSST_DEB_MSG "%s:D: EOM with lost data.\n", name); 3610#endif 3611 } 3612 } 3613 else 3614 retval = i; 3615 3616 if (retval < 0) { 3617 if (SRpnt != NULL) { 3618 osst_release_request(SRpnt); 3619 SRpnt = NULL; 3620 } 3621 STp->buffer->buffer_bytes = 0; 3622 STp->dirty = 0; 3623 if (count < total) 3624 retval = total - count; 3625 goto out; 3626 } 3627 3628 *ppos += do_count; 3629 b_point += do_count; 3630 count -= do_count; 3631 if (STps->drv_block >= 0) { 3632 STps->drv_block += blks; 3633 } 3634 STp->buffer->buffer_bytes = 0; 3635 STp->dirty = 0; 3636 } /* end while write threshold exceeded */ 3637 3638 if (count != 0) { 3639 STp->dirty = 1; 3640 i = append_to_buffer(b_point, STp->buffer, count); 3641 if (i) { 3642 retval = i; 3643 goto out; 3644 } 3645 blks = count / STp->block_size; 3646 STp->logical_blk_num += blks; 3647 if (STps->drv_block >= 0) { 3648 STps->drv_block += blks; 3649 } 3650 *ppos += count; 3651 count = 0; 3652 } 3653 3654 if (doing_write && (STp->buffer)->syscall_result != 0) { 3655 retval = (STp->buffer)->syscall_result; 3656 goto out; 3657 } 3658 3659 if (STm->do_async_writes && ((STp->buffer)->buffer_bytes >= STp->write_threshold)) { 3660 /* Schedule an asynchronous write */ 3661 (STp->buffer)->writing = ((STp->buffer)->buffer_bytes / 3662 STp->block_size) * STp->block_size; 3663 STp->dirty = !((STp->buffer)->writing == 3664 (STp->buffer)->buffer_bytes); 3665 3666 i = osst_write_frame(STp, &SRpnt, 0); 3667 if (i < 0) { 3668 retval = (-EIO); 3669 goto out; 3670 } 3671 SRpnt = NULL; /* Prevent releasing this request! */ 3672 } 3673 STps->at_sm &= (total == 0); 3674 if (total > 0) 3675 STps->eof = ST_NOEOF; 3676 3677 retval = total; 3678 3679out: 3680 if (SRpnt != NULL) osst_release_request(SRpnt); 3681 3682 mutex_unlock(&STp->lock); 3683 3684 return retval; 3685} 3686 3687 3688/* Read command */ 3689static ssize_t osst_read(struct file * filp, char __user * buf, size_t count, loff_t *ppos) 3690{ 3691 ssize_t total, retval = 0; 3692 ssize_t i, transfer; 3693 int special; 3694 struct st_modedef * STm; 3695 struct st_partstat * STps; 3696 struct osst_request * SRpnt = NULL; 3697 struct osst_tape * STp = filp->private_data; 3698 char * name = tape_name(STp); 3699 3700 3701 if (mutex_lock_interruptible(&STp->lock)) 3702 return (-ERESTARTSYS); 3703 3704 /* 3705 * If we are in the middle of error recovery, don't let anyone 3706 * else try and use this device. Also, if error recovery fails, it 3707 * may try and take the device offline, in which case all further 3708 * access to the device is prohibited. 3709 */ 3710 if( !scsi_block_when_processing_errors(STp->device) ) { 3711 retval = (-ENXIO); 3712 goto out; 3713 } 3714 3715 if (STp->ready != ST_READY) { 3716 if (STp->ready == ST_NO_TAPE) 3717 retval = (-ENOMEDIUM); 3718 else 3719 retval = (-EIO); 3720 goto out; 3721 } 3722 STm = &(STp->modes[STp->current_mode]); 3723 if (!STm->defined) { 3724 retval = (-ENXIO); 3725 goto out; 3726 } 3727#if DEBUG 3728 if (!STp->in_use) { 3729 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name); 3730 retval = (-EIO); 3731 goto out; 3732 } 3733#endif 3734 /* Must have initialized medium */ 3735 if (!STp->header_ok) { 3736 retval = (-EIO); 3737 goto out; 3738 } 3739 3740 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && !do_door_lock(STp, 1)) 3741 STp->door_locked = ST_LOCKED_AUTO; 3742 3743 STps = &(STp->ps[STp->partition]); 3744 if (STps->rw == ST_WRITING) { 3745 retval = osst_flush_buffer(STp, &SRpnt, 0); 3746 if (retval) 3747 goto out; 3748 STps->rw = ST_IDLE; 3749 /* FIXME -- this may leave the tape without EOD and up2date headers */ 3750 } 3751 3752 if ((count % STp->block_size) != 0) { 3753 printk(KERN_WARNING 3754 "%s:W: Read (%Zd bytes) not multiple of tape block size (%d%c).\n", name, count, 3755 STp->block_size<1024?STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k'); 3756 } 3757 3758#if DEBUG 3759 if (debugging && STps->eof != ST_NOEOF) 3760 printk(OSST_DEB_MSG "%s:D: EOF/EOM flag up (%d). Bytes %d\n", name, 3761 STps->eof, (STp->buffer)->buffer_bytes); 3762#endif 3763 if ((STp->buffer)->buffer_bytes == 0 && 3764 STps->eof >= ST_EOD_1) { 3765 if (STps->eof < ST_EOD) { 3766 STps->eof += 1; 3767 retval = 0; 3768 goto out; 3769 } 3770 retval = (-EIO); /* EOM or Blank Check */ 3771 goto out; 3772 } 3773 3774 /* Check the buffer writability before any tape movement. Don't alter 3775 buffer data. */ 3776 if (copy_from_user(&i, buf, 1) != 0 || 3777 copy_to_user (buf, &i, 1) != 0 || 3778 copy_from_user(&i, buf + count - 1, 1) != 0 || 3779 copy_to_user (buf + count - 1, &i, 1) != 0) { 3780 retval = (-EFAULT); 3781 goto out; 3782 } 3783 3784 /* Loop until enough data in buffer or a special condition found */ 3785 for (total = 0, special = 0; total < count - STp->block_size + 1 && !special; ) { 3786 3787 /* Get new data if the buffer is empty */ 3788 if ((STp->buffer)->buffer_bytes == 0) { 3789 if (STps->eof == ST_FM_HIT) 3790 break; 3791 special = osst_get_logical_frame(STp, &SRpnt, STp->frame_seq_number, 0); 3792 if (special < 0) { /* No need to continue read */ 3793 STp->frame_in_buffer = 0; 3794 retval = special; 3795 goto out; 3796 } 3797 } 3798 3799 /* Move the data from driver buffer to user buffer */ 3800 if ((STp->buffer)->buffer_bytes > 0) { 3801#if DEBUG 3802 if (debugging && STps->eof != ST_NOEOF) 3803 printk(OSST_DEB_MSG "%s:D: EOF up (%d). Left %d, needed %d.\n", name, 3804 STps->eof, (STp->buffer)->buffer_bytes, (int) (count - total)); 3805#endif 3806 /* force multiple of block size, note block_size may have been adjusted */ 3807 transfer = (((STp->buffer)->buffer_bytes < count - total ? 3808 (STp->buffer)->buffer_bytes : count - total)/ 3809 STp->block_size) * STp->block_size; 3810 3811 if (transfer == 0) { 3812 printk(KERN_WARNING 3813 "%s:W: Nothing can be transferred, requested %Zd, tape block size (%d%c).\n", 3814 name, count, STp->block_size < 1024? 3815 STp->block_size:STp->block_size/1024, 3816 STp->block_size<1024?'b':'k'); 3817 break; 3818 } 3819 i = from_buffer(STp->buffer, buf, transfer); 3820 if (i) { 3821 retval = i; 3822 goto out; 3823 } 3824 STp->logical_blk_num += transfer / STp->block_size; 3825 STps->drv_block += transfer / STp->block_size; 3826 *ppos += transfer; 3827 buf += transfer; 3828 total += transfer; 3829 } 3830 3831 if ((STp->buffer)->buffer_bytes == 0) { 3832#if DEBUG 3833 if (debugging) 3834 printk(OSST_DEB_MSG "%s:D: Finished with frame %d\n", 3835 name, STp->frame_seq_number); 3836#endif 3837 STp->frame_in_buffer = 0; 3838 STp->frame_seq_number++; /* frame to look for next time */ 3839 } 3840 } /* for (total = 0, special = 0; total < count && !special; ) */ 3841 3842 /* Change the eof state if no data from tape or buffer */ 3843 if (total == 0) { 3844 if (STps->eof == ST_FM_HIT) { 3845 STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD_2:ST_FM; 3846 STps->drv_block = 0; 3847 if (STps->drv_file >= 0) 3848 STps->drv_file++; 3849 } 3850 else if (STps->eof == ST_EOD_1) { 3851 STps->eof = ST_EOD_2; 3852 if (STps->drv_block > 0 && STps->drv_file >= 0) 3853 STps->drv_file++; 3854 STps->drv_block = 0; 3855 } 3856 else if (STps->eof == ST_EOD_2) 3857 STps->eof = ST_EOD; 3858 } 3859 else if (STps->eof == ST_FM) 3860 STps->eof = ST_NOEOF; 3861 3862 retval = total; 3863 3864out: 3865 if (SRpnt != NULL) osst_release_request(SRpnt); 3866 3867 mutex_unlock(&STp->lock); 3868 3869 return retval; 3870} 3871 3872 3873/* Set the driver options */ 3874static void osst_log_options(struct osst_tape *STp, struct st_modedef *STm, char *name) 3875{ 3876 printk(KERN_INFO 3877"%s:I: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n", 3878 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes, 3879 STm->do_read_ahead); 3880 printk(KERN_INFO 3881"%s:I: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n", 3882 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock); 3883 printk(KERN_INFO 3884"%s:I: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n", 3885 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions, 3886 STp->scsi2_logical); 3887 printk(KERN_INFO 3888"%s:I: sysv: %d\n", name, STm->sysv); 3889#if DEBUG 3890 printk(KERN_INFO 3891 "%s:D: debugging: %d\n", 3892 name, debugging); 3893#endif 3894} 3895 3896 3897static int osst_set_options(struct osst_tape *STp, long options) 3898{ 3899 int value; 3900 long code; 3901 struct st_modedef * STm; 3902 char * name = tape_name(STp); 3903 3904 STm = &(STp->modes[STp->current_mode]); 3905 if (!STm->defined) { 3906 memcpy(STm, &(STp->modes[0]), sizeof(*STm)); 3907 modes_defined = 1; 3908#if DEBUG 3909 if (debugging) 3910 printk(OSST_DEB_MSG "%s:D: Initialized mode %d definition from mode 0\n", 3911 name, STp->current_mode); 3912#endif 3913 } 3914 3915 code = options & MT_ST_OPTIONS; 3916 if (code == MT_ST_BOOLEANS) { 3917 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0; 3918 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0; 3919 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0; 3920 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0; 3921 STp->two_fm = (options & MT_ST_TWO_FM) != 0; 3922 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0; 3923 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0; 3924 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0; 3925 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0; 3926 if ((STp->device)->scsi_level >= SCSI_2) 3927 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0; 3928 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0; 3929 STm->sysv = (options & MT_ST_SYSV) != 0; 3930#if DEBUG 3931 debugging = (options & MT_ST_DEBUGGING) != 0; 3932#endif 3933 osst_log_options(STp, STm, name); 3934 } 3935 else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) { 3936 value = (code == MT_ST_SETBOOLEANS); 3937 if ((options & MT_ST_BUFFER_WRITES) != 0) 3938 STm->do_buffer_writes = value; 3939 if ((options & MT_ST_ASYNC_WRITES) != 0) 3940 STm->do_async_writes = value; 3941 if ((options & MT_ST_DEF_WRITES) != 0) 3942 STm->defaults_for_writes = value; 3943 if ((options & MT_ST_READ_AHEAD) != 0) 3944 STm->do_read_ahead = value; 3945 if ((options & MT_ST_TWO_FM) != 0) 3946 STp->two_fm = value; 3947 if ((options & MT_ST_FAST_MTEOM) != 0) 3948 STp->fast_mteom = value; 3949 if ((options & MT_ST_AUTO_LOCK) != 0) 3950 STp->do_auto_lock = value; 3951 if ((options & MT_ST_CAN_BSR) != 0) 3952 STp->can_bsr = value; 3953 if ((options & MT_ST_NO_BLKLIMS) != 0) 3954 STp->omit_blklims = value; 3955 if ((STp->device)->scsi_level >= SCSI_2 && 3956 (options & MT_ST_CAN_PARTITIONS) != 0) 3957 STp->can_partitions = value; 3958 if ((options & MT_ST_SCSI2LOGICAL) != 0) 3959 STp->scsi2_logical = value; 3960 if ((options & MT_ST_SYSV) != 0) 3961 STm->sysv = value; 3962#if DEBUG 3963 if ((options & MT_ST_DEBUGGING) != 0) 3964 debugging = value; 3965#endif 3966 osst_log_options(STp, STm, name); 3967 } 3968 else if (code == MT_ST_WRITE_THRESHOLD) { 3969 value = (options & ~MT_ST_OPTIONS) * ST_KILOBYTE; 3970 if (value < 1 || value > osst_buffer_size) { 3971 printk(KERN_WARNING "%s:W: Write threshold %d too small or too large.\n", 3972 name, value); 3973 return (-EIO); 3974 } 3975 STp->write_threshold = value; 3976 printk(KERN_INFO "%s:I: Write threshold set to %d bytes.\n", 3977 name, value); 3978 } 3979 else if (code == MT_ST_DEF_BLKSIZE) { 3980 value = (options & ~MT_ST_OPTIONS); 3981 if (value == ~MT_ST_OPTIONS) { 3982 STm->default_blksize = (-1); 3983 printk(KERN_INFO "%s:I: Default block size disabled.\n", name); 3984 } 3985 else { 3986 if (value < 512 || value > OS_DATA_SIZE || OS_DATA_SIZE % value) { 3987 printk(KERN_WARNING "%s:W: Default block size cannot be set to %d.\n", 3988 name, value); 3989 return (-EINVAL); 3990 } 3991 STm->default_blksize = value; 3992 printk(KERN_INFO "%s:I: Default block size set to %d bytes.\n", 3993 name, STm->default_blksize); 3994 } 3995 } 3996 else if (code == MT_ST_TIMEOUTS) { 3997 value = (options & ~MT_ST_OPTIONS); 3998 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) { 3999 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ; 4000 printk(KERN_INFO "%s:I: Long timeout set to %d seconds.\n", name, 4001 (value & ~MT_ST_SET_LONG_TIMEOUT)); 4002 } 4003 else { 4004 STp->timeout = value * HZ; 4005 printk(KERN_INFO "%s:I: Normal timeout set to %d seconds.\n", name, value); 4006 } 4007 } 4008 else if (code == MT_ST_DEF_OPTIONS) { 4009 code = (options & ~MT_ST_CLEAR_DEFAULT); 4010 value = (options & MT_ST_CLEAR_DEFAULT); 4011 if (code == MT_ST_DEF_DENSITY) { 4012 if (value == MT_ST_CLEAR_DEFAULT) { 4013 STm->default_density = (-1); 4014 printk(KERN_INFO "%s:I: Density default disabled.\n", name); 4015 } 4016 else { 4017 STm->default_density = value & 0xff; 4018 printk(KERN_INFO "%s:I: Density default set to %x\n", 4019 name, STm->default_density); 4020 } 4021 } 4022 else if (code == MT_ST_DEF_DRVBUFFER) { 4023 if (value == MT_ST_CLEAR_DEFAULT) { 4024 STp->default_drvbuffer = 0xff; 4025 printk(KERN_INFO "%s:I: Drive buffer default disabled.\n", name); 4026 } 4027 else { 4028 STp->default_drvbuffer = value & 7; 4029 printk(KERN_INFO "%s:I: Drive buffer default set to %x\n", 4030 name, STp->default_drvbuffer); 4031 } 4032 } 4033 else if (code == MT_ST_DEF_COMPRESSION) { 4034 if (value == MT_ST_CLEAR_DEFAULT) { 4035 STm->default_compression = ST_DONT_TOUCH; 4036 printk(KERN_INFO "%s:I: Compression default disabled.\n", name); 4037 } 4038 else { 4039 STm->default_compression = (value & 1 ? ST_YES : ST_NO); 4040 printk(KERN_INFO "%s:I: Compression default set to %x\n", 4041 name, (value & 1)); 4042 } 4043 } 4044 } 4045 else 4046 return (-EIO); 4047 4048 return 0; 4049} 4050 4051 4052/* Internal ioctl function */ 4053static int osst_int_ioctl(struct osst_tape * STp, struct osst_request ** aSRpnt, 4054 unsigned int cmd_in, unsigned long arg) 4055{ 4056 int timeout; 4057 long ltmp; 4058 int i, ioctl_result; 4059 int chg_eof = 1; 4060 unsigned char cmd[MAX_COMMAND_SIZE]; 4061 struct osst_request * SRpnt = * aSRpnt; 4062 struct st_partstat * STps; 4063 int fileno, blkno, at_sm, frame_seq_numbr, logical_blk_num; 4064 int datalen = 0, direction = DMA_NONE; 4065 char * name = tape_name(STp); 4066 4067 if (STp->ready != ST_READY && cmd_in != MTLOAD) { 4068 if (STp->ready == ST_NO_TAPE) 4069 return (-ENOMEDIUM); 4070 else 4071 return (-EIO); 4072 } 4073 timeout = STp->long_timeout; 4074 STps = &(STp->ps[STp->partition]); 4075 fileno = STps->drv_file; 4076 blkno = STps->drv_block; 4077 at_sm = STps->at_sm; 4078 frame_seq_numbr = STp->frame_seq_number; 4079 logical_blk_num = STp->logical_blk_num; 4080 4081 memset(cmd, 0, MAX_COMMAND_SIZE); 4082 switch (cmd_in) { 4083 case MTFSFM: 4084 chg_eof = 0; /* Changed from the FSF after this */ 4085 case MTFSF: 4086 if (STp->raw) 4087 return (-EIO); 4088 if (STp->linux_media) 4089 ioctl_result = osst_space_over_filemarks_forward_fast(STp, &SRpnt, cmd_in, arg); 4090 else 4091 ioctl_result = osst_space_over_filemarks_forward_slow(STp, &SRpnt, cmd_in, arg); 4092 if (fileno >= 0) 4093 fileno += arg; 4094 blkno = 0; 4095 at_sm &= (arg == 0); 4096 goto os_bypass; 4097 4098 case MTBSF: 4099 chg_eof = 0; /* Changed from the FSF after this */ 4100 case MTBSFM: 4101 if (STp->raw) 4102 return (-EIO); 4103 ioctl_result = osst_space_over_filemarks_backward(STp, &SRpnt, cmd_in, arg); 4104 if (fileno >= 0) 4105 fileno -= arg; 4106 blkno = (-1); /* We can't know the block number */ 4107 at_sm &= (arg == 0); 4108 goto os_bypass; 4109 4110 case MTFSR: 4111 case MTBSR: 4112#if DEBUG 4113 if (debugging) 4114 printk(OSST_DEB_MSG "%s:D: Skipping %lu blocks %s from logical block %d\n", 4115 name, arg, cmd_in==MTFSR?"forward":"backward", logical_blk_num); 4116#endif 4117 if (cmd_in == MTFSR) { 4118 logical_blk_num += arg; 4119 if (blkno >= 0) blkno += arg; 4120 } 4121 else { 4122 logical_blk_num -= arg; 4123 if (blkno >= 0) blkno -= arg; 4124 } 4125 ioctl_result = osst_seek_logical_blk(STp, &SRpnt, logical_blk_num); 4126 fileno = STps->drv_file; 4127 blkno = STps->drv_block; 4128 at_sm &= (arg == 0); 4129 goto os_bypass; 4130 4131 case MTFSS: 4132 cmd[0] = SPACE; 4133 cmd[1] = 0x04; /* Space Setmarks */ /* FIXME -- OS can't do this? */ 4134 cmd[2] = (arg >> 16); 4135 cmd[3] = (arg >> 8); 4136 cmd[4] = arg; 4137#if DEBUG 4138 if (debugging) 4139 printk(OSST_DEB_MSG "%s:D: Spacing tape forward %d setmarks.\n", name, 4140 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]); 4141#endif 4142 if (arg != 0) { 4143 blkno = fileno = (-1); 4144 at_sm = 1; 4145 } 4146 break; 4147 case MTBSS: 4148 cmd[0] = SPACE; 4149 cmd[1] = 0x04; /* Space Setmarks */ /* FIXME -- OS can't do this? */ 4150 ltmp = (-arg); 4151 cmd[2] = (ltmp >> 16); 4152 cmd[3] = (ltmp >> 8); 4153 cmd[4] = ltmp; 4154#if DEBUG 4155 if (debugging) { 4156 if (cmd[2] & 0x80) 4157 ltmp = 0xff000000; 4158 ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4]; 4159 printk(OSST_DEB_MSG "%s:D: Spacing tape backward %ld setmarks.\n", 4160 name, (-ltmp)); 4161 } 4162#endif 4163 if (arg != 0) { 4164 blkno = fileno = (-1); 4165 at_sm = 1; 4166 } 4167 break; 4168 case MTWEOF: 4169 if ((STps->rw == ST_WRITING || STp->dirty) && !STp->pos_unknown) { 4170 STp->write_type = OS_WRITE_DATA; 4171 ioctl_result = osst_flush_write_buffer(STp, &SRpnt); 4172 } else 4173 ioctl_result = 0; 4174#if DEBUG 4175 if (debugging) 4176 printk(OSST_DEB_MSG "%s:D: Writing %ld filemark(s).\n", name, arg); 4177#endif 4178 for (i=0; i<arg; i++) 4179 ioctl_result |= osst_write_filemark(STp, &SRpnt); 4180 if (fileno >= 0) fileno += arg; 4181 if (blkno >= 0) blkno = 0; 4182 goto os_bypass; 4183 4184 case MTWSM: 4185 if (STp->write_prot) 4186 return (-EACCES); 4187 if (!STp->raw) 4188 return 0; 4189 cmd[0] = WRITE_FILEMARKS; /* FIXME -- need OS version */ 4190 if (cmd_in == MTWSM) 4191 cmd[1] = 2; 4192 cmd[2] = (arg >> 16); 4193 cmd[3] = (arg >> 8); 4194 cmd[4] = arg; 4195 timeout = STp->timeout; 4196#if DEBUG 4197 if (debugging) 4198 printk(OSST_DEB_MSG "%s:D: Writing %d setmark(s).\n", name, 4199 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]); 4200#endif 4201 if (fileno >= 0) 4202 fileno += arg; 4203 blkno = 0; 4204 at_sm = (cmd_in == MTWSM); 4205 break; 4206 case MTOFFL: 4207 case MTLOAD: 4208 case MTUNLOAD: 4209 case MTRETEN: 4210 cmd[0] = START_STOP; 4211 cmd[1] = 1; /* Don't wait for completion */ 4212 if (cmd_in == MTLOAD) { 4213 if (STp->ready == ST_NO_TAPE) 4214 cmd[4] = 4; /* open tray */ 4215 else 4216 cmd[4] = 1; /* load */ 4217 } 4218 if (cmd_in == MTRETEN) 4219 cmd[4] = 3; /* retension then mount */ 4220 if (cmd_in == MTOFFL) 4221 cmd[4] = 4; /* rewind then eject */ 4222 timeout = STp->timeout; 4223#if DEBUG 4224 if (debugging) { 4225 switch (cmd_in) { 4226 case MTUNLOAD: 4227 printk(OSST_DEB_MSG "%s:D: Unloading tape.\n", name); 4228 break; 4229 case MTLOAD: 4230 printk(OSST_DEB_MSG "%s:D: Loading tape.\n", name); 4231 break; 4232 case MTRETEN: 4233 printk(OSST_DEB_MSG "%s:D: Retensioning tape.\n", name); 4234 break; 4235 case MTOFFL: 4236 printk(OSST_DEB_MSG "%s:D: Ejecting tape.\n", name); 4237 break; 4238 } 4239 } 4240#endif 4241 fileno = blkno = at_sm = frame_seq_numbr = logical_blk_num = 0 ; 4242 break; 4243 case MTNOP: 4244#if DEBUG 4245 if (debugging) 4246 printk(OSST_DEB_MSG "%s:D: No-op on tape.\n", name); 4247#endif 4248 return 0; /* Should do something ? */ 4249 break; 4250 case MTEOM: 4251#if DEBUG 4252 if (debugging) 4253 printk(OSST_DEB_MSG "%s:D: Spacing to end of recorded medium.\n", name); 4254#endif 4255 if ((osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos) < 0) || 4256 (osst_get_logical_frame(STp, &SRpnt, -1, 0) < 0)) { 4257 ioctl_result = -EIO; 4258 goto os_bypass; 4259 } 4260 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_EOD) { 4261#if DEBUG 4262 printk(OSST_DEB_MSG "%s:D: No EOD frame found where expected.\n", name); 4263#endif 4264 ioctl_result = -EIO; 4265 goto os_bypass; 4266 } 4267 ioctl_result = osst_set_frame_position(STp, &SRpnt, STp->eod_frame_ppos, 0); 4268 fileno = STp->filemark_cnt; 4269 blkno = at_sm = 0; 4270 goto os_bypass; 4271 4272 case MTERASE: 4273 if (STp->write_prot) 4274 return (-EACCES); 4275 ioctl_result = osst_reset_header(STp, &SRpnt); 4276 i = osst_write_eod(STp, &SRpnt); 4277 if (i < ioctl_result) ioctl_result = i; 4278 i = osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos); 4279 if (i < ioctl_result) ioctl_result = i; 4280 fileno = blkno = at_sm = 0 ; 4281 goto os_bypass; 4282 4283 case MTREW: 4284 cmd[0] = REZERO_UNIT; /* rewind */ 4285 cmd[1] = 1; 4286#if DEBUG 4287 if (debugging) 4288 printk(OSST_DEB_MSG "%s:D: Rewinding tape, Immed=%d.\n", name, cmd[1]); 4289#endif 4290 fileno = blkno = at_sm = frame_seq_numbr = logical_blk_num = 0 ; 4291 break; 4292 4293 case MTSETBLK: /* Set block length */ 4294 if ((STps->drv_block == 0 ) && 4295 !STp->dirty && 4296 ((STp->buffer)->buffer_bytes == 0) && 4297 ((arg & MT_ST_BLKSIZE_MASK) >= 512 ) && 4298 ((arg & MT_ST_BLKSIZE_MASK) <= OS_DATA_SIZE) && 4299 !(OS_DATA_SIZE % (arg & MT_ST_BLKSIZE_MASK)) ) { 4300 /* 4301 * Only allowed to change the block size if you opened the 4302 * device at the beginning of a file before writing anything. 4303 * Note, that when reading, changing block_size is futile, 4304 * as the size used when writing overrides it. 4305 */ 4306 STp->block_size = (arg & MT_ST_BLKSIZE_MASK); 4307 printk(KERN_INFO "%s:I: Block size set to %d bytes.\n", 4308 name, STp->block_size); 4309 return 0; 4310 } 4311 case MTSETDENSITY: /* Set tape density */ 4312 case MTSETDRVBUFFER: /* Set drive buffering */ 4313 case SET_DENS_AND_BLK: /* Set density and block size */ 4314 chg_eof = 0; 4315 if (STp->dirty || (STp->buffer)->buffer_bytes != 0) 4316 return (-EIO); /* Not allowed if data in buffer */ 4317 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) && 4318 (arg & MT_ST_BLKSIZE_MASK) != 0 && 4319 (arg & MT_ST_BLKSIZE_MASK) != STp->block_size ) { 4320 printk(KERN_WARNING "%s:W: Illegal to set block size to %d%s.\n", 4321 name, (int)(arg & MT_ST_BLKSIZE_MASK), 4322 (OS_DATA_SIZE % (arg & MT_ST_BLKSIZE_MASK))?"":" now"); 4323 return (-EINVAL); 4324 } 4325 return 0; /* FIXME silently ignore if block size didn't change */ 4326 4327 default: 4328 return (-ENOSYS); 4329 } 4330 4331 SRpnt = osst_do_scsi(SRpnt, STp, cmd, datalen, direction, timeout, MAX_RETRIES, 1); 4332 4333 ioctl_result = (STp->buffer)->syscall_result; 4334 4335 if (!SRpnt) { 4336#if DEBUG 4337 printk(OSST_DEB_MSG "%s:D: Couldn't exec scsi cmd for IOCTL\n", name); 4338#endif 4339 return ioctl_result; 4340 } 4341 4342 if (!ioctl_result) { /* SCSI command successful */ 4343 STp->frame_seq_number = frame_seq_numbr; 4344 STp->logical_blk_num = logical_blk_num; 4345 } 4346 4347os_bypass: 4348#if DEBUG 4349 if (debugging) 4350 printk(OSST_DEB_MSG "%s:D: IOCTL (%d) Result=%d\n", name, cmd_in, ioctl_result); 4351#endif 4352 4353 if (!ioctl_result) { /* success */ 4354 4355 if (cmd_in == MTFSFM) { 4356 fileno--; 4357 blkno--; 4358 } 4359 if (cmd_in == MTBSFM) { 4360 fileno++; 4361 blkno++; 4362 } 4363 STps->drv_block = blkno; 4364 STps->drv_file = fileno; 4365 STps->at_sm = at_sm; 4366 4367 if (cmd_in == MTEOM) 4368 STps->eof = ST_EOD; 4369 else if ((cmd_in == MTFSFM || cmd_in == MTBSF) && STps->eof == ST_FM_HIT) { 4370 ioctl_result = osst_seek_logical_blk(STp, &SRpnt, STp->logical_blk_num-1); 4371 STps->drv_block++; 4372 STp->logical_blk_num++; 4373 STp->frame_seq_number++; 4374 STp->frame_in_buffer = 0; 4375 STp->buffer->read_pointer = 0; 4376 } 4377 else if (cmd_in == MTFSF) 4378 STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_FM; 4379 else if (chg_eof) 4380 STps->eof = ST_NOEOF; 4381 4382 if (cmd_in == MTOFFL || cmd_in == MTUNLOAD) 4383 STp->rew_at_close = 0; 4384 else if (cmd_in == MTLOAD) { 4385 for (i=0; i < ST_NBR_PARTITIONS; i++) { 4386 STp->ps[i].rw = ST_IDLE; 4387 STp->ps[i].last_block_valid = 0;/* FIXME - where else is this field maintained? */ 4388 } 4389 STp->partition = 0; 4390 } 4391 4392 if (cmd_in == MTREW) { 4393 ioctl_result = osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos); 4394 if (ioctl_result > 0) 4395 ioctl_result = 0; 4396 } 4397 4398 } else if (cmd_in == MTBSF || cmd_in == MTBSFM ) { 4399 if (osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos) < 0) 4400 STps->drv_file = STps->drv_block = -1; 4401 else 4402 STps->drv_file = STps->drv_block = 0; 4403 STps->eof = ST_NOEOF; 4404 } else if (cmd_in == MTFSF || cmd_in == MTFSFM) { 4405 if (osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos) < 0) 4406 STps->drv_file = STps->drv_block = -1; 4407 else { 4408 STps->drv_file = STp->filemark_cnt; 4409 STps->drv_block = 0; 4410 } 4411 STps->eof = ST_EOD; 4412 } else if (cmd_in == MTBSR || cmd_in == MTFSR || cmd_in == MTWEOF || cmd_in == MTEOM) { 4413 STps->drv_file = STps->drv_block = (-1); 4414 STps->eof = ST_NOEOF; 4415 STp->header_ok = 0; 4416 } else if (cmd_in == MTERASE) { 4417 STp->header_ok = 0; 4418 } else if (SRpnt) { /* SCSI command was not completely successful. */ 4419 if (SRpnt->sense[2] & 0x40) { 4420 STps->eof = ST_EOM_OK; 4421 STps->drv_block = 0; 4422 } 4423 if (chg_eof) 4424 STps->eof = ST_NOEOF; 4425 4426 if ((SRpnt->sense[2] & 0x0f) == BLANK_CHECK) 4427 STps->eof = ST_EOD; 4428 4429 if (cmd_in == MTLOAD && osst_wait_for_medium(STp, &SRpnt, 60)) 4430 ioctl_result = osst_wait_ready(STp, &SRpnt, 5 * 60, OSST_WAIT_POSITION_COMPLETE); 4431 } 4432 *aSRpnt = SRpnt; 4433 4434 return ioctl_result; 4435} 4436 4437 4438/* Open the device */ 4439static int __os_scsi_tape_open(struct inode * inode, struct file * filp) 4440{ 4441 unsigned short flags; 4442 int i, b_size, new_session = 0, retval = 0; 4443 unsigned char cmd[MAX_COMMAND_SIZE]; 4444 struct osst_request * SRpnt = NULL; 4445 struct osst_tape * STp; 4446 struct st_modedef * STm; 4447 struct st_partstat * STps; 4448 char * name; 4449 int dev = TAPE_NR(inode); 4450 int mode = TAPE_MODE(inode); 4451 4452 /* 4453 * We really want to do nonseekable_open(inode, filp); here, but some 4454 * versions of tar incorrectly call lseek on tapes and bail out if that 4455 * fails. So we disallow pread() and pwrite(), but permit lseeks. 4456 */ 4457 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 4458 4459 write_lock(&os_scsi_tapes_lock); 4460 if (dev >= osst_max_dev || os_scsi_tapes == NULL || 4461 (STp = os_scsi_tapes[dev]) == NULL || !STp->device) { 4462 write_unlock(&os_scsi_tapes_lock); 4463 return (-ENXIO); 4464 } 4465 4466 name = tape_name(STp); 4467 4468 if (STp->in_use) { 4469 write_unlock(&os_scsi_tapes_lock); 4470#if DEBUG 4471 printk(OSST_DEB_MSG "%s:D: Device already in use.\n", name); 4472#endif 4473 return (-EBUSY); 4474 } 4475 if (scsi_device_get(STp->device)) { 4476 write_unlock(&os_scsi_tapes_lock); 4477#if DEBUG 4478 printk(OSST_DEB_MSG "%s:D: Failed scsi_device_get.\n", name); 4479#endif 4480 return (-ENXIO); 4481 } 4482 filp->private_data = STp; 4483 STp->in_use = 1; 4484 write_unlock(&os_scsi_tapes_lock); 4485 STp->rew_at_close = TAPE_REWIND(inode); 4486 4487 if( !scsi_block_when_processing_errors(STp->device) ) { 4488 return -ENXIO; 4489 } 4490 4491 if (mode != STp->current_mode) { 4492#if DEBUG 4493 if (debugging) 4494 printk(OSST_DEB_MSG "%s:D: Mode change from %d to %d.\n", 4495 name, STp->current_mode, mode); 4496#endif 4497 new_session = 1; 4498 STp->current_mode = mode; 4499 } 4500 STm = &(STp->modes[STp->current_mode]); 4501 4502 flags = filp->f_flags; 4503 STp->write_prot = ((flags & O_ACCMODE) == O_RDONLY); 4504 4505 STp->raw = TAPE_IS_RAW(inode); 4506 if (STp->raw) 4507 STp->header_ok = 0; 4508 4509 /* Allocate data segments for this device's tape buffer */ 4510 if (!enlarge_buffer(STp->buffer, STp->restr_dma)) { 4511 printk(KERN_ERR "%s:E: Unable to allocate memory segments for tape buffer.\n", name); 4512 retval = (-EOVERFLOW); 4513 goto err_out; 4514 } 4515 if (STp->buffer->buffer_size >= OS_FRAME_SIZE) { 4516 for (i = 0, b_size = 0; 4517 (i < STp->buffer->sg_segs) && ((b_size + STp->buffer->sg[i].length) <= OS_DATA_SIZE); 4518 b_size += STp->buffer->sg[i++].length); 4519 STp->buffer->aux = (os_aux_t *) (page_address(sg_page(&STp->buffer->sg[i])) + OS_DATA_SIZE - b_size); 4520#if DEBUG 4521 printk(OSST_DEB_MSG "%s:D: b_data points to %p in segment 0 at %p\n", name, 4522 STp->buffer->b_data, page_address(STp->buffer->sg[0].page)); 4523 printk(OSST_DEB_MSG "%s:D: AUX points to %p in segment %d at %p\n", name, 4524 STp->buffer->aux, i, page_address(STp->buffer->sg[i].page)); 4525#endif 4526 } else { 4527 STp->buffer->aux = NULL; /* this had better never happen! */ 4528 printk(KERN_NOTICE "%s:A: Framesize %d too large for buffer.\n", name, OS_FRAME_SIZE); 4529 retval = (-EIO); 4530 goto err_out; 4531 } 4532 STp->buffer->writing = 0; 4533 STp->buffer->syscall_result = 0; 4534 STp->dirty = 0; 4535 for (i=0; i < ST_NBR_PARTITIONS; i++) { 4536 STps = &(STp->ps[i]); 4537 STps->rw = ST_IDLE; 4538 } 4539 STp->ready = ST_READY; 4540#if DEBUG 4541 STp->nbr_waits = STp->nbr_finished = 0; 4542#endif 4543 4544 memset (cmd, 0, MAX_COMMAND_SIZE); 4545 cmd[0] = TEST_UNIT_READY; 4546 4547 SRpnt = osst_do_scsi(NULL, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1); 4548 if (!SRpnt) { 4549 retval = (STp->buffer)->syscall_result; /* FIXME - valid? */ 4550 goto err_out; 4551 } 4552 if ((SRpnt->sense[0] & 0x70) == 0x70 && 4553 (SRpnt->sense[2] & 0x0f) == NOT_READY && 4554 SRpnt->sense[12] == 4 ) { 4555#if DEBUG 4556 printk(OSST_DEB_MSG "%s:D: Unit not ready, cause %x\n", name, SRpnt->sense[13]); 4557#endif 4558 if (filp->f_flags & O_NONBLOCK) { 4559 retval = -EAGAIN; 4560 goto err_out; 4561 } 4562 if (SRpnt->sense[13] == 2) { /* initialize command required (LOAD) */ 4563 memset (cmd, 0, MAX_COMMAND_SIZE); 4564 cmd[0] = START_STOP; 4565 cmd[1] = 1; 4566 cmd[4] = 1; 4567 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, 4568 STp->timeout, MAX_RETRIES, 1); 4569 } 4570 osst_wait_ready(STp, &SRpnt, (SRpnt->sense[13]==1?15:3) * 60, 0); 4571 } 4572 if ((SRpnt->sense[0] & 0x70) == 0x70 && 4573 (SRpnt->sense[2] & 0x0f) == UNIT_ATTENTION) { /* New media? */ 4574#if DEBUG 4575 printk(OSST_DEB_MSG "%s:D: Unit wants attention\n", name); 4576#endif 4577 STp->header_ok = 0; 4578 4579 for (i=0; i < 10; i++) { 4580 4581 memset (cmd, 0, MAX_COMMAND_SIZE); 4582 cmd[0] = TEST_UNIT_READY; 4583 4584 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, 4585 STp->timeout, MAX_RETRIES, 1); 4586 if ((SRpnt->sense[0] & 0x70) != 0x70 || 4587 (SRpnt->sense[2] & 0x0f) != UNIT_ATTENTION) 4588 break; 4589 } 4590 4591 STp->pos_unknown = 0; 4592 STp->partition = STp->new_partition = 0; 4593 if (STp->can_partitions) 4594 STp->nbr_partitions = 1; /* This guess will be updated later if necessary */ 4595 for (i=0; i < ST_NBR_PARTITIONS; i++) { 4596 STps = &(STp->ps[i]); 4597 STps->rw = ST_IDLE; /* FIXME - seems to be redundant... */ 4598 STps->eof = ST_NOEOF; 4599 STps->at_sm = 0; 4600 STps->last_block_valid = 0; 4601 STps->drv_block = 0; 4602 STps->drv_file = 0 ; 4603 } 4604 new_session = 1; 4605 STp->recover_count = 0; 4606 STp->abort_count = 0; 4607 } 4608 /* 4609 * if we have valid headers from before, and the drive/tape seem untouched, 4610 * open without reconfiguring and re-reading the headers 4611 */ 4612 if (!STp->buffer->syscall_result && STp->header_ok && 4613 !SRpnt->result && SRpnt->sense[0] == 0) { 4614 4615 memset(cmd, 0, MAX_COMMAND_SIZE); 4616 cmd[0] = MODE_SENSE; 4617 cmd[1] = 8; 4618 cmd[2] = VENDOR_IDENT_PAGE; 4619 cmd[4] = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH; 4620 4621 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1); 4622 4623 if (STp->buffer->syscall_result || 4624 STp->buffer->b_data[MODE_HEADER_LENGTH + 2] != 'L' || 4625 STp->buffer->b_data[MODE_HEADER_LENGTH + 3] != 'I' || 4626 STp->buffer->b_data[MODE_HEADER_LENGTH + 4] != 'N' || 4627 STp->buffer->b_data[MODE_HEADER_LENGTH + 5] != '4' ) { 4628#if DEBUG 4629 printk(OSST_DEB_MSG "%s:D: Signature was changed to %c%c%c%c\n", name, 4630 STp->buffer->b_data[MODE_HEADER_LENGTH + 2], 4631 STp->buffer->b_data[MODE_HEADER_LENGTH + 3], 4632 STp->buffer->b_data[MODE_HEADER_LENGTH + 4], 4633 STp->buffer->b_data[MODE_HEADER_LENGTH + 5]); 4634#endif 4635 STp->header_ok = 0; 4636 } 4637 i = STp->first_frame_position; 4638 if (STp->header_ok && i == osst_get_frame_position(STp, &SRpnt)) { 4639 if (STp->door_locked == ST_UNLOCKED) { 4640 if (do_door_lock(STp, 1)) 4641 printk(KERN_INFO "%s:I: Can't lock drive door\n", name); 4642 else 4643 STp->door_locked = ST_LOCKED_AUTO; 4644 } 4645 if (!STp->frame_in_buffer) { 4646 STp->block_size = (STm->default_blksize > 0) ? 4647 STm->default_blksize : OS_DATA_SIZE; 4648 STp->buffer->buffer_bytes = STp->buffer->read_pointer = 0; 4649 } 4650 STp->buffer->buffer_blocks = OS_DATA_SIZE / STp->block_size; 4651 STp->fast_open = 1; 4652 osst_release_request(SRpnt); 4653 return 0; 4654 } 4655#if DEBUG 4656 if (i != STp->first_frame_position) 4657 printk(OSST_DEB_MSG "%s:D: Tape position changed from %d to %d\n", 4658 name, i, STp->first_frame_position); 4659#endif 4660 STp->header_ok = 0; 4661 } 4662 STp->fast_open = 0; 4663 4664 if ((STp->buffer)->syscall_result != 0 && /* in all error conditions except no medium */ 4665 (SRpnt->sense[2] != 2 || SRpnt->sense[12] != 0x3A) ) { 4666 4667 memset(cmd, 0, MAX_COMMAND_SIZE); 4668 cmd[0] = MODE_SELECT; 4669 cmd[1] = 0x10; 4670 cmd[4] = 4 + MODE_HEADER_LENGTH; 4671 4672 (STp->buffer)->b_data[0] = cmd[4] - 1; 4673 (STp->buffer)->b_data[1] = 0; /* Medium Type - ignoring */ 4674 (STp->buffer)->b_data[2] = 0; /* Reserved */ 4675 (STp->buffer)->b_data[3] = 0; /* Block Descriptor Length */ 4676 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = 0x3f; 4677 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 1; 4678 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 2; 4679 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = 3; 4680 4681#if DEBUG 4682 printk(OSST_DEB_MSG "%s:D: Applying soft reset\n", name); 4683#endif 4684 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1); 4685 4686 STp->header_ok = 0; 4687 4688 for (i=0; i < 10; i++) { 4689 4690 memset (cmd, 0, MAX_COMMAND_SIZE); 4691 cmd[0] = TEST_UNIT_READY; 4692 4693 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, 4694 STp->timeout, MAX_RETRIES, 1); 4695 if ((SRpnt->sense[0] & 0x70) != 0x70 || 4696 (SRpnt->sense[2] & 0x0f) == NOT_READY) 4697 break; 4698 4699 if ((SRpnt->sense[2] & 0x0f) == UNIT_ATTENTION) { 4700 int j; 4701 4702 STp->pos_unknown = 0; 4703 STp->partition = STp->new_partition = 0; 4704 if (STp->can_partitions) 4705 STp->nbr_partitions = 1; /* This guess will be updated later if necessary */ 4706 for (j = 0; j < ST_NBR_PARTITIONS; j++) { 4707 STps = &(STp->ps[j]); 4708 STps->rw = ST_IDLE; 4709 STps->eof = ST_NOEOF; 4710 STps->at_sm = 0; 4711 STps->last_block_valid = 0; 4712 STps->drv_block = 0; 4713 STps->drv_file = 0 ; 4714 } 4715 new_session = 1; 4716 } 4717 } 4718 } 4719 4720 if (osst_wait_ready(STp, &SRpnt, 15 * 60, 0)) /* FIXME - not allowed with NOBLOCK */ 4721 printk(KERN_INFO "%s:I: Device did not become Ready in open\n", name); 4722 4723 if ((STp->buffer)->syscall_result != 0) { 4724 if ((STp->device)->scsi_level >= SCSI_2 && 4725 (SRpnt->sense[0] & 0x70) == 0x70 && 4726 (SRpnt->sense[2] & 0x0f) == NOT_READY && 4727 SRpnt->sense[12] == 0x3a) { /* Check ASC */ 4728 STp->ready = ST_NO_TAPE; 4729 } else 4730 STp->ready = ST_NOT_READY; 4731 osst_release_request(SRpnt); 4732 SRpnt = NULL; 4733 STp->density = 0; /* Clear the erroneous "residue" */ 4734 STp->write_prot = 0; 4735 STp->block_size = 0; 4736 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1); 4737 STp->partition = STp->new_partition = 0; 4738 STp->door_locked = ST_UNLOCKED; 4739 return 0; 4740 } 4741 4742 osst_configure_onstream(STp, &SRpnt); 4743 4744 STp->block_size = STp->raw ? OS_FRAME_SIZE : ( 4745 (STm->default_blksize > 0) ? STm->default_blksize : OS_DATA_SIZE); 4746 STp->buffer->buffer_blocks = STp->raw ? 1 : OS_DATA_SIZE / STp->block_size; 4747 STp->buffer->buffer_bytes = 4748 STp->buffer->read_pointer = 4749 STp->frame_in_buffer = 0; 4750 4751#if DEBUG 4752 if (debugging) 4753 printk(OSST_DEB_MSG "%s:D: Block size: %d, frame size: %d, buffer size: %d (%d blocks).\n", 4754 name, STp->block_size, OS_FRAME_SIZE, (STp->buffer)->buffer_size, 4755 (STp->buffer)->buffer_blocks); 4756#endif 4757 4758 if (STp->drv_write_prot) { 4759 STp->write_prot = 1; 4760#if DEBUG 4761 if (debugging) 4762 printk(OSST_DEB_MSG "%s:D: Write protected\n", name); 4763#endif 4764 if ((flags & O_ACCMODE) == O_WRONLY || (flags & O_ACCMODE) == O_RDWR) { 4765 retval = (-EROFS); 4766 goto err_out; 4767 } 4768 } 4769 4770 if (new_session) { /* Change the drive parameters for the new mode */ 4771#if DEBUG 4772 if (debugging) 4773 printk(OSST_DEB_MSG "%s:D: New Session\n", name); 4774#endif 4775 STp->density_changed = STp->blksize_changed = 0; 4776 STp->compression_changed = 0; 4777 } 4778 4779 /* 4780 * properly position the tape and check the ADR headers 4781 */ 4782 if (STp->door_locked == ST_UNLOCKED) { 4783 if (do_door_lock(STp, 1)) 4784 printk(KERN_INFO "%s:I: Can't lock drive door\n", name); 4785 else 4786 STp->door_locked = ST_LOCKED_AUTO; 4787 } 4788 4789 osst_analyze_headers(STp, &SRpnt); 4790 4791 osst_release_request(SRpnt); 4792 SRpnt = NULL; 4793 4794 return 0; 4795 4796err_out: 4797 if (SRpnt != NULL) 4798 osst_release_request(SRpnt); 4799 normalize_buffer(STp->buffer); 4800 STp->header_ok = 0; 4801 STp->in_use = 0; 4802 scsi_device_put(STp->device); 4803 4804 return retval; 4805} 4806 4807/* BKL pushdown: spaghetti avoidance wrapper */ 4808static int os_scsi_tape_open(struct inode * inode, struct file * filp) 4809{ 4810 int ret; 4811 4812 mutex_lock(&osst_int_mutex); 4813 ret = __os_scsi_tape_open(inode, filp); 4814 mutex_unlock(&osst_int_mutex); 4815 return ret; 4816} 4817 4818 4819 4820/* Flush the tape buffer before close */ 4821static int os_scsi_tape_flush(struct file * filp, fl_owner_t id) 4822{ 4823 int result = 0, result2; 4824 struct osst_tape * STp = filp->private_data; 4825 struct st_modedef * STm = &(STp->modes[STp->current_mode]); 4826 struct st_partstat * STps = &(STp->ps[STp->partition]); 4827 struct osst_request * SRpnt = NULL; 4828 char * name = tape_name(STp); 4829 4830 if (file_count(filp) > 1) 4831 return 0; 4832 4833 if ((STps->rw == ST_WRITING || STp->dirty) && !STp->pos_unknown) { 4834 STp->write_type = OS_WRITE_DATA; 4835 result = osst_flush_write_buffer(STp, &SRpnt); 4836 if (result != 0 && result != (-ENOSPC)) 4837 goto out; 4838 } 4839 if ( STps->rw >= ST_WRITING && !STp->pos_unknown) { 4840 4841#if DEBUG 4842 if (debugging) { 4843 printk(OSST_DEB_MSG "%s:D: File length %ld bytes.\n", 4844 name, (long)(filp->f_pos)); 4845 printk(OSST_DEB_MSG "%s:D: Async write waits %d, finished %d.\n", 4846 name, STp->nbr_waits, STp->nbr_finished); 4847 } 4848#endif 4849 result = osst_write_trailer(STp, &SRpnt, !(STp->rew_at_close)); 4850#if DEBUG 4851 if (debugging) 4852 printk(OSST_DEB_MSG "%s:D: Buffer flushed, %d EOF(s) written\n", 4853 name, 1+STp->two_fm); 4854#endif 4855 } 4856 else if (!STp->rew_at_close) { 4857 STps = &(STp->ps[STp->partition]); 4858 if (!STm->sysv || STps->rw != ST_READING) { 4859 if (STp->can_bsr) 4860 result = osst_flush_buffer(STp, &SRpnt, 0); /* this is the default path */ 4861 else if (STps->eof == ST_FM_HIT) { 4862 result = cross_eof(STp, &SRpnt, 0); 4863 if (result) { 4864 if (STps->drv_file >= 0) 4865 STps->drv_file++; 4866 STps->drv_block = 0; 4867 STps->eof = ST_FM; 4868 } 4869 else 4870 STps->eof = ST_NOEOF; 4871 } 4872 } 4873 else if ((STps->eof == ST_NOEOF && 4874 !(result = cross_eof(STp, &SRpnt, 1))) || 4875 STps->eof == ST_FM_HIT) { 4876 if (STps->drv_file >= 0) 4877 STps->drv_file++; 4878 STps->drv_block = 0; 4879 STps->eof = ST_FM; 4880 } 4881 } 4882 4883out: 4884 if (STp->rew_at_close) { 4885 result2 = osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos); 4886 STps->drv_file = STps->drv_block = STp->frame_seq_number = STp->logical_blk_num = 0; 4887 if (result == 0 && result2 < 0) 4888 result = result2; 4889 } 4890 if (SRpnt) osst_release_request(SRpnt); 4891 4892 if (STp->abort_count || STp->recover_count) { 4893 printk(KERN_INFO "%s:I:", name); 4894 if (STp->abort_count) 4895 printk(" %d unrecovered errors", STp->abort_count); 4896 if (STp->recover_count) 4897 printk(" %d recovered errors", STp->recover_count); 4898 if (STp->write_count) 4899 printk(" in %d frames written", STp->write_count); 4900 if (STp->read_count) 4901 printk(" in %d frames read", STp->read_count); 4902 printk("\n"); 4903 STp->recover_count = 0; 4904 STp->abort_count = 0; 4905 } 4906 STp->write_count = 0; 4907 STp->read_count = 0; 4908 4909 return result; 4910} 4911 4912 4913/* Close the device and release it */ 4914static int os_scsi_tape_close(struct inode * inode, struct file * filp) 4915{ 4916 int result = 0; 4917 struct osst_tape * STp = filp->private_data; 4918 4919 if (STp->door_locked == ST_LOCKED_AUTO) 4920 do_door_lock(STp, 0); 4921 4922 if (STp->raw) 4923 STp->header_ok = 0; 4924 4925 normalize_buffer(STp->buffer); 4926 write_lock(&os_scsi_tapes_lock); 4927 STp->in_use = 0; 4928 write_unlock(&os_scsi_tapes_lock); 4929 4930 scsi_device_put(STp->device); 4931 4932 return result; 4933} 4934 4935 4936/* The ioctl command */ 4937static long osst_ioctl(struct file * file, 4938 unsigned int cmd_in, unsigned long arg) 4939{ 4940 int i, cmd_nr, cmd_type, blk, retval = 0; 4941 struct st_modedef * STm; 4942 struct st_partstat * STps; 4943 struct osst_request * SRpnt = NULL; 4944 struct osst_tape * STp = file->private_data; 4945 char * name = tape_name(STp); 4946 void __user * p = (void __user *)arg; 4947 4948 mutex_lock(&osst_int_mutex); 4949 if (mutex_lock_interruptible(&STp->lock)) { 4950 mutex_unlock(&osst_int_mutex); 4951 return -ERESTARTSYS; 4952 } 4953 4954#if DEBUG 4955 if (debugging && !STp->in_use) { 4956 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name); 4957 retval = (-EIO); 4958 goto out; 4959 } 4960#endif 4961 STm = &(STp->modes[STp->current_mode]); 4962 STps = &(STp->ps[STp->partition]); 4963 4964 /* 4965 * If we are in the middle of error recovery, don't let anyone 4966 * else try and use this device. Also, if error recovery fails, it 4967 * may try and take the device offline, in which case all further 4968 * access to the device is prohibited. 4969 */ 4970 if( !scsi_block_when_processing_errors(STp->device) ) { 4971 retval = (-ENXIO); 4972 goto out; 4973 } 4974 4975 cmd_type = _IOC_TYPE(cmd_in); 4976 cmd_nr = _IOC_NR(cmd_in); 4977#if DEBUG 4978 printk(OSST_DEB_MSG "%s:D: Ioctl %d,%d in %s mode\n", name, 4979 cmd_type, cmd_nr, STp->raw?"raw":"normal"); 4980#endif 4981 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) { 4982 struct mtop mtc; 4983 int auto_weof = 0; 4984 4985 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) { 4986 retval = (-EINVAL); 4987 goto out; 4988 } 4989 4990 i = copy_from_user((char *) &mtc, p, sizeof(struct mtop)); 4991 if (i) { 4992 retval = (-EFAULT); 4993 goto out; 4994 } 4995 4996 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) { 4997 printk(KERN_WARNING "%s:W: MTSETDRVBUFFER only allowed for root.\n", name); 4998 retval = (-EPERM); 4999 goto out; 5000 } 5001 5002 if (!STm->defined && (mtc.mt_op != MTSETDRVBUFFER && (mtc.mt_count & MT_ST_OPTIONS) == 0)) { 5003 retval = (-ENXIO); 5004 goto out; 5005 } 5006 5007 if (!STp->pos_unknown) { 5008 5009 if (STps->eof == ST_FM_HIT) { 5010 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM|| mtc.mt_op == MTEOM) { 5011 mtc.mt_count -= 1; 5012 if (STps->drv_file >= 0) 5013 STps->drv_file += 1; 5014 } 5015 else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) { 5016 mtc.mt_count += 1; 5017 if (STps->drv_file >= 0) 5018 STps->drv_file += 1; 5019 } 5020 } 5021 5022 if (mtc.mt_op == MTSEEK) { 5023 /* Old position must be restored if partition will be changed */ 5024 i = !STp->can_partitions || (STp->new_partition != STp->partition); 5025 } 5026 else { 5027 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL || 5028 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM || 5029 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD || 5030 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM || 5031 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM || 5032 mtc.mt_op == MTCOMPRESSION; 5033 } 5034 i = osst_flush_buffer(STp, &SRpnt, i); 5035 if (i < 0) { 5036 retval = i; 5037 goto out; 5038 } 5039 } 5040 else { 5041 /* 5042 * If there was a bus reset, block further access 5043 * to this device. If the user wants to rewind the tape, 5044 * then reset the flag and allow access again. 5045 */ 5046 if(mtc.mt_op != MTREW && 5047 mtc.mt_op != MTOFFL && 5048 mtc.mt_op != MTRETEN && 5049 mtc.mt_op != MTERASE && 5050 mtc.mt_op != MTSEEK && 5051 mtc.mt_op != MTEOM) { 5052 retval = (-EIO); 5053 goto out; 5054 } 5055 reset_state(STp); 5056 /* remove this when the midlevel properly clears was_reset */ 5057 STp->device->was_reset = 0; 5058 } 5059 5060 if (mtc.mt_op != MTCOMPRESSION && mtc.mt_op != MTLOCK && 5061 mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK && 5062 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTSETDRVBUFFER && 5063 mtc.mt_op != MTMKPART && mtc.mt_op != MTSETPART && 5064 mtc.mt_op != MTWEOF && mtc.mt_op != MTWSM ) { 5065 5066 /* 5067 * The user tells us to move to another position on the tape. 5068 * If we were appending to the tape content, that would leave 5069 * the tape without proper end, in that case write EOD and 5070 * update the header to reflect its position. 5071 */ 5072#if DEBUG 5073 printk(KERN_WARNING "%s:D: auto_weod %s at ffp=%d,efp=%d,fsn=%d,lbn=%d,fn=%d,bn=%d\n", name, 5074 STps->rw >= ST_WRITING ? "write" : STps->rw == ST_READING ? "read" : "idle", 5075 STp->first_frame_position, STp->eod_frame_ppos, STp->frame_seq_number, 5076 STp->logical_blk_num, STps->drv_file, STps->drv_block ); 5077#endif 5078 if (STps->rw >= ST_WRITING && STp->first_frame_position >= STp->eod_frame_ppos) { 5079 auto_weof = ((STp->write_type != OS_WRITE_NEW_MARK) && 5080 !(mtc.mt_op == MTREW || mtc.mt_op == MTOFFL)); 5081 i = osst_write_trailer(STp, &SRpnt, 5082 !(mtc.mt_op == MTREW || mtc.mt_op == MTOFFL)); 5083#if DEBUG 5084 printk(KERN_WARNING "%s:D: post trailer xeof=%d,ffp=%d,efp=%d,fsn=%d,lbn=%d,fn=%d,bn=%d\n", 5085 name, auto_weof, STp->first_frame_position, STp->eod_frame_ppos, 5086 STp->frame_seq_number, STp->logical_blk_num, STps->drv_file, STps->drv_block ); 5087#endif 5088 if (i < 0) { 5089 retval = i; 5090 goto out; 5091 } 5092 } 5093 STps->rw = ST_IDLE; 5094 } 5095 5096 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED) 5097 do_door_lock(STp, 0); /* Ignore result! */ 5098 5099 if (mtc.mt_op == MTSETDRVBUFFER && 5100 (mtc.mt_count & MT_ST_OPTIONS) != 0) { 5101 retval = osst_set_options(STp, mtc.mt_count); 5102 goto out; 5103 } 5104 5105 if (mtc.mt_op == MTSETPART) { 5106 if (mtc.mt_count >= STp->nbr_partitions) 5107 retval = -EINVAL; 5108 else { 5109 STp->new_partition = mtc.mt_count; 5110 retval = 0; 5111 } 5112 goto out; 5113 } 5114 5115 if (mtc.mt_op == MTMKPART) { 5116 if (!STp->can_partitions) { 5117 retval = (-EINVAL); 5118 goto out; 5119 } 5120 if ((i = osst_int_ioctl(STp, &SRpnt, MTREW, 0)) < 0 /*|| 5121 (i = partition_tape(inode, mtc.mt_count)) < 0*/) { 5122 retval = i; 5123 goto out; 5124 } 5125 for (i=0; i < ST_NBR_PARTITIONS; i++) { 5126 STp->ps[i].rw = ST_IDLE; 5127 STp->ps[i].at_sm = 0; 5128 STp->ps[i].last_block_valid = 0; 5129 } 5130 STp->partition = STp->new_partition = 0; 5131 STp->nbr_partitions = 1; /* Bad guess ?-) */ 5132 STps->drv_block = STps->drv_file = 0; 5133 retval = 0; 5134 goto out; 5135 } 5136 5137 if (mtc.mt_op == MTSEEK) { 5138 if (STp->raw) 5139 i = osst_set_frame_position(STp, &SRpnt, mtc.mt_count, 0); 5140 else 5141 i = osst_seek_sector(STp, &SRpnt, mtc.mt_count); 5142 if (!STp->can_partitions) 5143 STp->ps[0].rw = ST_IDLE; 5144 retval = i; 5145 goto out; 5146 } 5147 5148 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) { 5149 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK)); 5150 goto out; 5151 } 5152 5153 if (auto_weof) 5154 cross_eof(STp, &SRpnt, 0); 5155 5156 if (mtc.mt_op == MTCOMPRESSION) 5157 retval = -EINVAL; /* OnStream drives don't have compression hardware */ 5158 else 5159 /* MTBSF MTBSFM MTBSR MTBSS MTEOM MTERASE MTFSF MTFSFB MTFSR MTFSS 5160 * MTLOAD MTOFFL MTRESET MTRETEN MTREW MTUNLOAD MTWEOF MTWSM */ 5161 retval = osst_int_ioctl(STp, &SRpnt, mtc.mt_op, mtc.mt_count); 5162 goto out; 5163 } 5164 5165 if (!STm->defined) { 5166 retval = (-ENXIO); 5167 goto out; 5168 } 5169 5170 if ((i = osst_flush_buffer(STp, &SRpnt, 0)) < 0) { 5171 retval = i; 5172 goto out; 5173 } 5174 5175 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) { 5176 struct mtget mt_status; 5177 5178 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) { 5179 retval = (-EINVAL); 5180 goto out; 5181 } 5182 5183 mt_status.mt_type = MT_ISONSTREAM_SC; 5184 mt_status.mt_erreg = STp->recover_erreg << MT_ST_SOFTERR_SHIFT; 5185 mt_status.mt_dsreg = 5186 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | 5187 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK); 5188 mt_status.mt_blkno = STps->drv_block; 5189 mt_status.mt_fileno = STps->drv_file; 5190 if (STp->block_size != 0) { 5191 if (STps->rw == ST_WRITING) 5192 mt_status.mt_blkno += (STp->buffer)->buffer_bytes / STp->block_size; 5193 else if (STps->rw == ST_READING) 5194 mt_status.mt_blkno -= ((STp->buffer)->buffer_bytes + 5195 STp->block_size - 1) / STp->block_size; 5196 } 5197 5198 mt_status.mt_gstat = 0; 5199 if (STp->drv_write_prot) 5200 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff); 5201 if (mt_status.mt_blkno == 0) { 5202 if (mt_status.mt_fileno == 0) 5203 mt_status.mt_gstat |= GMT_BOT(0xffffffff); 5204 else 5205 mt_status.mt_gstat |= GMT_EOF(0xffffffff); 5206 } 5207 mt_status.mt_resid = STp->partition; 5208 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR) 5209 mt_status.mt_gstat |= GMT_EOT(0xffffffff); 5210 else if (STps->eof >= ST_EOM_OK) 5211 mt_status.mt_gstat |= GMT_EOD(0xffffffff); 5212 if (STp->density == 1) 5213 mt_status.mt_gstat |= GMT_D_800(0xffffffff); 5214 else if (STp->density == 2) 5215 mt_status.mt_gstat |= GMT_D_1600(0xffffffff); 5216 else if (STp->density == 3) 5217 mt_status.mt_gstat |= GMT_D_6250(0xffffffff); 5218 if (STp->ready == ST_READY) 5219 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff); 5220 if (STp->ready == ST_NO_TAPE) 5221 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff); 5222 if (STps->at_sm) 5223 mt_status.mt_gstat |= GMT_SM(0xffffffff); 5224 if (STm->do_async_writes || (STm->do_buffer_writes && STp->block_size != 0) || 5225 STp->drv_buffer != 0) 5226 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff); 5227 5228 i = copy_to_user(p, &mt_status, sizeof(struct mtget)); 5229 if (i) { 5230 retval = (-EFAULT); 5231 goto out; 5232 } 5233 5234 STp->recover_erreg = 0; /* Clear after read */ 5235 retval = 0; 5236 goto out; 5237 } /* End of MTIOCGET */ 5238 5239 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) { 5240 struct mtpos mt_pos; 5241 5242 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) { 5243 retval = (-EINVAL); 5244 goto out; 5245 } 5246 if (STp->raw) 5247 blk = osst_get_frame_position(STp, &SRpnt); 5248 else 5249 blk = osst_get_sector(STp, &SRpnt); 5250 if (blk < 0) { 5251 retval = blk; 5252 goto out; 5253 } 5254 mt_pos.mt_blkno = blk; 5255 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos)); 5256 if (i) 5257 retval = -EFAULT; 5258 goto out; 5259 } 5260 if (SRpnt) osst_release_request(SRpnt); 5261 5262 mutex_unlock(&STp->lock); 5263 5264 retval = scsi_ioctl(STp->device, cmd_in, p); 5265 mutex_unlock(&osst_int_mutex); 5266 return retval; 5267 5268out: 5269 if (SRpnt) osst_release_request(SRpnt); 5270 5271 mutex_unlock(&STp->lock); 5272 mutex_unlock(&osst_int_mutex); 5273 5274 return retval; 5275} 5276 5277#ifdef CONFIG_COMPAT 5278static long osst_compat_ioctl(struct file * file, unsigned int cmd_in, unsigned long arg) 5279{ 5280 struct osst_tape *STp = file->private_data; 5281 struct scsi_device *sdev = STp->device; 5282 int ret = -ENOIOCTLCMD; 5283 if (sdev->host->hostt->compat_ioctl) { 5284 5285 ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg); 5286 5287 } 5288 return ret; 5289} 5290#endif 5291 5292 5293 5294/* Memory handling routines */ 5295 5296/* Try to allocate a new tape buffer skeleton. Caller must not hold os_scsi_tapes_lock */ 5297static struct osst_buffer * new_tape_buffer( int from_initialization, int need_dma, int max_sg ) 5298{ 5299 int i; 5300 gfp_t priority; 5301 struct osst_buffer *tb; 5302 5303 if (from_initialization) 5304 priority = GFP_ATOMIC; 5305 else 5306 priority = GFP_KERNEL; 5307 5308 i = sizeof(struct osst_buffer) + (osst_max_sg_segs - 1) * sizeof(struct scatterlist); 5309 tb = kzalloc(i, priority); 5310 if (!tb) { 5311 printk(KERN_NOTICE "osst :I: Can't allocate new tape buffer.\n"); 5312 return NULL; 5313 } 5314 5315 tb->sg_segs = tb->orig_sg_segs = 0; 5316 tb->use_sg = max_sg; 5317 tb->in_use = 1; 5318 tb->dma = need_dma; 5319 tb->buffer_size = 0; 5320#if DEBUG 5321 if (debugging) 5322 printk(OSST_DEB_MSG 5323 "osst :D: Allocated tape buffer skeleton (%d bytes, %d segments, dma: %d).\n", 5324 i, max_sg, need_dma); 5325#endif 5326 return tb; 5327} 5328 5329/* Try to allocate a temporary (while a user has the device open) enlarged tape buffer */ 5330static int enlarge_buffer(struct osst_buffer *STbuffer, int need_dma) 5331{ 5332 int segs, nbr, max_segs, b_size, order, got; 5333 gfp_t priority; 5334 5335 if (STbuffer->buffer_size >= OS_FRAME_SIZE) 5336 return 1; 5337 5338 if (STbuffer->sg_segs) { 5339 printk(KERN_WARNING "osst :A: Buffer not previously normalized.\n"); 5340 normalize_buffer(STbuffer); 5341 } 5342 /* See how many segments we can use -- need at least two */ 5343 nbr = max_segs = STbuffer->use_sg; 5344 if (nbr <= 2) 5345 return 0; 5346 5347 priority = GFP_KERNEL /* | __GFP_NOWARN */; 5348 if (need_dma) 5349 priority |= GFP_DMA; 5350 5351 /* Try to allocate the first segment up to OS_DATA_SIZE and the others 5352 big enough to reach the goal (code assumes no segments in place) */ 5353 for (b_size = OS_DATA_SIZE, order = OSST_FIRST_ORDER; b_size >= PAGE_SIZE; order--, b_size /= 2) { 5354 struct page *page = alloc_pages(priority, order); 5355 5356 STbuffer->sg[0].offset = 0; 5357 if (page != NULL) { 5358 sg_set_page(&STbuffer->sg[0], page, b_size, 0); 5359 STbuffer->b_data = page_address(page); 5360 break; 5361 } 5362 } 5363 if (sg_page(&STbuffer->sg[0]) == NULL) { 5364 printk(KERN_NOTICE "osst :I: Can't allocate tape buffer main segment.\n"); 5365 return 0; 5366 } 5367 /* Got initial segment of 'bsize,order', continue with same size if possible, except for AUX */ 5368 for (segs=STbuffer->sg_segs=1, got=b_size; 5369 segs < max_segs && got < OS_FRAME_SIZE; ) { 5370 struct page *page = alloc_pages(priority, (OS_FRAME_SIZE - got <= PAGE_SIZE) ? 0 : order); 5371 STbuffer->sg[segs].offset = 0; 5372 if (page == NULL) { 5373 printk(KERN_WARNING "osst :W: Failed to enlarge buffer to %d bytes.\n", 5374 OS_FRAME_SIZE); 5375#if DEBUG 5376 STbuffer->buffer_size = got; 5377#endif 5378 normalize_buffer(STbuffer); 5379 return 0; 5380 } 5381 sg_set_page(&STbuffer->sg[segs], page, (OS_FRAME_SIZE - got <= PAGE_SIZE / 2) ? (OS_FRAME_SIZE - got) : b_size, 0); 5382 got += STbuffer->sg[segs].length; 5383 STbuffer->buffer_size = got; 5384 STbuffer->sg_segs = ++segs; 5385 } 5386#if DEBUG 5387 if (debugging) { 5388 printk(OSST_DEB_MSG 5389 "osst :D: Expanded tape buffer (%d bytes, %d->%d segments, dma: %d, at: %p).\n", 5390 got, STbuffer->orig_sg_segs, STbuffer->sg_segs, need_dma, STbuffer->b_data); 5391 printk(OSST_DEB_MSG 5392 "osst :D: segment sizes: first %d at %p, last %d bytes at %p.\n", 5393 STbuffer->sg[0].length, page_address(STbuffer->sg[0].page), 5394 STbuffer->sg[segs-1].length, page_address(STbuffer->sg[segs-1].page)); 5395 } 5396#endif 5397 5398 return 1; 5399} 5400 5401 5402/* Release the segments */ 5403static void normalize_buffer(struct osst_buffer *STbuffer) 5404{ 5405 int i, order, b_size; 5406 5407 for (i=0; i < STbuffer->sg_segs; i++) { 5408 5409 for (b_size = PAGE_SIZE, order = 0; 5410 b_size < STbuffer->sg[i].length; 5411 b_size *= 2, order++); 5412 5413 __free_pages(sg_page(&STbuffer->sg[i]), order); 5414 STbuffer->buffer_size -= STbuffer->sg[i].length; 5415 } 5416#if DEBUG 5417 if (debugging && STbuffer->orig_sg_segs < STbuffer->sg_segs) 5418 printk(OSST_DEB_MSG "osst :D: Buffer at %p normalized to %d bytes (segs %d).\n", 5419 STbuffer->b_data, STbuffer->buffer_size, STbuffer->sg_segs); 5420#endif 5421 STbuffer->sg_segs = STbuffer->orig_sg_segs = 0; 5422} 5423 5424 5425/* Move data from the user buffer to the tape buffer. Returns zero (success) or 5426 negative error code. */ 5427static int append_to_buffer(const char __user *ubp, struct osst_buffer *st_bp, int do_count) 5428{ 5429 int i, cnt, res, offset; 5430 5431 for (i=0, offset=st_bp->buffer_bytes; 5432 i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++) 5433 offset -= st_bp->sg[i].length; 5434 if (i == st_bp->sg_segs) { /* Should never happen */ 5435 printk(KERN_WARNING "osst :A: Append_to_buffer offset overflow.\n"); 5436 return (-EIO); 5437 } 5438 for ( ; i < st_bp->sg_segs && do_count > 0; i++) { 5439 cnt = st_bp->sg[i].length - offset < do_count ? 5440 st_bp->sg[i].length - offset : do_count; 5441 res = copy_from_user(page_address(sg_page(&st_bp->sg[i])) + offset, ubp, cnt); 5442 if (res) 5443 return (-EFAULT); 5444 do_count -= cnt; 5445 st_bp->buffer_bytes += cnt; 5446 ubp += cnt; 5447 offset = 0; 5448 } 5449 if (do_count) { /* Should never happen */ 5450 printk(KERN_WARNING "osst :A: Append_to_buffer overflow (left %d).\n", 5451 do_count); 5452 return (-EIO); 5453 } 5454 return 0; 5455} 5456 5457 5458/* Move data from the tape buffer to the user buffer. Returns zero (success) or 5459 negative error code. */ 5460static int from_buffer(struct osst_buffer *st_bp, char __user *ubp, int do_count) 5461{ 5462 int i, cnt, res, offset; 5463 5464 for (i=0, offset=st_bp->read_pointer; 5465 i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++) 5466 offset -= st_bp->sg[i].length; 5467 if (i == st_bp->sg_segs) { /* Should never happen */ 5468 printk(KERN_WARNING "osst :A: From_buffer offset overflow.\n"); 5469 return (-EIO); 5470 } 5471 for ( ; i < st_bp->sg_segs && do_count > 0; i++) { 5472 cnt = st_bp->sg[i].length - offset < do_count ? 5473 st_bp->sg[i].length - offset : do_count; 5474 res = copy_to_user(ubp, page_address(sg_page(&st_bp->sg[i])) + offset, cnt); 5475 if (res) 5476 return (-EFAULT); 5477 do_count -= cnt; 5478 st_bp->buffer_bytes -= cnt; 5479 st_bp->read_pointer += cnt; 5480 ubp += cnt; 5481 offset = 0; 5482 } 5483 if (do_count) { /* Should never happen */ 5484 printk(KERN_WARNING "osst :A: From_buffer overflow (left %d).\n", do_count); 5485 return (-EIO); 5486 } 5487 return 0; 5488} 5489 5490/* Sets the tail of the buffer after fill point to zero. 5491 Returns zero (success) or negative error code. */ 5492static int osst_zero_buffer_tail(struct osst_buffer *st_bp) 5493{ 5494 int i, offset, do_count, cnt; 5495 5496 for (i = 0, offset = st_bp->buffer_bytes; 5497 i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++) 5498 offset -= st_bp->sg[i].length; 5499 if (i == st_bp->sg_segs) { /* Should never happen */ 5500 printk(KERN_WARNING "osst :A: Zero_buffer offset overflow.\n"); 5501 return (-EIO); 5502 } 5503 for (do_count = OS_DATA_SIZE - st_bp->buffer_bytes; 5504 i < st_bp->sg_segs && do_count > 0; i++) { 5505 cnt = st_bp->sg[i].length - offset < do_count ? 5506 st_bp->sg[i].length - offset : do_count ; 5507 memset(page_address(sg_page(&st_bp->sg[i])) + offset, 0, cnt); 5508 do_count -= cnt; 5509 offset = 0; 5510 } 5511 if (do_count) { /* Should never happen */ 5512 printk(KERN_WARNING "osst :A: Zero_buffer overflow (left %d).\n", do_count); 5513 return (-EIO); 5514 } 5515 return 0; 5516} 5517 5518/* Copy a osst 32K chunk of memory into the buffer. 5519 Returns zero (success) or negative error code. */ 5520static int osst_copy_to_buffer(struct osst_buffer *st_bp, unsigned char *ptr) 5521{ 5522 int i, cnt, do_count = OS_DATA_SIZE; 5523 5524 for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) { 5525 cnt = st_bp->sg[i].length < do_count ? 5526 st_bp->sg[i].length : do_count ; 5527 memcpy(page_address(sg_page(&st_bp->sg[i])), ptr, cnt); 5528 do_count -= cnt; 5529 ptr += cnt; 5530 } 5531 if (do_count || i != st_bp->sg_segs-1) { /* Should never happen */ 5532 printk(KERN_WARNING "osst :A: Copy_to_buffer overflow (left %d at sg %d).\n", 5533 do_count, i); 5534 return (-EIO); 5535 } 5536 return 0; 5537} 5538 5539/* Copy a osst 32K chunk of memory from the buffer. 5540 Returns zero (success) or negative error code. */ 5541static int osst_copy_from_buffer(struct osst_buffer *st_bp, unsigned char *ptr) 5542{ 5543 int i, cnt, do_count = OS_DATA_SIZE; 5544 5545 for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) { 5546 cnt = st_bp->sg[i].length < do_count ? 5547 st_bp->sg[i].length : do_count ; 5548 memcpy(ptr, page_address(sg_page(&st_bp->sg[i])), cnt); 5549 do_count -= cnt; 5550 ptr += cnt; 5551 } 5552 if (do_count || i != st_bp->sg_segs-1) { /* Should never happen */ 5553 printk(KERN_WARNING "osst :A: Copy_from_buffer overflow (left %d at sg %d).\n", 5554 do_count, i); 5555 return (-EIO); 5556 } 5557 return 0; 5558} 5559 5560 5561/* Module housekeeping */ 5562 5563static void validate_options (void) 5564{ 5565 if (max_dev > 0) 5566 osst_max_dev = max_dev; 5567 if (write_threshold_kbs > 0) 5568 osst_write_threshold = write_threshold_kbs * ST_KILOBYTE; 5569 if (osst_write_threshold > osst_buffer_size) 5570 osst_write_threshold = osst_buffer_size; 5571 if (max_sg_segs >= OSST_FIRST_SG) 5572 osst_max_sg_segs = max_sg_segs; 5573#if DEBUG 5574 printk(OSST_DEB_MSG "osst :D: max tapes %d, write threshold %d, max s/g segs %d.\n", 5575 osst_max_dev, osst_write_threshold, osst_max_sg_segs); 5576#endif 5577} 5578 5579#ifndef MODULE 5580/* Set the boot options. Syntax: osst=xxx,yyy,... 5581 where xxx is write threshold in 1024 byte blocks, 5582 and yyy is number of s/g segments to use. */ 5583static int __init osst_setup (char *str) 5584{ 5585 int i, ints[5]; 5586 char *stp; 5587 5588 stp = get_options(str, ARRAY_SIZE(ints), ints); 5589 5590 if (ints[0] > 0) { 5591 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++) 5592 *parms[i].val = ints[i + 1]; 5593 } else { 5594 while (stp != NULL) { 5595 for (i = 0; i < ARRAY_SIZE(parms); i++) { 5596 int len = strlen(parms[i].name); 5597 if (!strncmp(stp, parms[i].name, len) && 5598 (*(stp + len) == ':' || *(stp + len) == '=')) { 5599 *parms[i].val = 5600 simple_strtoul(stp + len + 1, NULL, 0); 5601 break; 5602 } 5603 } 5604 if (i >= ARRAY_SIZE(parms)) 5605 printk(KERN_INFO "osst :I: Illegal parameter in '%s'\n", 5606 stp); 5607 stp = strchr(stp, ','); 5608 if (stp) 5609 stp++; 5610 } 5611 } 5612 5613 return 1; 5614} 5615 5616__setup("osst=", osst_setup); 5617 5618#endif 5619 5620static const struct file_operations osst_fops = { 5621 .owner = THIS_MODULE, 5622 .read = osst_read, 5623 .write = osst_write, 5624 .unlocked_ioctl = osst_ioctl, 5625#ifdef CONFIG_COMPAT 5626 .compat_ioctl = osst_compat_ioctl, 5627#endif 5628 .open = os_scsi_tape_open, 5629 .flush = os_scsi_tape_flush, 5630 .release = os_scsi_tape_close, 5631 .llseek = noop_llseek, 5632}; 5633 5634static int osst_supports(struct scsi_device * SDp) 5635{ 5636 struct osst_support_data { 5637 char *vendor; 5638 char *model; 5639 char *rev; 5640 char *driver_hint; /* Name of the correct driver, NULL if unknown */ 5641 }; 5642 5643static struct osst_support_data support_list[] = { 5644 /* {"XXX", "Yy-", "", NULL}, example */ 5645 SIGS_FROM_OSST, 5646 {NULL, }}; 5647 5648 struct osst_support_data *rp; 5649 5650 /* We are willing to drive OnStream SC-x0 as well as the 5651 * * IDE, ParPort, FireWire, USB variants, if accessible by 5652 * * emulation layer (ide-scsi, usb-storage, ...) */ 5653 5654 for (rp=&(support_list[0]); rp->vendor != NULL; rp++) 5655 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) && 5656 !strncmp(rp->model, SDp->model, strlen(rp->model)) && 5657 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) 5658 return 1; 5659 return 0; 5660} 5661 5662/* 5663 * sysfs support for osst driver parameter information 5664 */ 5665 5666static ssize_t osst_version_show(struct device_driver *ddd, char *buf) 5667{ 5668 return snprintf(buf, PAGE_SIZE, "%s\n", osst_version); 5669} 5670 5671static DRIVER_ATTR(version, S_IRUGO, osst_version_show, NULL); 5672 5673static int osst_create_sysfs_files(struct device_driver *sysfs) 5674{ 5675 return driver_create_file(sysfs, &driver_attr_version); 5676} 5677 5678static void osst_remove_sysfs_files(struct device_driver *sysfs) 5679{ 5680 driver_remove_file(sysfs, &driver_attr_version); 5681} 5682 5683/* 5684 * sysfs support for accessing ADR header information 5685 */ 5686 5687static ssize_t osst_adr_rev_show(struct device *dev, 5688 struct device_attribute *attr, char *buf) 5689{ 5690 struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); 5691 ssize_t l = 0; 5692 5693 if (STp && STp->header_ok && STp->linux_media) 5694 l = snprintf(buf, PAGE_SIZE, "%d.%d\n", STp->header_cache->major_rev, STp->header_cache->minor_rev); 5695 return l; 5696} 5697 5698DEVICE_ATTR(ADR_rev, S_IRUGO, osst_adr_rev_show, NULL); 5699 5700static ssize_t osst_linux_media_version_show(struct device *dev, 5701 struct device_attribute *attr, 5702 char *buf) 5703{ 5704 struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); 5705 ssize_t l = 0; 5706 5707 if (STp && STp->header_ok && STp->linux_media) 5708 l = snprintf(buf, PAGE_SIZE, "LIN%d\n", STp->linux_media_version); 5709 return l; 5710} 5711 5712DEVICE_ATTR(media_version, S_IRUGO, osst_linux_media_version_show, NULL); 5713 5714static ssize_t osst_capacity_show(struct device *dev, 5715 struct device_attribute *attr, char *buf) 5716{ 5717 struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); 5718 ssize_t l = 0; 5719 5720 if (STp && STp->header_ok && STp->linux_media) 5721 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->capacity); 5722 return l; 5723} 5724 5725DEVICE_ATTR(capacity, S_IRUGO, osst_capacity_show, NULL); 5726 5727static ssize_t osst_first_data_ppos_show(struct device *dev, 5728 struct device_attribute *attr, 5729 char *buf) 5730{ 5731 struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); 5732 ssize_t l = 0; 5733 5734 if (STp && STp->header_ok && STp->linux_media) 5735 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->first_data_ppos); 5736 return l; 5737} 5738 5739DEVICE_ATTR(BOT_frame, S_IRUGO, osst_first_data_ppos_show, NULL); 5740 5741static ssize_t osst_eod_frame_ppos_show(struct device *dev, 5742 struct device_attribute *attr, 5743 char *buf) 5744{ 5745 struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); 5746 ssize_t l = 0; 5747 5748 if (STp && STp->header_ok && STp->linux_media) 5749 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->eod_frame_ppos); 5750 return l; 5751} 5752 5753DEVICE_ATTR(EOD_frame, S_IRUGO, osst_eod_frame_ppos_show, NULL); 5754 5755static ssize_t osst_filemark_cnt_show(struct device *dev, 5756 struct device_attribute *attr, char *buf) 5757{ 5758 struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev); 5759 ssize_t l = 0; 5760 5761 if (STp && STp->header_ok && STp->linux_media) 5762 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->filemark_cnt); 5763 return l; 5764} 5765 5766DEVICE_ATTR(file_count, S_IRUGO, osst_filemark_cnt_show, NULL); 5767 5768static struct class *osst_sysfs_class; 5769 5770static int osst_sysfs_init(void) 5771{ 5772 osst_sysfs_class = class_create(THIS_MODULE, "onstream_tape"); 5773 if (IS_ERR(osst_sysfs_class)) { 5774 printk(KERN_ERR "osst :W: Unable to register sysfs class\n"); 5775 return PTR_ERR(osst_sysfs_class); 5776 } 5777 5778 return 0; 5779} 5780 5781static void osst_sysfs_destroy(dev_t dev) 5782{ 5783 device_destroy(osst_sysfs_class, dev); 5784} 5785 5786static int osst_sysfs_add(dev_t dev, struct device *device, struct osst_tape * STp, char * name) 5787{ 5788 struct device *osst_member; 5789 int err; 5790 5791 osst_member = device_create(osst_sysfs_class, device, dev, STp, 5792 "%s", name); 5793 if (IS_ERR(osst_member)) { 5794 printk(KERN_WARNING "osst :W: Unable to add sysfs class member %s\n", name); 5795 return PTR_ERR(osst_member); 5796 } 5797 5798 err = device_create_file(osst_member, &dev_attr_ADR_rev); 5799 if (err) 5800 goto err_out; 5801 err = device_create_file(osst_member, &dev_attr_media_version); 5802 if (err) 5803 goto err_out; 5804 err = device_create_file(osst_member, &dev_attr_capacity); 5805 if (err) 5806 goto err_out; 5807 err = device_create_file(osst_member, &dev_attr_BOT_frame); 5808 if (err) 5809 goto err_out; 5810 err = device_create_file(osst_member, &dev_attr_EOD_frame); 5811 if (err) 5812 goto err_out; 5813 err = device_create_file(osst_member, &dev_attr_file_count); 5814 if (err) 5815 goto err_out; 5816 5817 return 0; 5818 5819err_out: 5820 osst_sysfs_destroy(dev); 5821 return err; 5822} 5823 5824static void osst_sysfs_cleanup(void) 5825{ 5826 class_destroy(osst_sysfs_class); 5827} 5828 5829/* 5830 * osst startup / cleanup code 5831 */ 5832 5833static int osst_probe(struct device *dev) 5834{ 5835 struct scsi_device * SDp = to_scsi_device(dev); 5836 struct osst_tape * tpnt; 5837 struct st_modedef * STm; 5838 struct st_partstat * STps; 5839 struct osst_buffer * buffer; 5840 struct gendisk * drive; 5841 int i, dev_num, err = -ENODEV; 5842 5843 if (SDp->type != TYPE_TAPE || !osst_supports(SDp)) 5844 return -ENODEV; 5845 5846 drive = alloc_disk(1); 5847 if (!drive) { 5848 printk(KERN_ERR "osst :E: Out of memory. Device not attached.\n"); 5849 return -ENODEV; 5850 } 5851 5852 /* if this is the first attach, build the infrastructure */ 5853 write_lock(&os_scsi_tapes_lock); 5854 if (os_scsi_tapes == NULL) { 5855 os_scsi_tapes = kmalloc(osst_max_dev * sizeof(struct osst_tape *), GFP_ATOMIC); 5856 if (os_scsi_tapes == NULL) { 5857 write_unlock(&os_scsi_tapes_lock); 5858 printk(KERN_ERR "osst :E: Unable to allocate array for OnStream SCSI tapes.\n"); 5859 goto out_put_disk; 5860 } 5861 for (i=0; i < osst_max_dev; ++i) os_scsi_tapes[i] = NULL; 5862 } 5863 5864 if (osst_nr_dev >= osst_max_dev) { 5865 write_unlock(&os_scsi_tapes_lock); 5866 printk(KERN_ERR "osst :E: Too many tape devices (max. %d).\n", osst_max_dev); 5867 goto out_put_disk; 5868 } 5869 5870 /* find a free minor number */ 5871 for (i = 0; i < osst_max_dev && os_scsi_tapes[i]; i++) 5872 ; 5873 if(i >= osst_max_dev) panic ("Scsi_devices corrupt (osst)"); 5874 dev_num = i; 5875 5876 /* allocate a struct osst_tape for this device */ 5877 tpnt = kzalloc(sizeof(struct osst_tape), GFP_ATOMIC); 5878 if (!tpnt) { 5879 write_unlock(&os_scsi_tapes_lock); 5880 printk(KERN_ERR "osst :E: Can't allocate device descriptor, device not attached.\n"); 5881 goto out_put_disk; 5882 } 5883 5884 /* allocate a buffer for this device */ 5885 i = SDp->host->sg_tablesize; 5886 if (osst_max_sg_segs < i) 5887 i = osst_max_sg_segs; 5888 buffer = new_tape_buffer(1, SDp->host->unchecked_isa_dma, i); 5889 if (buffer == NULL) { 5890 write_unlock(&os_scsi_tapes_lock); 5891 printk(KERN_ERR "osst :E: Unable to allocate a tape buffer, device not attached.\n"); 5892 kfree(tpnt); 5893 goto out_put_disk; 5894 } 5895 os_scsi_tapes[dev_num] = tpnt; 5896 tpnt->buffer = buffer; 5897 tpnt->device = SDp; 5898 drive->private_data = &tpnt->driver; 5899 sprintf(drive->disk_name, "osst%d", dev_num); 5900 tpnt->driver = &osst_template; 5901 tpnt->drive = drive; 5902 tpnt->in_use = 0; 5903 tpnt->capacity = 0xfffff; 5904 tpnt->dirty = 0; 5905 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */ 5906 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma; 5907 tpnt->density = 0; 5908 tpnt->do_auto_lock = OSST_AUTO_LOCK; 5909 tpnt->can_bsr = OSST_IN_FILE_POS; 5910 tpnt->can_partitions = 0; 5911 tpnt->two_fm = OSST_TWO_FM; 5912 tpnt->fast_mteom = OSST_FAST_MTEOM; 5913 tpnt->scsi2_logical = OSST_SCSI2LOGICAL; /* FIXME */ 5914 tpnt->write_threshold = osst_write_threshold; 5915 tpnt->default_drvbuffer = 0xff; /* No forced buffering */ 5916 tpnt->partition = 0; 5917 tpnt->new_partition = 0; 5918 tpnt->nbr_partitions = 0; 5919 tpnt->min_block = 512; 5920 tpnt->max_block = OS_DATA_SIZE; 5921 tpnt->timeout = OSST_TIMEOUT; 5922 tpnt->long_timeout = OSST_LONG_TIMEOUT; 5923 5924 /* Recognize OnStream tapes */ 5925 /* We don't need to test for OnStream, as this has been done in detect () */ 5926 tpnt->os_fw_rev = osst_parse_firmware_rev (SDp->rev); 5927 tpnt->omit_blklims = 1; 5928 5929 tpnt->poll = (strncmp(SDp->model, "DI-", 3) == 0) || 5930 (strncmp(SDp->model, "FW-", 3) == 0) || OSST_FW_NEED_POLL(tpnt->os_fw_rev,SDp); 5931 tpnt->frame_in_buffer = 0; 5932 tpnt->header_ok = 0; 5933 tpnt->linux_media = 0; 5934 tpnt->header_cache = NULL; 5935 5936 for (i=0; i < ST_NBR_MODES; i++) { 5937 STm = &(tpnt->modes[i]); 5938 STm->defined = 0; 5939 STm->sysv = OSST_SYSV; 5940 STm->defaults_for_writes = 0; 5941 STm->do_async_writes = OSST_ASYNC_WRITES; 5942 STm->do_buffer_writes = OSST_BUFFER_WRITES; 5943 STm->do_read_ahead = OSST_READ_AHEAD; 5944 STm->default_compression = ST_DONT_TOUCH; 5945 STm->default_blksize = 512; 5946 STm->default_density = (-1); /* No forced density */ 5947 } 5948 5949 for (i=0; i < ST_NBR_PARTITIONS; i++) { 5950 STps = &(tpnt->ps[i]); 5951 STps->rw = ST_IDLE; 5952 STps->eof = ST_NOEOF; 5953 STps->at_sm = 0; 5954 STps->last_block_valid = 0; 5955 STps->drv_block = (-1); 5956 STps->drv_file = (-1); 5957 } 5958 5959 tpnt->current_mode = 0; 5960 tpnt->modes[0].defined = 1; 5961 tpnt->modes[2].defined = 1; 5962 tpnt->density_changed = tpnt->compression_changed = tpnt->blksize_changed = 0; 5963 5964 mutex_init(&tpnt->lock); 5965 osst_nr_dev++; 5966 write_unlock(&os_scsi_tapes_lock); 5967 5968 { 5969 char name[8]; 5970 5971 /* Rewind entry */ 5972 err = osst_sysfs_add(MKDEV(OSST_MAJOR, dev_num), dev, tpnt, tape_name(tpnt)); 5973 if (err) 5974 goto out_free_buffer; 5975 5976 /* No-rewind entry */ 5977 snprintf(name, 8, "%s%s", "n", tape_name(tpnt)); 5978 err = osst_sysfs_add(MKDEV(OSST_MAJOR, dev_num + 128), dev, tpnt, name); 5979 if (err) 5980 goto out_free_sysfs1; 5981 } 5982 5983 sdev_printk(KERN_INFO, SDp, 5984 "osst :I: Attached OnStream %.5s tape as %s\n", 5985 SDp->model, tape_name(tpnt)); 5986 5987 return 0; 5988 5989out_free_sysfs1: 5990 osst_sysfs_destroy(MKDEV(OSST_MAJOR, dev_num)); 5991out_free_buffer: 5992 kfree(buffer); 5993out_put_disk: 5994 put_disk(drive); 5995 return err; 5996}; 5997 5998static int osst_remove(struct device *dev) 5999{ 6000 struct scsi_device * SDp = to_scsi_device(dev); 6001 struct osst_tape * tpnt; 6002 int i; 6003 6004 if ((SDp->type != TYPE_TAPE) || (osst_nr_dev <= 0)) 6005 return 0; 6006 6007 write_lock(&os_scsi_tapes_lock); 6008 for(i=0; i < osst_max_dev; i++) { 6009 if((tpnt = os_scsi_tapes[i]) && (tpnt->device == SDp)) { 6010 osst_sysfs_destroy(MKDEV(OSST_MAJOR, i)); 6011 osst_sysfs_destroy(MKDEV(OSST_MAJOR, i+128)); 6012 tpnt->device = NULL; 6013 put_disk(tpnt->drive); 6014 os_scsi_tapes[i] = NULL; 6015 osst_nr_dev--; 6016 write_unlock(&os_scsi_tapes_lock); 6017 vfree(tpnt->header_cache); 6018 if (tpnt->buffer) { 6019 normalize_buffer(tpnt->buffer); 6020 kfree(tpnt->buffer); 6021 } 6022 kfree(tpnt); 6023 return 0; 6024 } 6025 } 6026 write_unlock(&os_scsi_tapes_lock); 6027 return 0; 6028} 6029 6030static int __init init_osst(void) 6031{ 6032 int err; 6033 6034 printk(KERN_INFO "osst :I: Tape driver with OnStream support version %s\nosst :I: %s\n", osst_version, cvsid); 6035 6036 validate_options(); 6037 6038 err = osst_sysfs_init(); 6039 if (err) 6040 return err; 6041 6042 err = register_chrdev(OSST_MAJOR, "osst", &osst_fops); 6043 if (err < 0) { 6044 printk(KERN_ERR "osst :E: Unable to register major %d for OnStream tapes\n", OSST_MAJOR); 6045 goto err_out; 6046 } 6047 6048 err = scsi_register_driver(&osst_template.gendrv); 6049 if (err) 6050 goto err_out_chrdev; 6051 6052 err = osst_create_sysfs_files(&osst_template.gendrv); 6053 if (err) 6054 goto err_out_scsidrv; 6055 6056 return 0; 6057 6058err_out_scsidrv: 6059 scsi_unregister_driver(&osst_template.gendrv); 6060err_out_chrdev: 6061 unregister_chrdev(OSST_MAJOR, "osst"); 6062err_out: 6063 osst_sysfs_cleanup(); 6064 return err; 6065} 6066 6067static void __exit exit_osst (void) 6068{ 6069 int i; 6070 struct osst_tape * STp; 6071 6072 osst_remove_sysfs_files(&osst_template.gendrv); 6073 scsi_unregister_driver(&osst_template.gendrv); 6074 unregister_chrdev(OSST_MAJOR, "osst"); 6075 osst_sysfs_cleanup(); 6076 6077 if (os_scsi_tapes) { 6078 for (i=0; i < osst_max_dev; ++i) { 6079 if (!(STp = os_scsi_tapes[i])) continue; 6080 /* This is defensive, supposed to happen during detach */ 6081 vfree(STp->header_cache); 6082 if (STp->buffer) { 6083 normalize_buffer(STp->buffer); 6084 kfree(STp->buffer); 6085 } 6086 put_disk(STp->drive); 6087 kfree(STp); 6088 } 6089 kfree(os_scsi_tapes); 6090 } 6091 printk(KERN_INFO "osst :I: Unloaded.\n"); 6092} 6093 6094module_init(init_osst); 6095module_exit(exit_osst); 6096