2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
6 Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
7 Contribution and ideas from several people including (in alphabetical
8 order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk,
9 Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky,
10 Michael Schaefer, J"org Weule, and Eric Youngdale.
12 Copyright 1992 - 2010 Kai Makisara
13 email Kai.Makisara@kolumbus.fi
15 Some small formal changes - aeb, 950809
17 Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
20 static const char *verstr
= "20101219";
22 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/sched.h>
28 #include <linux/init.h>
29 #include <linux/string.h>
30 #include <linux/slab.h>
31 #include <linux/errno.h>
32 #include <linux/mtio.h>
33 #include <linux/cdrom.h>
34 #include <linux/ioctl.h>
35 #include <linux/fcntl.h>
36 #include <linux/spinlock.h>
37 #include <linux/blkdev.h>
38 #include <linux/moduleparam.h>
39 #include <linux/cdev.h>
40 #include <linux/delay.h>
41 #include <linux/mutex.h>
43 #include <asm/uaccess.h>
45 #include <asm/system.h>
47 #include <scsi/scsi.h>
48 #include <scsi/scsi_dbg.h>
49 #include <scsi/scsi_device.h>
50 #include <scsi/scsi_driver.h>
51 #include <scsi/scsi_eh.h>
52 #include <scsi/scsi_host.h>
53 #include <scsi/scsi_ioctl.h>
57 /* The driver prints some debugging information on the console if DEBUG
58 is defined and non-zero. */
62 /* The message level for the debug messages is currently set to KERN_NOTICE
63 so that people can easily see the messages. Later when the debugging messages
64 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
65 #define ST_DEB_MSG KERN_NOTICE
67 #define DEBC(a) if (debugging) { a ; }
73 #define ST_KILOBYTE 1024
75 #include "st_options.h"
78 static DEFINE_MUTEX(st_mutex
);
79 static int buffer_kbs
;
80 static int max_sg_segs
;
81 static int try_direct_io
= TRY_DIRECT_IO
;
82 static int try_rdio
= 1;
83 static int try_wdio
= 1;
85 static int st_dev_max
;
88 static struct class *st_sysfs_class
;
90 MODULE_AUTHOR("Kai Makisara");
91 MODULE_DESCRIPTION("SCSI tape (st) driver");
92 MODULE_LICENSE("GPL");
93 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR
);
94 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE
);
96 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
97 * of sysfs parameters (which module_param doesn't yet support).
98 * Sysfs parameters defined explicitly later.
100 module_param_named(buffer_kbs
, buffer_kbs
, int, 0);
101 MODULE_PARM_DESC(buffer_kbs
, "Default driver buffer size for fixed block mode (KB; 32)");
102 module_param_named(max_sg_segs
, max_sg_segs
, int, 0);
103 MODULE_PARM_DESC(max_sg_segs
, "Maximum number of scatter/gather segments to use (256)");
104 module_param_named(try_direct_io
, try_direct_io
, int, 0);
105 MODULE_PARM_DESC(try_direct_io
, "Try direct I/O between user buffer and tape drive (1)");
107 /* Extra parameters for testing */
108 module_param_named(try_rdio
, try_rdio
, int, 0);
109 MODULE_PARM_DESC(try_rdio
, "Try direct read i/o when possible");
110 module_param_named(try_wdio
, try_wdio
, int, 0);
111 MODULE_PARM_DESC(try_wdio
, "Try direct write i/o when possible");
114 static int write_threshold_kbs
; /* retained for compatibility */
115 static struct st_dev_parm
{
118 } parms
[] __initdata
= {
120 "buffer_kbs", &buffer_kbs
122 { /* Retained for compatibility with 2.4 */
123 "write_threshold_kbs", &write_threshold_kbs
129 "try_direct_io", &try_direct_io
134 /* Restrict the number of modes so that names for all are assigned */
135 #if ST_NBR_MODES > 16
136 #error "Maximum number of modes is 16"
138 /* Bit reversed order to get same names for same minors with all
140 static const char *st_formats
[] = {
141 "", "r", "k", "s", "l", "t", "o", "u",
142 "m", "v", "p", "x", "a", "y", "q", "z"};
144 /* The default definitions have been moved to st_options.h */
146 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
148 /* The buffer size should fit into the 24 bits for length in the
149 6-byte SCSI read and write commands. */
150 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
151 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
154 static int debugging
= DEBUG
;
156 #define MAX_RETRIES 0
157 #define MAX_WRITE_RETRIES 0
158 #define MAX_READY_RETRIES 0
159 #define NO_TAPE NOT_READY
161 #define ST_TIMEOUT (900 * HZ)
162 #define ST_LONG_TIMEOUT (14000 * HZ)
164 /* Remove mode bits and auto-rewind bit (7) */
165 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
166 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
167 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
169 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
170 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
171 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
173 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
175 #define SET_DENS_AND_BLK 0x10001
177 static DEFINE_RWLOCK(st_dev_arr_lock
);
179 static int st_fixed_buffer_size
= ST_FIXED_BUFFER_SIZE
;
180 static int st_max_sg_segs
= ST_MAX_SG
;
182 static struct scsi_tape
**scsi_tapes
= NULL
;
184 static int modes_defined
;
186 static int enlarge_buffer(struct st_buffer
*, int, int);
187 static void clear_buffer(struct st_buffer
*);
188 static void normalize_buffer(struct st_buffer
*);
189 static int append_to_buffer(const char __user
*, struct st_buffer
*, int);
190 static int from_buffer(struct st_buffer
*, char __user
*, int);
191 static void move_buffer_data(struct st_buffer
*, int);
193 static int sgl_map_user_pages(struct st_buffer
*, const unsigned int,
194 unsigned long, size_t, int);
195 static int sgl_unmap_user_pages(struct st_buffer
*, const unsigned int, int);
197 static int st_probe(struct device
*);
198 static int st_remove(struct device
*);
200 static int do_create_sysfs_files(void);
201 static void do_remove_sysfs_files(void);
202 static int do_create_class_files(struct scsi_tape
*, int, int);
204 static struct scsi_driver st_template
= {
205 .owner
= THIS_MODULE
,
213 static int st_compression(struct scsi_tape
*, int);
215 static int find_partition(struct scsi_tape
*);
216 static int switch_partition(struct scsi_tape
*);
218 static int st_int_ioctl(struct scsi_tape
*, unsigned int, unsigned long);
220 static void scsi_tape_release(struct kref
*);
222 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
224 static DEFINE_MUTEX(st_ref_mutex
);
227 #include "osst_detect.h"
228 #ifndef SIGS_FROM_OSST
229 #define SIGS_FROM_OSST \
230 {"OnStream", "SC-", "", "osst"}, \
231 {"OnStream", "DI-", "", "osst"}, \
232 {"OnStream", "DP-", "", "osst"}, \
233 {"OnStream", "USB", "", "osst"}, \
234 {"OnStream", "FW-", "", "osst"}
237 static struct scsi_tape
*scsi_tape_get(int dev
)
239 struct scsi_tape
*STp
= NULL
;
241 mutex_lock(&st_ref_mutex
);
242 write_lock(&st_dev_arr_lock
);
244 if (dev
< st_dev_max
&& scsi_tapes
!= NULL
)
245 STp
= scsi_tapes
[dev
];
248 kref_get(&STp
->kref
);
253 if (scsi_device_get(STp
->device
))
259 kref_put(&STp
->kref
, scsi_tape_release
);
262 write_unlock(&st_dev_arr_lock
);
263 mutex_unlock(&st_ref_mutex
);
267 static void scsi_tape_put(struct scsi_tape
*STp
)
269 struct scsi_device
*sdev
= STp
->device
;
271 mutex_lock(&st_ref_mutex
);
272 kref_put(&STp
->kref
, scsi_tape_release
);
273 scsi_device_put(sdev
);
274 mutex_unlock(&st_ref_mutex
);
277 struct st_reject_data
{
281 char *driver_hint
; /* Name of the correct driver, NULL if unknown */
284 static struct st_reject_data reject_list
[] = {
285 /* {"XXX", "Yy-", "", NULL}, example */
289 /* If the device signature is on the list of incompatible drives, the
290 function returns a pointer to the name of the correct driver (if known) */
291 static char * st_incompatible(struct scsi_device
* SDp
)
293 struct st_reject_data
*rp
;
295 for (rp
=&(reject_list
[0]); rp
->vendor
!= NULL
; rp
++)
296 if (!strncmp(rp
->vendor
, SDp
->vendor
, strlen(rp
->vendor
)) &&
297 !strncmp(rp
->model
, SDp
->model
, strlen(rp
->model
)) &&
298 !strncmp(rp
->rev
, SDp
->rev
, strlen(rp
->rev
))) {
300 return rp
->driver_hint
;
308 static inline char *tape_name(struct scsi_tape
*tape
)
310 return tape
->disk
->disk_name
;
314 static void st_analyze_sense(struct st_request
*SRpnt
, struct st_cmdstatus
*s
)
317 const u8
*sense
= SRpnt
->sense
;
319 s
->have_sense
= scsi_normalize_sense(SRpnt
->sense
,
320 SCSI_SENSE_BUFFERSIZE
, &s
->sense_hdr
);
326 scsi_get_sense_info_fld(sense
, SCSI_SENSE_BUFFERSIZE
, &s
->uremainder64
);
327 switch (sense
[0] & 0x7f) {
332 s
->flags
= sense
[2] & 0xe0;
338 ucp
= scsi_sense_desc_find(sense
, SCSI_SENSE_BUFFERSIZE
, 4);
339 s
->flags
= ucp
? (ucp
[3] & 0xe0) : 0;
346 /* Convert the result to success code */
347 static int st_chk_result(struct scsi_tape
*STp
, struct st_request
* SRpnt
)
349 int result
= SRpnt
->result
;
351 DEB(const char *stp
;)
352 char *name
= tape_name(STp
);
353 struct st_cmdstatus
*cmdstatp
;
358 cmdstatp
= &STp
->buffer
->cmdstat
;
359 st_analyze_sense(SRpnt
, cmdstatp
);
361 if (cmdstatp
->have_sense
)
362 scode
= STp
->buffer
->cmdstat
.sense_hdr
.sense_key
;
368 printk(ST_DEB_MSG
"%s: Error: %x, cmd: %x %x %x %x %x %x\n",
370 SRpnt
->cmd
[0], SRpnt
->cmd
[1], SRpnt
->cmd
[2],
371 SRpnt
->cmd
[3], SRpnt
->cmd
[4], SRpnt
->cmd
[5]);
372 if (cmdstatp
->have_sense
)
373 __scsi_print_sense(name
, SRpnt
->sense
, SCSI_SENSE_BUFFERSIZE
);
375 if (!debugging
) { /* Abnormal conditions for tape */
376 if (!cmdstatp
->have_sense
)
378 "%s: Error %x (driver bt 0x%x, host bt 0x%x).\n",
379 name
, result
, driver_byte(result
),
381 else if (cmdstatp
->have_sense
&&
383 scode
!= RECOVERED_ERROR
&&
384 /* scode != UNIT_ATTENTION && */
385 scode
!= BLANK_CHECK
&&
386 scode
!= VOLUME_OVERFLOW
&&
387 SRpnt
->cmd
[0] != MODE_SENSE
&&
388 SRpnt
->cmd
[0] != TEST_UNIT_READY
) {
390 __scsi_print_sense(name
, SRpnt
->sense
, SCSI_SENSE_BUFFERSIZE
);
394 if (cmdstatp
->fixed_format
&&
395 STp
->cln_mode
>= EXTENDED_SENSE_START
) { /* Only fixed format sense */
396 if (STp
->cln_sense_value
)
397 STp
->cleaning_req
|= ((SRpnt
->sense
[STp
->cln_mode
] &
398 STp
->cln_sense_mask
) == STp
->cln_sense_value
);
400 STp
->cleaning_req
|= ((SRpnt
->sense
[STp
->cln_mode
] &
401 STp
->cln_sense_mask
) != 0);
403 if (cmdstatp
->have_sense
&&
404 cmdstatp
->sense_hdr
.asc
== 0 && cmdstatp
->sense_hdr
.ascq
== 0x17)
405 STp
->cleaning_req
= 1; /* ASC and ASCQ => cleaning requested */
407 STp
->pos_unknown
|= STp
->device
->was_reset
;
409 if (cmdstatp
->have_sense
&&
410 scode
== RECOVERED_ERROR
411 #if ST_RECOVERED_WRITE_FATAL
412 && SRpnt
->cmd
[0] != WRITE_6
413 && SRpnt
->cmd
[0] != WRITE_FILEMARKS
416 STp
->recover_count
++;
421 if (SRpnt
->cmd
[0] == READ_6
)
423 else if (SRpnt
->cmd
[0] == WRITE_6
)
427 printk(ST_DEB_MSG
"%s: Recovered %s error (%d).\n", name
, stp
,
431 if (cmdstatp
->flags
== 0)
437 static struct st_request
*st_allocate_request(struct scsi_tape
*stp
)
439 struct st_request
*streq
;
441 streq
= kzalloc(sizeof(*streq
), GFP_KERNEL
);
445 DEBC(printk(KERN_ERR
"%s: Can't get SCSI request.\n",
447 if (signal_pending(current
))
448 stp
->buffer
->syscall_result
= -EINTR
;
450 stp
->buffer
->syscall_result
= -EBUSY
;
456 static void st_release_request(struct st_request
*streq
)
461 static void st_scsi_execute_end(struct request
*req
, int uptodate
)
463 struct st_request
*SRpnt
= req
->end_io_data
;
464 struct scsi_tape
*STp
= SRpnt
->stp
;
467 STp
->buffer
->cmdstat
.midlevel_result
= SRpnt
->result
= req
->errors
;
468 STp
->buffer
->cmdstat
.residual
= req
->resid_len
;
472 complete(SRpnt
->waiting
);
474 blk_rq_unmap_user(tmp
);
475 __blk_put_request(req
->q
, req
);
478 static int st_scsi_execute(struct st_request
*SRpnt
, const unsigned char *cmd
,
479 int data_direction
, void *buffer
, unsigned bufflen
,
480 int timeout
, int retries
)
483 struct rq_map_data
*mdata
= &SRpnt
->stp
->buffer
->map_data
;
485 int write
= (data_direction
== DMA_TO_DEVICE
);
487 req
= blk_get_request(SRpnt
->stp
->device
->request_queue
, write
,
490 return DRIVER_ERROR
<< 24;
492 req
->cmd_type
= REQ_TYPE_BLOCK_PC
;
493 req
->cmd_flags
|= REQ_QUIET
;
495 mdata
->null_mapped
= 1;
498 err
= blk_rq_map_user(req
->q
, req
, mdata
, NULL
, bufflen
,
501 blk_put_request(req
);
502 return DRIVER_ERROR
<< 24;
506 SRpnt
->bio
= req
->bio
;
507 req
->cmd_len
= COMMAND_SIZE(cmd
[0]);
508 memset(req
->cmd
, 0, BLK_MAX_CDB
);
509 memcpy(req
->cmd
, cmd
, req
->cmd_len
);
510 req
->sense
= SRpnt
->sense
;
512 req
->timeout
= timeout
;
513 req
->retries
= retries
;
514 req
->end_io_data
= SRpnt
;
516 blk_execute_rq_nowait(req
->q
, NULL
, req
, 1, st_scsi_execute_end
);
520 /* Do the scsi command. Waits until command performed if do_wait is true.
521 Otherwise write_behind_check() is used to check that the command
523 static struct st_request
*
524 st_do_scsi(struct st_request
* SRpnt
, struct scsi_tape
* STp
, unsigned char *cmd
,
525 int bytes
, int direction
, int timeout
, int retries
, int do_wait
)
527 struct completion
*waiting
;
528 struct rq_map_data
*mdata
= &STp
->buffer
->map_data
;
531 /* if async, make sure there's no command outstanding */
532 if (!do_wait
&& ((STp
->buffer
)->last_SRpnt
)) {
533 printk(KERN_ERR
"%s: Async command already active.\n",
535 if (signal_pending(current
))
536 (STp
->buffer
)->syscall_result
= (-EINTR
);
538 (STp
->buffer
)->syscall_result
= (-EBUSY
);
543 SRpnt
= st_allocate_request(STp
);
548 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
549 which IO is outstanding. It's nulled out when the IO completes. */
551 (STp
->buffer
)->last_SRpnt
= SRpnt
;
553 waiting
= &STp
->wait
;
554 init_completion(waiting
);
555 SRpnt
->waiting
= waiting
;
557 if (STp
->buffer
->do_dio
) {
558 mdata
->page_order
= 0;
559 mdata
->nr_entries
= STp
->buffer
->sg_segs
;
560 mdata
->pages
= STp
->buffer
->mapped_pages
;
562 mdata
->page_order
= STp
->buffer
->reserved_page_order
;
564 DIV_ROUND_UP(bytes
, PAGE_SIZE
<< mdata
->page_order
);
565 mdata
->pages
= STp
->buffer
->reserved_pages
;
569 memcpy(SRpnt
->cmd
, cmd
, sizeof(SRpnt
->cmd
));
570 STp
->buffer
->cmdstat
.have_sense
= 0;
571 STp
->buffer
->syscall_result
= 0;
573 ret
= st_scsi_execute(SRpnt
, cmd
, direction
, NULL
, bytes
, timeout
,
576 /* could not allocate the buffer or request was too large */
577 (STp
->buffer
)->syscall_result
= (-EBUSY
);
578 (STp
->buffer
)->last_SRpnt
= NULL
;
579 } else if (do_wait
) {
580 wait_for_completion(waiting
);
581 SRpnt
->waiting
= NULL
;
582 (STp
->buffer
)->syscall_result
= st_chk_result(STp
, SRpnt
);
589 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
590 write has been correct but EOM early warning reached, -EIO if write ended in
591 error or zero if write successful. Asynchronous writes are used only in
592 variable block mode. */
593 static int write_behind_check(struct scsi_tape
* STp
)
596 struct st_buffer
*STbuffer
;
597 struct st_partstat
*STps
;
598 struct st_cmdstatus
*cmdstatp
;
599 struct st_request
*SRpnt
;
601 STbuffer
= STp
->buffer
;
602 if (!STbuffer
->writing
)
606 if (STp
->write_pending
)
612 wait_for_completion(&(STp
->wait
));
613 SRpnt
= STbuffer
->last_SRpnt
;
614 STbuffer
->last_SRpnt
= NULL
;
615 SRpnt
->waiting
= NULL
;
617 (STp
->buffer
)->syscall_result
= st_chk_result(STp
, SRpnt
);
618 st_release_request(SRpnt
);
620 STbuffer
->buffer_bytes
-= STbuffer
->writing
;
621 STps
= &(STp
->ps
[STp
->partition
]);
622 if (STps
->drv_block
>= 0) {
623 if (STp
->block_size
== 0)
626 STps
->drv_block
+= STbuffer
->writing
/ STp
->block_size
;
629 cmdstatp
= &STbuffer
->cmdstat
;
630 if (STbuffer
->syscall_result
) {
632 if (cmdstatp
->have_sense
&& !cmdstatp
->deferred
&&
633 (cmdstatp
->flags
& SENSE_EOM
) &&
634 (cmdstatp
->sense_hdr
.sense_key
== NO_SENSE
||
635 cmdstatp
->sense_hdr
.sense_key
== RECOVERED_ERROR
)) {
636 /* EOM at write-behind, has all data been written? */
637 if (!cmdstatp
->remainder_valid
||
638 cmdstatp
->uremainder64
== 0)
642 STps
->drv_block
= -1;
644 STbuffer
->writing
= 0;
646 DEB(if (debugging
&& retval
)
647 printk(ST_DEB_MSG
"%s: Async write error %x, return value %d.\n",
648 tape_name(STp
), STbuffer
->cmdstat
.midlevel_result
, retval
);) /* end DEB */
654 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
655 it messes up the block number). */
656 static int cross_eof(struct scsi_tape
* STp
, int forward
)
658 struct st_request
*SRpnt
;
659 unsigned char cmd
[MAX_COMMAND_SIZE
];
662 cmd
[1] = 0x01; /* Space FileMarks */
667 cmd
[2] = cmd
[3] = cmd
[4] = 0xff; /* -1 filemarks */
670 DEBC(printk(ST_DEB_MSG
"%s: Stepping over filemark %s.\n",
671 tape_name(STp
), forward
? "forward" : "backward"));
673 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, 0, DMA_NONE
,
674 STp
->device
->request_queue
->rq_timeout
,
677 return (STp
->buffer
)->syscall_result
;
679 st_release_request(SRpnt
);
682 if ((STp
->buffer
)->cmdstat
.midlevel_result
!= 0)
683 printk(KERN_ERR
"%s: Stepping over filemark %s failed.\n",
684 tape_name(STp
), forward
? "forward" : "backward");
686 return (STp
->buffer
)->syscall_result
;
690 /* Flush the write buffer (never need to write if variable blocksize). */
691 static int st_flush_write_buffer(struct scsi_tape
* STp
)
695 unsigned char cmd
[MAX_COMMAND_SIZE
];
696 struct st_request
*SRpnt
;
697 struct st_partstat
*STps
;
699 result
= write_behind_check(STp
);
704 if (STp
->dirty
== 1) {
706 transfer
= STp
->buffer
->buffer_bytes
;
707 DEBC(printk(ST_DEB_MSG
"%s: Flushing %d bytes.\n",
708 tape_name(STp
), transfer
));
710 memset(cmd
, 0, MAX_COMMAND_SIZE
);
713 blks
= transfer
/ STp
->block_size
;
718 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, transfer
, DMA_TO_DEVICE
,
719 STp
->device
->request_queue
->rq_timeout
,
720 MAX_WRITE_RETRIES
, 1);
722 return (STp
->buffer
)->syscall_result
;
724 STps
= &(STp
->ps
[STp
->partition
]);
725 if ((STp
->buffer
)->syscall_result
!= 0) {
726 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
728 if (cmdstatp
->have_sense
&& !cmdstatp
->deferred
&&
729 (cmdstatp
->flags
& SENSE_EOM
) &&
730 (cmdstatp
->sense_hdr
.sense_key
== NO_SENSE
||
731 cmdstatp
->sense_hdr
.sense_key
== RECOVERED_ERROR
) &&
732 (!cmdstatp
->remainder_valid
||
733 cmdstatp
->uremainder64
== 0)) { /* All written at EOM early warning */
735 (STp
->buffer
)->buffer_bytes
= 0;
736 if (STps
->drv_block
>= 0)
737 STps
->drv_block
+= blks
;
740 printk(KERN_ERR
"%s: Error on flush.\n",
742 STps
->drv_block
= (-1);
746 if (STps
->drv_block
>= 0)
747 STps
->drv_block
+= blks
;
749 (STp
->buffer
)->buffer_bytes
= 0;
751 st_release_request(SRpnt
);
758 /* Flush the tape buffer. The tape will be positioned correctly unless
759 seek_next is true. */
760 static int flush_buffer(struct scsi_tape
*STp
, int seek_next
)
762 int backspace
, result
;
763 struct st_buffer
*STbuffer
;
764 struct st_partstat
*STps
;
766 STbuffer
= STp
->buffer
;
769 * If there was a bus reset, block further access
772 if (STp
->pos_unknown
)
775 if (STp
->ready
!= ST_READY
)
777 STps
= &(STp
->ps
[STp
->partition
]);
778 if (STps
->rw
== ST_WRITING
) /* Writing */
779 return st_flush_write_buffer(STp
);
781 if (STp
->block_size
== 0)
784 backspace
= ((STp
->buffer
)->buffer_bytes
+
785 (STp
->buffer
)->read_pointer
) / STp
->block_size
-
786 ((STp
->buffer
)->read_pointer
+ STp
->block_size
- 1) /
788 (STp
->buffer
)->buffer_bytes
= 0;
789 (STp
->buffer
)->read_pointer
= 0;
792 if (STps
->eof
== ST_FM_HIT
) {
793 result
= cross_eof(STp
, 0); /* Back over the EOF hit */
795 STps
->eof
= ST_NOEOF
;
797 if (STps
->drv_file
>= 0)
802 if (!result
&& backspace
> 0)
803 result
= st_int_ioctl(STp
, MTBSR
, backspace
);
804 } else if (STps
->eof
== ST_FM_HIT
) {
805 if (STps
->drv_file
>= 0)
808 STps
->eof
= ST_NOEOF
;
814 /* Set the mode parameters */
815 static int set_mode_densblk(struct scsi_tape
* STp
, struct st_modedef
* STm
)
819 char *name
= tape_name(STp
);
821 if (!STp
->density_changed
&&
822 STm
->default_density
>= 0 &&
823 STm
->default_density
!= STp
->density
) {
824 arg
= STm
->default_density
;
828 arg
<<= MT_ST_DENSITY_SHIFT
;
829 if (!STp
->blksize_changed
&&
830 STm
->default_blksize
>= 0 &&
831 STm
->default_blksize
!= STp
->block_size
) {
832 arg
|= STm
->default_blksize
;
835 arg
|= STp
->block_size
;
837 st_int_ioctl(STp
, SET_DENS_AND_BLK
, arg
)) {
839 "%s: Can't set default block size to %d bytes and density %x.\n",
840 name
, STm
->default_blksize
, STm
->default_density
);
848 /* Lock or unlock the drive door. Don't use when st_request allocated. */
849 static int do_door_lock(struct scsi_tape
* STp
, int do_lock
)
852 DEB(char *name
= tape_name(STp
);)
855 cmd
= do_lock
? SCSI_IOCTL_DOORLOCK
: SCSI_IOCTL_DOORUNLOCK
;
856 DEBC(printk(ST_DEB_MSG
"%s: %socking drive door.\n", name
,
857 do_lock
? "L" : "Unl"));
858 retval
= scsi_ioctl(STp
->device
, cmd
, NULL
);
860 STp
->door_locked
= do_lock
? ST_LOCKED_EXPLICIT
: ST_UNLOCKED
;
863 STp
->door_locked
= ST_LOCK_FAILS
;
869 /* Set the internal state after reset */
870 static void reset_state(struct scsi_tape
*STp
)
873 struct st_partstat
*STps
;
875 STp
->pos_unknown
= 0;
876 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
877 STps
= &(STp
->ps
[i
]);
879 STps
->eof
= ST_NOEOF
;
881 STps
->last_block_valid
= 0;
882 STps
->drv_block
= -1;
885 if (STp
->can_partitions
) {
886 STp
->partition
= find_partition(STp
);
887 if (STp
->partition
< 0)
889 STp
->new_partition
= STp
->partition
;
893 /* Test if the drive is ready. Returns either one of the codes below or a negative system
895 #define CHKRES_READY 0
896 #define CHKRES_NEW_SESSION 1
897 #define CHKRES_NOT_READY 2
898 #define CHKRES_NO_TAPE 3
900 #define MAX_ATTENTIONS 10
902 static int test_ready(struct scsi_tape
*STp
, int do_wait
)
904 int attentions
, waits
, max_wait
, scode
;
905 int retval
= CHKRES_READY
, new_session
= 0;
906 unsigned char cmd
[MAX_COMMAND_SIZE
];
907 struct st_request
*SRpnt
= NULL
;
908 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
910 max_wait
= do_wait
? ST_BLOCK_SECONDS
: 0;
912 for (attentions
=waits
=0; ; ) {
913 memset((void *) &cmd
[0], 0, MAX_COMMAND_SIZE
);
914 cmd
[0] = TEST_UNIT_READY
;
915 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, 0, DMA_NONE
,
916 STp
->long_timeout
, MAX_READY_RETRIES
, 1);
919 retval
= (STp
->buffer
)->syscall_result
;
923 if (cmdstatp
->have_sense
) {
925 scode
= cmdstatp
->sense_hdr
.sense_key
;
927 if (scode
== UNIT_ATTENTION
) { /* New media? */
929 if (attentions
< MAX_ATTENTIONS
) {
939 if (scode
== NOT_READY
) {
940 if (waits
< max_wait
) {
941 if (msleep_interruptible(1000)) {
949 if ((STp
->device
)->scsi_level
>= SCSI_2
&&
950 cmdstatp
->sense_hdr
.asc
== 0x3a) /* Check ASC */
951 retval
= CHKRES_NO_TAPE
;
953 retval
= CHKRES_NOT_READY
;
959 retval
= (STp
->buffer
)->syscall_result
;
961 retval
= new_session
? CHKRES_NEW_SESSION
: CHKRES_READY
;
966 st_release_request(SRpnt
);
971 /* See if the drive is ready and gather information about the tape. Return values:
972 < 0 negative error code from errno.h
974 1 drive not ready (possibly no tape)
976 static int check_tape(struct scsi_tape
*STp
, struct file
*filp
)
978 int i
, retval
, new_session
= 0, do_wait
;
979 unsigned char cmd
[MAX_COMMAND_SIZE
], saved_cleaning
;
980 unsigned short st_flags
= filp
->f_flags
;
981 struct st_request
*SRpnt
= NULL
;
982 struct st_modedef
*STm
;
983 struct st_partstat
*STps
;
984 char *name
= tape_name(STp
);
985 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
986 int mode
= TAPE_MODE(inode
);
988 STp
->ready
= ST_READY
;
990 if (mode
!= STp
->current_mode
) {
991 DEBC(printk(ST_DEB_MSG
"%s: Mode change from %d to %d.\n",
992 name
, STp
->current_mode
, mode
));
994 STp
->current_mode
= mode
;
996 STm
= &(STp
->modes
[STp
->current_mode
]);
998 saved_cleaning
= STp
->cleaning_req
;
999 STp
->cleaning_req
= 0;
1001 do_wait
= ((filp
->f_flags
& O_NONBLOCK
) == 0);
1002 retval
= test_ready(STp
, do_wait
);
1007 if (retval
== CHKRES_NEW_SESSION
) {
1008 STp
->pos_unknown
= 0;
1009 STp
->partition
= STp
->new_partition
= 0;
1010 if (STp
->can_partitions
)
1011 STp
->nbr_partitions
= 1; /* This guess will be updated later
1013 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
1014 STps
= &(STp
->ps
[i
]);
1016 STps
->eof
= ST_NOEOF
;
1018 STps
->last_block_valid
= 0;
1019 STps
->drv_block
= 0;
1025 STp
->cleaning_req
|= saved_cleaning
;
1027 if (retval
== CHKRES_NOT_READY
|| retval
== CHKRES_NO_TAPE
) {
1028 if (retval
== CHKRES_NO_TAPE
)
1029 STp
->ready
= ST_NO_TAPE
;
1031 STp
->ready
= ST_NOT_READY
;
1033 STp
->density
= 0; /* Clear the erroneous "residue" */
1034 STp
->write_prot
= 0;
1035 STp
->block_size
= 0;
1036 STp
->ps
[0].drv_file
= STp
->ps
[0].drv_block
= (-1);
1037 STp
->partition
= STp
->new_partition
= 0;
1038 STp
->door_locked
= ST_UNLOCKED
;
1039 return CHKRES_NOT_READY
;
1043 if (STp
->omit_blklims
)
1044 STp
->min_block
= STp
->max_block
= (-1);
1046 memset((void *) &cmd
[0], 0, MAX_COMMAND_SIZE
);
1047 cmd
[0] = READ_BLOCK_LIMITS
;
1049 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, 6, DMA_FROM_DEVICE
,
1050 STp
->device
->request_queue
->rq_timeout
,
1051 MAX_READY_RETRIES
, 1);
1053 retval
= (STp
->buffer
)->syscall_result
;
1057 if (!SRpnt
->result
&& !STp
->buffer
->cmdstat
.have_sense
) {
1058 STp
->max_block
= ((STp
->buffer
)->b_data
[1] << 16) |
1059 ((STp
->buffer
)->b_data
[2] << 8) | (STp
->buffer
)->b_data
[3];
1060 STp
->min_block
= ((STp
->buffer
)->b_data
[4] << 8) |
1061 (STp
->buffer
)->b_data
[5];
1062 if ( DEB( debugging
|| ) !STp
->inited
)
1064 "%s: Block limits %d - %d bytes.\n", name
,
1065 STp
->min_block
, STp
->max_block
);
1067 STp
->min_block
= STp
->max_block
= (-1);
1068 DEBC(printk(ST_DEB_MSG
"%s: Can't read block limits.\n",
1073 memset((void *) &cmd
[0], 0, MAX_COMMAND_SIZE
);
1074 cmd
[0] = MODE_SENSE
;
1077 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, 12, DMA_FROM_DEVICE
,
1078 STp
->device
->request_queue
->rq_timeout
,
1079 MAX_READY_RETRIES
, 1);
1081 retval
= (STp
->buffer
)->syscall_result
;
1085 if ((STp
->buffer
)->syscall_result
!= 0) {
1086 DEBC(printk(ST_DEB_MSG
"%s: No Mode Sense.\n", name
));
1087 STp
->block_size
= ST_DEFAULT_BLOCK
; /* Educated guess (?) */
1088 (STp
->buffer
)->syscall_result
= 0; /* Prevent error propagation */
1089 STp
->drv_write_prot
= 0;
1091 DEBC(printk(ST_DEB_MSG
1092 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1094 (STp
->buffer
)->b_data
[0], (STp
->buffer
)->b_data
[1],
1095 (STp
->buffer
)->b_data
[2], (STp
->buffer
)->b_data
[3]));
1097 if ((STp
->buffer
)->b_data
[3] >= 8) {
1098 STp
->drv_buffer
= ((STp
->buffer
)->b_data
[2] >> 4) & 7;
1099 STp
->density
= (STp
->buffer
)->b_data
[4];
1100 STp
->block_size
= (STp
->buffer
)->b_data
[9] * 65536 +
1101 (STp
->buffer
)->b_data
[10] * 256 + (STp
->buffer
)->b_data
[11];
1102 DEBC(printk(ST_DEB_MSG
1103 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1104 name
, STp
->density
, (STp
->buffer
)->b_data
[5] * 65536 +
1105 (STp
->buffer
)->b_data
[6] * 256 + (STp
->buffer
)->b_data
[7],
1108 STp
->drv_write_prot
= ((STp
->buffer
)->b_data
[2] & 0x80) != 0;
1110 st_release_request(SRpnt
);
1114 if (STp
->block_size
> 0)
1115 (STp
->buffer
)->buffer_blocks
=
1116 (STp
->buffer
)->buffer_size
/ STp
->block_size
;
1118 (STp
->buffer
)->buffer_blocks
= 1;
1119 (STp
->buffer
)->buffer_bytes
= (STp
->buffer
)->read_pointer
= 0;
1121 DEBC(printk(ST_DEB_MSG
1122 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name
,
1123 STp
->block_size
, (STp
->buffer
)->buffer_size
,
1124 (STp
->buffer
)->buffer_blocks
));
1126 if (STp
->drv_write_prot
) {
1127 STp
->write_prot
= 1;
1129 DEBC(printk(ST_DEB_MSG
"%s: Write protected\n", name
));
1132 ((st_flags
& O_ACCMODE
) == O_WRONLY
||
1133 (st_flags
& O_ACCMODE
) == O_RDWR
)) {
1139 if (STp
->can_partitions
&& STp
->nbr_partitions
< 1) {
1140 /* This code is reached when the device is opened for the first time
1141 after the driver has been initialized with tape in the drive and the
1142 partition support has been enabled. */
1143 DEBC(printk(ST_DEB_MSG
1144 "%s: Updating partition number in status.\n", name
));
1145 if ((STp
->partition
= find_partition(STp
)) < 0) {
1146 retval
= STp
->partition
;
1149 STp
->new_partition
= STp
->partition
;
1150 STp
->nbr_partitions
= 1; /* This guess will be updated when necessary */
1153 if (new_session
) { /* Change the drive parameters for the new mode */
1154 STp
->density_changed
= STp
->blksize_changed
= 0;
1155 STp
->compression_changed
= 0;
1156 if (!(STm
->defaults_for_writes
) &&
1157 (retval
= set_mode_densblk(STp
, STm
)) < 0)
1160 if (STp
->default_drvbuffer
!= 0xff) {
1161 if (st_int_ioctl(STp
, MTSETDRVBUFFER
, STp
->default_drvbuffer
))
1163 "%s: Can't set default drive buffering to %d.\n",
1164 name
, STp
->default_drvbuffer
);
1168 return CHKRES_READY
;
1175 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1177 static int st_open(struct inode
*inode
, struct file
*filp
)
1179 int i
, retval
= (-EIO
);
1181 struct scsi_tape
*STp
;
1182 struct st_partstat
*STps
;
1183 int dev
= TAPE_NR(inode
);
1186 mutex_lock(&st_mutex
);
1188 * We really want to do nonseekable_open(inode, filp); here, but some
1189 * versions of tar incorrectly call lseek on tapes and bail out if that
1190 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1192 filp
->f_mode
&= ~(FMODE_PREAD
| FMODE_PWRITE
);
1194 if (!(STp
= scsi_tape_get(dev
))) {
1195 mutex_unlock(&st_mutex
);
1199 write_lock(&st_dev_arr_lock
);
1200 filp
->private_data
= STp
;
1201 name
= tape_name(STp
);
1204 write_unlock(&st_dev_arr_lock
);
1206 mutex_unlock(&st_mutex
);
1207 DEB( printk(ST_DEB_MSG
"%s: Device already in use.\n", name
); )
1212 write_unlock(&st_dev_arr_lock
);
1213 STp
->rew_at_close
= STp
->autorew_dev
= (iminor(inode
) & 0x80) == 0;
1215 if (scsi_autopm_get_device(STp
->device
) < 0) {
1220 if (!scsi_block_when_processing_errors(STp
->device
)) {
1225 /* See that we have at least a one page buffer available */
1226 if (!enlarge_buffer(STp
->buffer
, PAGE_SIZE
, STp
->restr_dma
)) {
1227 printk(KERN_WARNING
"%s: Can't allocate one page tape buffer.\n",
1229 retval
= (-EOVERFLOW
);
1233 (STp
->buffer
)->cleared
= 0;
1234 (STp
->buffer
)->writing
= 0;
1235 (STp
->buffer
)->syscall_result
= 0;
1237 STp
->write_prot
= ((filp
->f_flags
& O_ACCMODE
) == O_RDONLY
);
1240 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
1241 STps
= &(STp
->ps
[i
]);
1244 STp
->try_dio_now
= STp
->try_dio
;
1245 STp
->recover_count
= 0;
1246 DEB( STp
->nbr_waits
= STp
->nbr_finished
= 0;
1247 STp
->nbr_requests
= STp
->nbr_dio
= STp
->nbr_pages
= 0; )
1249 retval
= check_tape(STp
, filp
);
1252 if ((filp
->f_flags
& O_NONBLOCK
) == 0 &&
1253 retval
!= CHKRES_READY
) {
1254 if (STp
->ready
== NO_TAPE
)
1255 retval
= (-ENOMEDIUM
);
1260 mutex_unlock(&st_mutex
);
1264 normalize_buffer(STp
->buffer
);
1268 scsi_autopm_put_device(STp
->device
);
1269 mutex_unlock(&st_mutex
);
1275 /* Flush the tape buffer before close */
1276 static int st_flush(struct file
*filp
, fl_owner_t id
)
1278 int result
= 0, result2
;
1279 unsigned char cmd
[MAX_COMMAND_SIZE
];
1280 struct st_request
*SRpnt
;
1281 struct scsi_tape
*STp
= filp
->private_data
;
1282 struct st_modedef
*STm
= &(STp
->modes
[STp
->current_mode
]);
1283 struct st_partstat
*STps
= &(STp
->ps
[STp
->partition
]);
1284 char *name
= tape_name(STp
);
1286 if (file_count(filp
) > 1)
1289 if (STps
->rw
== ST_WRITING
&& !STp
->pos_unknown
) {
1290 result
= st_flush_write_buffer(STp
);
1291 if (result
!= 0 && result
!= (-ENOSPC
))
1295 if (STp
->can_partitions
&&
1296 (result2
= switch_partition(STp
)) < 0) {
1297 DEBC(printk(ST_DEB_MSG
1298 "%s: switch_partition at close failed.\n", name
));
1304 DEBC( if (STp
->nbr_requests
)
1305 printk(KERN_DEBUG
"%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1306 name
, STp
->nbr_requests
, STp
->nbr_dio
, STp
->nbr_pages
));
1308 if (STps
->rw
== ST_WRITING
&& !STp
->pos_unknown
) {
1309 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
1311 DEBC(printk(ST_DEB_MSG
"%s: Async write waits %d, finished %d.\n",
1312 name
, STp
->nbr_waits
, STp
->nbr_finished
);
1315 memset(cmd
, 0, MAX_COMMAND_SIZE
);
1316 cmd
[0] = WRITE_FILEMARKS
;
1317 cmd
[4] = 1 + STp
->two_fm
;
1319 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, 0, DMA_NONE
,
1320 STp
->device
->request_queue
->rq_timeout
,
1321 MAX_WRITE_RETRIES
, 1);
1323 result
= (STp
->buffer
)->syscall_result
;
1327 if (STp
->buffer
->syscall_result
== 0 ||
1328 (cmdstatp
->have_sense
&& !cmdstatp
->deferred
&&
1329 (cmdstatp
->flags
& SENSE_EOM
) &&
1330 (cmdstatp
->sense_hdr
.sense_key
== NO_SENSE
||
1331 cmdstatp
->sense_hdr
.sense_key
== RECOVERED_ERROR
) &&
1332 (!cmdstatp
->remainder_valid
|| cmdstatp
->uremainder64
== 0))) {
1333 /* Write successful at EOM */
1334 st_release_request(SRpnt
);
1336 if (STps
->drv_file
>= 0)
1338 STps
->drv_block
= 0;
1343 else { /* Write error */
1344 st_release_request(SRpnt
);
1346 printk(KERN_ERR
"%s: Error on write filemark.\n", name
);
1351 DEBC(printk(ST_DEB_MSG
"%s: Buffer flushed, %d EOF(s) written\n",
1353 } else if (!STp
->rew_at_close
) {
1354 STps
= &(STp
->ps
[STp
->partition
]);
1355 if (!STm
->sysv
|| STps
->rw
!= ST_READING
) {
1357 result
= flush_buffer(STp
, 0);
1358 else if (STps
->eof
== ST_FM_HIT
) {
1359 result
= cross_eof(STp
, 0);
1361 if (STps
->drv_file
>= 0)
1363 STps
->drv_block
= 0;
1366 STps
->eof
= ST_NOEOF
;
1368 } else if ((STps
->eof
== ST_NOEOF
&&
1369 !(result
= cross_eof(STp
, 1))) ||
1370 STps
->eof
== ST_FM_HIT
) {
1371 if (STps
->drv_file
>= 0)
1373 STps
->drv_block
= 0;
1379 if (STp
->rew_at_close
) {
1380 result2
= st_int_ioctl(STp
, MTREW
, 1);
1388 /* Close the device and release it. BKL is not needed: this is the only thread
1389 accessing this tape. */
1390 static int st_release(struct inode
*inode
, struct file
*filp
)
1393 struct scsi_tape
*STp
= filp
->private_data
;
1395 if (STp
->door_locked
== ST_LOCKED_AUTO
)
1396 do_door_lock(STp
, 0);
1398 normalize_buffer(STp
->buffer
);
1399 write_lock(&st_dev_arr_lock
);
1401 write_unlock(&st_dev_arr_lock
);
1402 scsi_autopm_put_device(STp
->device
);
1408 /* The checks common to both reading and writing */
1409 static ssize_t
rw_checks(struct scsi_tape
*STp
, struct file
*filp
, size_t count
)
1414 * If we are in the middle of error recovery, don't let anyone
1415 * else try and use this device. Also, if error recovery fails, it
1416 * may try and take the device offline, in which case all further
1417 * access to the device is prohibited.
1419 if (!scsi_block_when_processing_errors(STp
->device
)) {
1424 if (STp
->ready
!= ST_READY
) {
1425 if (STp
->ready
== ST_NO_TAPE
)
1426 retval
= (-ENOMEDIUM
);
1432 if (! STp
->modes
[STp
->current_mode
].defined
) {
1439 * If there was a bus reset, block further access
1442 if (STp
->pos_unknown
) {
1452 printk(ST_DEB_MSG
"%s: Incorrect device.\n", tape_name(STp
));
1457 if (STp
->can_partitions
&&
1458 (retval
= switch_partition(STp
)) < 0)
1461 if (STp
->block_size
== 0 && STp
->max_block
> 0 &&
1462 (count
< STp
->min_block
|| count
> STp
->max_block
)) {
1467 if (STp
->do_auto_lock
&& STp
->door_locked
== ST_UNLOCKED
&&
1468 !do_door_lock(STp
, 1))
1469 STp
->door_locked
= ST_LOCKED_AUTO
;
1476 static int setup_buffering(struct scsi_tape
*STp
, const char __user
*buf
,
1477 size_t count
, int is_read
)
1479 int i
, bufsize
, retval
= 0;
1480 struct st_buffer
*STbp
= STp
->buffer
;
1483 i
= STp
->try_dio_now
&& try_rdio
;
1485 i
= STp
->try_dio_now
&& try_wdio
;
1487 if (i
&& ((unsigned long)buf
& queue_dma_alignment(
1488 STp
->device
->request_queue
)) == 0) {
1489 i
= sgl_map_user_pages(STbp
, STbp
->use_sg
, (unsigned long)buf
,
1490 count
, (is_read
? READ
: WRITE
));
1493 STbp
->buffer_bytes
= 0; /* can be used as transfer counter */
1496 STbp
->do_dio
= 0; /* fall back to buffering with any error */
1497 STbp
->sg_segs
= STbp
->do_dio
;
1501 STp
->nbr_pages
+= STbp
->do_dio
;
1506 DEB( STp
->nbr_requests
++; )
1508 if (!STbp
->do_dio
) {
1509 if (STp
->block_size
)
1510 bufsize
= STp
->block_size
> st_fixed_buffer_size
?
1511 STp
->block_size
: st_fixed_buffer_size
;
1514 /* Make sure that data from previous user is not leaked even if
1515 HBA does not return correct residual */
1516 if (is_read
&& STp
->sili
&& !STbp
->cleared
)
1520 if (bufsize
> STbp
->buffer_size
&&
1521 !enlarge_buffer(STbp
, bufsize
, STp
->restr_dma
)) {
1522 printk(KERN_WARNING
"%s: Can't allocate %d byte tape buffer.\n",
1523 tape_name(STp
), bufsize
);
1524 retval
= (-EOVERFLOW
);
1527 if (STp
->block_size
)
1528 STbp
->buffer_blocks
= bufsize
/ STp
->block_size
;
1536 /* Can be called more than once after each setup_buffer() */
1537 static void release_buffering(struct scsi_tape
*STp
, int is_read
)
1539 struct st_buffer
*STbp
;
1543 sgl_unmap_user_pages(STbp
, STbp
->do_dio
, is_read
);
1552 st_write(struct file
*filp
, const char __user
*buf
, size_t count
, loff_t
* ppos
)
1555 ssize_t i
, do_count
, blks
, transfer
;
1557 int undone
, retry_eot
= 0, scode
;
1559 unsigned char cmd
[MAX_COMMAND_SIZE
];
1560 const char __user
*b_point
;
1561 struct st_request
*SRpnt
= NULL
;
1562 struct scsi_tape
*STp
= filp
->private_data
;
1563 struct st_modedef
*STm
;
1564 struct st_partstat
*STps
;
1565 struct st_buffer
*STbp
;
1566 char *name
= tape_name(STp
);
1568 if (mutex_lock_interruptible(&STp
->lock
))
1569 return -ERESTARTSYS
;
1571 retval
= rw_checks(STp
, filp
, count
);
1572 if (retval
|| count
== 0)
1575 /* Write must be integral number of blocks */
1576 if (STp
->block_size
!= 0 && (count
% STp
->block_size
) != 0) {
1577 printk(KERN_WARNING
"%s: Write not multiple of tape block size.\n",
1583 STm
= &(STp
->modes
[STp
->current_mode
]);
1584 STps
= &(STp
->ps
[STp
->partition
]);
1586 if (STp
->write_prot
) {
1592 if (STps
->rw
== ST_READING
) {
1593 retval
= flush_buffer(STp
, 0);
1596 STps
->rw
= ST_WRITING
;
1597 } else if (STps
->rw
!= ST_WRITING
&&
1598 STps
->drv_file
== 0 && STps
->drv_block
== 0) {
1599 if ((retval
= set_mode_densblk(STp
, STm
)) < 0)
1601 if (STm
->default_compression
!= ST_DONT_TOUCH
&&
1602 !(STp
->compression_changed
)) {
1603 if (st_compression(STp
, (STm
->default_compression
== ST_YES
))) {
1604 printk(KERN_WARNING
"%s: Can't set default compression.\n",
1606 if (modes_defined
) {
1615 i
= write_behind_check(STp
);
1618 STps
->eof
= ST_EOM_OK
;
1620 STps
->eof
= ST_EOM_ERROR
;
1623 if (STps
->eof
== ST_EOM_OK
) {
1624 STps
->eof
= ST_EOD_1
; /* allow next write */
1628 else if (STps
->eof
== ST_EOM_ERROR
) {
1633 /* Check the buffer readability in cases where copy_user might catch
1634 the problems after some tape movement. */
1635 if (STp
->block_size
!= 0 &&
1637 (copy_from_user(&i
, buf
, 1) != 0 ||
1638 copy_from_user(&i
, buf
+ count
- 1, 1) != 0)) {
1643 retval
= setup_buffering(STp
, buf
, count
, 0);
1649 memset(cmd
, 0, MAX_COMMAND_SIZE
);
1651 cmd
[1] = (STp
->block_size
!= 0);
1653 STps
->rw
= ST_WRITING
;
1656 while (count
> 0 && !retry_eot
) {
1662 if (STp
->block_size
== 0)
1665 do_count
= STbp
->buffer_blocks
* STp
->block_size
-
1667 if (do_count
> count
)
1671 i
= append_to_buffer(b_point
, STbp
, do_count
);
1678 b_point
+= do_count
;
1680 async_write
= STp
->block_size
== 0 && !STbp
->do_dio
&&
1681 STm
->do_async_writes
&& STps
->eof
< ST_EOM_OK
;
1683 if (STp
->block_size
!= 0 && STm
->do_buffer_writes
&&
1684 !(STp
->try_dio_now
&& try_wdio
) && STps
->eof
< ST_EOM_OK
&&
1685 STbp
->buffer_bytes
< STbp
->buffer_size
) {
1687 /* Don't write a buffer that is not full enough. */
1688 if (!async_write
&& count
== 0)
1693 if (STp
->block_size
== 0)
1694 blks
= transfer
= do_count
;
1697 blks
= STbp
->buffer_bytes
;
1700 blks
/= STp
->block_size
;
1701 transfer
= blks
* STp
->block_size
;
1703 cmd
[2] = blks
>> 16;
1707 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, transfer
, DMA_TO_DEVICE
,
1708 STp
->device
->request_queue
->rq_timeout
,
1709 MAX_WRITE_RETRIES
, !async_write
);
1711 retval
= STbp
->syscall_result
;
1714 if (async_write
&& !STbp
->syscall_result
) {
1715 STbp
->writing
= transfer
;
1716 STp
->dirty
= !(STbp
->writing
==
1717 STbp
->buffer_bytes
);
1718 SRpnt
= NULL
; /* Prevent releasing this request! */
1719 DEB( STp
->write_pending
= 1; )
1723 if (STbp
->syscall_result
!= 0) {
1724 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
1726 DEBC(printk(ST_DEB_MSG
"%s: Error on write:\n", name
));
1727 if (cmdstatp
->have_sense
&& (cmdstatp
->flags
& SENSE_EOM
)) {
1728 scode
= cmdstatp
->sense_hdr
.sense_key
;
1729 if (cmdstatp
->remainder_valid
)
1730 undone
= (int)cmdstatp
->uremainder64
;
1731 else if (STp
->block_size
== 0 &&
1732 scode
== VOLUME_OVERFLOW
)
1736 if (STp
->block_size
!= 0)
1737 undone
*= STp
->block_size
;
1738 if (undone
<= do_count
) {
1739 /* Only data from this write is not written */
1743 if (STp
->block_size
)
1744 blks
= (transfer
- undone
) / STp
->block_size
;
1745 STps
->eof
= ST_EOM_OK
;
1746 /* Continue in fixed block mode if all written
1747 in this request but still something left to write
1748 (retval left to zero)
1750 if (STp
->block_size
== 0 ||
1751 undone
> 0 || count
== 0)
1752 retval
= (-ENOSPC
); /* EOM within current request */
1753 DEBC(printk(ST_DEB_MSG
1754 "%s: EOM with %d bytes unwritten.\n",
1757 /* EOT within data buffered earlier (possible only
1758 in fixed block mode without direct i/o) */
1759 if (!retry_eot
&& !cmdstatp
->deferred
&&
1760 (scode
== NO_SENSE
|| scode
== RECOVERED_ERROR
)) {
1761 move_buffer_data(STp
->buffer
, transfer
- undone
);
1763 if (STps
->drv_block
>= 0) {
1764 STps
->drv_block
+= (transfer
- undone
) /
1767 STps
->eof
= ST_EOM_OK
;
1768 DEBC(printk(ST_DEB_MSG
1769 "%s: Retry write of %d bytes at EOM.\n",
1770 name
, STp
->buffer
->buffer_bytes
));
1774 /* Either error within data buffered by driver or
1777 blks
= do_count
= 0;
1778 STps
->eof
= ST_EOM_ERROR
;
1779 STps
->drv_block
= (-1); /* Too cautious? */
1780 retval
= (-EIO
); /* EOM for old data */
1781 DEBC(printk(ST_DEB_MSG
1782 "%s: EOM with lost data.\n",
1788 STps
->drv_block
= (-1); /* Too cautious? */
1789 retval
= STbp
->syscall_result
;
1794 if (STps
->drv_block
>= 0) {
1795 if (STp
->block_size
== 0)
1796 STps
->drv_block
+= (do_count
> 0);
1798 STps
->drv_block
+= blks
;
1801 STbp
->buffer_bytes
= 0;
1804 if (retval
|| retry_eot
) {
1806 retval
= total
- count
;
1811 if (STps
->eof
== ST_EOD_1
)
1812 STps
->eof
= ST_EOM_OK
;
1813 else if (STps
->eof
!= ST_EOM_OK
)
1814 STps
->eof
= ST_NOEOF
;
1815 retval
= total
- count
;
1819 st_release_request(SRpnt
);
1820 release_buffering(STp
, 0);
1821 mutex_unlock(&STp
->lock
);
1826 /* Read data from the tape. Returns zero in the normal case, one if the
1827 eof status has changed, and the negative error code in case of a
1828 fatal error. Otherwise updates the buffer and the eof state.
1830 Does release user buffer mapping if it is set.
1832 static long read_tape(struct scsi_tape
*STp
, long count
,
1833 struct st_request
** aSRpnt
)
1835 int transfer
, blks
, bytes
;
1836 unsigned char cmd
[MAX_COMMAND_SIZE
];
1837 struct st_request
*SRpnt
;
1838 struct st_modedef
*STm
;
1839 struct st_partstat
*STps
;
1840 struct st_buffer
*STbp
;
1842 char *name
= tape_name(STp
);
1847 STm
= &(STp
->modes
[STp
->current_mode
]);
1848 STps
= &(STp
->ps
[STp
->partition
]);
1849 if (STps
->eof
== ST_FM_HIT
)
1853 if (STp
->block_size
== 0)
1854 blks
= bytes
= count
;
1856 if (!(STp
->try_dio_now
&& try_rdio
) && STm
->do_read_ahead
) {
1857 blks
= (STp
->buffer
)->buffer_blocks
;
1858 bytes
= blks
* STp
->block_size
;
1861 if (!STbp
->do_dio
&& bytes
> (STp
->buffer
)->buffer_size
)
1862 bytes
= (STp
->buffer
)->buffer_size
;
1863 blks
= bytes
/ STp
->block_size
;
1864 bytes
= blks
* STp
->block_size
;
1868 memset(cmd
, 0, MAX_COMMAND_SIZE
);
1870 cmd
[1] = (STp
->block_size
!= 0);
1871 if (!cmd
[1] && STp
->sili
)
1873 cmd
[2] = blks
>> 16;
1878 SRpnt
= st_do_scsi(SRpnt
, STp
, cmd
, bytes
, DMA_FROM_DEVICE
,
1879 STp
->device
->request_queue
->rq_timeout
,
1881 release_buffering(STp
, 1);
1884 return STbp
->syscall_result
;
1886 STbp
->read_pointer
= 0;
1889 /* Something to check */
1890 if (STbp
->syscall_result
) {
1891 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
1894 DEBC(printk(ST_DEB_MSG
"%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1896 SRpnt
->sense
[0], SRpnt
->sense
[1],
1897 SRpnt
->sense
[2], SRpnt
->sense
[3],
1898 SRpnt
->sense
[4], SRpnt
->sense
[5],
1899 SRpnt
->sense
[6], SRpnt
->sense
[7]));
1900 if (cmdstatp
->have_sense
) {
1902 if (cmdstatp
->sense_hdr
.sense_key
== BLANK_CHECK
)
1903 cmdstatp
->flags
&= 0xcf; /* No need for EOM in this case */
1905 if (cmdstatp
->flags
!= 0) { /* EOF, EOM, or ILI */
1906 /* Compute the residual count */
1907 if (cmdstatp
->remainder_valid
)
1908 transfer
= (int)cmdstatp
->uremainder64
;
1911 if (STp
->block_size
== 0 &&
1912 cmdstatp
->sense_hdr
.sense_key
== MEDIUM_ERROR
)
1915 if (cmdstatp
->flags
& SENSE_ILI
) { /* ILI */
1916 if (STp
->block_size
== 0) {
1917 if (transfer
<= 0) {
1920 "%s: Failed to read %d byte block with %d byte transfer.\n",
1921 name
, bytes
- transfer
, bytes
);
1922 if (STps
->drv_block
>= 0)
1923 STps
->drv_block
+= 1;
1924 STbp
->buffer_bytes
= 0;
1927 STbp
->buffer_bytes
= bytes
- transfer
;
1929 st_release_request(SRpnt
);
1930 SRpnt
= *aSRpnt
= NULL
;
1931 if (transfer
== blks
) { /* We did not get anything, error */
1932 printk(KERN_NOTICE
"%s: Incorrect block size.\n", name
);
1933 if (STps
->drv_block
>= 0)
1934 STps
->drv_block
+= blks
- transfer
+ 1;
1935 st_int_ioctl(STp
, MTBSR
, 1);
1938 /* We have some data, deliver it */
1939 STbp
->buffer_bytes
= (blks
- transfer
) *
1941 DEBC(printk(ST_DEB_MSG
1942 "%s: ILI but enough data received %ld %d.\n",
1943 name
, count
, STbp
->buffer_bytes
));
1944 if (STps
->drv_block
>= 0)
1945 STps
->drv_block
+= 1;
1946 if (st_int_ioctl(STp
, MTBSR
, 1))
1949 } else if (cmdstatp
->flags
& SENSE_FMK
) { /* FM overrides EOM */
1950 if (STps
->eof
!= ST_FM_HIT
)
1951 STps
->eof
= ST_FM_HIT
;
1953 STps
->eof
= ST_EOD_2
;
1954 if (STp
->block_size
== 0)
1955 STbp
->buffer_bytes
= 0;
1957 STbp
->buffer_bytes
=
1958 bytes
- transfer
* STp
->block_size
;
1959 DEBC(printk(ST_DEB_MSG
1960 "%s: EOF detected (%d bytes read).\n",
1961 name
, STbp
->buffer_bytes
));
1962 } else if (cmdstatp
->flags
& SENSE_EOM
) {
1963 if (STps
->eof
== ST_FM
)
1964 STps
->eof
= ST_EOD_1
;
1966 STps
->eof
= ST_EOM_OK
;
1967 if (STp
->block_size
== 0)
1968 STbp
->buffer_bytes
= bytes
- transfer
;
1970 STbp
->buffer_bytes
=
1971 bytes
- transfer
* STp
->block_size
;
1973 DEBC(printk(ST_DEB_MSG
"%s: EOM detected (%d bytes read).\n",
1974 name
, STbp
->buffer_bytes
));
1977 /* end of EOF, EOM, ILI test */
1978 else { /* nonzero sense key */
1979 DEBC(printk(ST_DEB_MSG
1980 "%s: Tape error while reading.\n", name
));
1981 STps
->drv_block
= (-1);
1982 if (STps
->eof
== ST_FM
&&
1983 cmdstatp
->sense_hdr
.sense_key
== BLANK_CHECK
) {
1984 DEBC(printk(ST_DEB_MSG
1985 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1987 STps
->eof
= ST_EOD_2
; /* First BLANK_CHECK after FM */
1988 } else /* Some other extended sense code */
1992 if (STbp
->buffer_bytes
< 0) /* Caused by bogus sense data */
1993 STbp
->buffer_bytes
= 0;
1995 /* End of extended sense test */
1996 else { /* Non-extended sense */
1997 retval
= STbp
->syscall_result
;
2001 /* End of error handling */
2002 else { /* Read successful */
2003 STbp
->buffer_bytes
= bytes
;
2004 if (STp
->sili
) /* In fixed block mode residual is always zero here */
2005 STbp
->buffer_bytes
-= STp
->buffer
->cmdstat
.residual
;
2008 if (STps
->drv_block
>= 0) {
2009 if (STp
->block_size
== 0)
2012 STps
->drv_block
+= STbp
->buffer_bytes
/ STp
->block_size
;
2020 st_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
* ppos
)
2024 ssize_t i
, transfer
;
2025 int special
, do_dio
= 0;
2026 struct st_request
*SRpnt
= NULL
;
2027 struct scsi_tape
*STp
= filp
->private_data
;
2028 struct st_modedef
*STm
;
2029 struct st_partstat
*STps
;
2030 struct st_buffer
*STbp
= STp
->buffer
;
2031 DEB( char *name
= tape_name(STp
); )
2033 if (mutex_lock_interruptible(&STp
->lock
))
2034 return -ERESTARTSYS
;
2036 retval
= rw_checks(STp
, filp
, count
);
2037 if (retval
|| count
== 0)
2040 STm
= &(STp
->modes
[STp
->current_mode
]);
2041 if (STp
->block_size
!= 0 && (count
% STp
->block_size
) != 0) {
2042 if (!STm
->do_read_ahead
) {
2043 retval
= (-EINVAL
); /* Read must be integral number of blocks */
2046 STp
->try_dio_now
= 0; /* Direct i/o can't handle split blocks */
2049 STps
= &(STp
->ps
[STp
->partition
]);
2050 if (STps
->rw
== ST_WRITING
) {
2051 retval
= flush_buffer(STp
, 0);
2054 STps
->rw
= ST_READING
;
2057 if (debugging
&& STps
->eof
!= ST_NOEOF
)
2058 printk(ST_DEB_MSG
"%s: EOF/EOM flag up (%d). Bytes %d\n", name
,
2059 STps
->eof
, STbp
->buffer_bytes
);
2062 retval
= setup_buffering(STp
, buf
, count
, 1);
2065 do_dio
= STbp
->do_dio
;
2067 if (STbp
->buffer_bytes
== 0 &&
2068 STps
->eof
>= ST_EOD_1
) {
2069 if (STps
->eof
< ST_EOD
) {
2074 retval
= (-EIO
); /* EOM or Blank Check */
2079 /* Check the buffer writability before any tape movement. Don't alter
2081 if (copy_from_user(&i
, buf
, 1) != 0 ||
2082 copy_to_user(buf
, &i
, 1) != 0 ||
2083 copy_from_user(&i
, buf
+ count
- 1, 1) != 0 ||
2084 copy_to_user(buf
+ count
- 1, &i
, 1) != 0) {
2090 STps
->rw
= ST_READING
;
2093 /* Loop until enough data in buffer or a special condition found */
2094 for (total
= 0, special
= 0; total
< count
&& !special
;) {
2096 /* Get new data if the buffer is empty */
2097 if (STbp
->buffer_bytes
== 0) {
2098 special
= read_tape(STp
, count
- total
, &SRpnt
);
2099 if (special
< 0) { /* No need to continue read */
2105 /* Move the data from driver buffer to user buffer */
2106 if (STbp
->buffer_bytes
> 0) {
2108 if (debugging
&& STps
->eof
!= ST_NOEOF
)
2110 "%s: EOF up (%d). Left %d, needed %d.\n", name
,
2111 STps
->eof
, STbp
->buffer_bytes
,
2112 (int)(count
- total
));
2114 transfer
= STbp
->buffer_bytes
< count
- total
?
2115 STbp
->buffer_bytes
: count
- total
;
2117 i
= from_buffer(STbp
, buf
, transfer
);
2127 if (STp
->block_size
== 0)
2128 break; /* Read only one variable length block */
2130 } /* for (total = 0, special = 0;
2131 total < count && !special; ) */
2133 /* Change the eof state if no data from tape or buffer */
2135 if (STps
->eof
== ST_FM_HIT
) {
2137 STps
->drv_block
= 0;
2138 if (STps
->drv_file
>= 0)
2140 } else if (STps
->eof
== ST_EOD_1
) {
2141 STps
->eof
= ST_EOD_2
;
2142 STps
->drv_block
= 0;
2143 if (STps
->drv_file
>= 0)
2145 } else if (STps
->eof
== ST_EOD_2
)
2147 } else if (STps
->eof
== ST_FM
)
2148 STps
->eof
= ST_NOEOF
;
2152 if (SRpnt
!= NULL
) {
2153 st_release_request(SRpnt
);
2157 release_buffering(STp
, 1);
2158 STbp
->buffer_bytes
= 0;
2160 mutex_unlock(&STp
->lock
);
2168 /* Set the driver options */
2169 static void st_log_options(struct scsi_tape
* STp
, struct st_modedef
* STm
, char *name
)
2173 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2174 name
, STp
->current_mode
, STm
->do_buffer_writes
, STm
->do_async_writes
,
2175 STm
->do_read_ahead
);
2177 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2178 name
, STp
->can_bsr
, STp
->two_fm
, STp
->fast_mteom
, STp
->do_auto_lock
);
2180 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2181 name
, STm
->defaults_for_writes
, STp
->omit_blklims
, STp
->can_partitions
,
2182 STp
->scsi2_logical
);
2184 "%s: sysv: %d nowait: %d sili: %d\n", name
, STm
->sysv
, STp
->immediate
,
2186 printk(KERN_INFO
"%s: debugging: %d\n",
2193 static int st_set_options(struct scsi_tape
*STp
, long options
)
2197 struct st_modedef
*STm
;
2198 char *name
= tape_name(STp
);
2199 struct cdev
*cd0
, *cd1
;
2201 STm
= &(STp
->modes
[STp
->current_mode
]);
2202 if (!STm
->defined
) {
2203 cd0
= STm
->cdevs
[0]; cd1
= STm
->cdevs
[1];
2204 memcpy(STm
, &(STp
->modes
[0]), sizeof(struct st_modedef
));
2205 STm
->cdevs
[0] = cd0
; STm
->cdevs
[1] = cd1
;
2207 DEBC(printk(ST_DEB_MSG
2208 "%s: Initialized mode %d definition from mode 0\n",
2209 name
, STp
->current_mode
));
2212 code
= options
& MT_ST_OPTIONS
;
2213 if (code
== MT_ST_BOOLEANS
) {
2214 STm
->do_buffer_writes
= (options
& MT_ST_BUFFER_WRITES
) != 0;
2215 STm
->do_async_writes
= (options
& MT_ST_ASYNC_WRITES
) != 0;
2216 STm
->defaults_for_writes
= (options
& MT_ST_DEF_WRITES
) != 0;
2217 STm
->do_read_ahead
= (options
& MT_ST_READ_AHEAD
) != 0;
2218 STp
->two_fm
= (options
& MT_ST_TWO_FM
) != 0;
2219 STp
->fast_mteom
= (options
& MT_ST_FAST_MTEOM
) != 0;
2220 STp
->do_auto_lock
= (options
& MT_ST_AUTO_LOCK
) != 0;
2221 STp
->can_bsr
= (options
& MT_ST_CAN_BSR
) != 0;
2222 STp
->omit_blklims
= (options
& MT_ST_NO_BLKLIMS
) != 0;
2223 if ((STp
->device
)->scsi_level
>= SCSI_2
)
2224 STp
->can_partitions
= (options
& MT_ST_CAN_PARTITIONS
) != 0;
2225 STp
->scsi2_logical
= (options
& MT_ST_SCSI2LOGICAL
) != 0;
2226 STp
->immediate
= (options
& MT_ST_NOWAIT
) != 0;
2227 STm
->sysv
= (options
& MT_ST_SYSV
) != 0;
2228 STp
->sili
= (options
& MT_ST_SILI
) != 0;
2229 DEB( debugging
= (options
& MT_ST_DEBUGGING
) != 0;
2230 st_log_options(STp
, STm
, name
); )
2231 } else if (code
== MT_ST_SETBOOLEANS
|| code
== MT_ST_CLEARBOOLEANS
) {
2232 value
= (code
== MT_ST_SETBOOLEANS
);
2233 if ((options
& MT_ST_BUFFER_WRITES
) != 0)
2234 STm
->do_buffer_writes
= value
;
2235 if ((options
& MT_ST_ASYNC_WRITES
) != 0)
2236 STm
->do_async_writes
= value
;
2237 if ((options
& MT_ST_DEF_WRITES
) != 0)
2238 STm
->defaults_for_writes
= value
;
2239 if ((options
& MT_ST_READ_AHEAD
) != 0)
2240 STm
->do_read_ahead
= value
;
2241 if ((options
& MT_ST_TWO_FM
) != 0)
2242 STp
->two_fm
= value
;
2243 if ((options
& MT_ST_FAST_MTEOM
) != 0)
2244 STp
->fast_mteom
= value
;
2245 if ((options
& MT_ST_AUTO_LOCK
) != 0)
2246 STp
->do_auto_lock
= value
;
2247 if ((options
& MT_ST_CAN_BSR
) != 0)
2248 STp
->can_bsr
= value
;
2249 if ((options
& MT_ST_NO_BLKLIMS
) != 0)
2250 STp
->omit_blklims
= value
;
2251 if ((STp
->device
)->scsi_level
>= SCSI_2
&&
2252 (options
& MT_ST_CAN_PARTITIONS
) != 0)
2253 STp
->can_partitions
= value
;
2254 if ((options
& MT_ST_SCSI2LOGICAL
) != 0)
2255 STp
->scsi2_logical
= value
;
2256 if ((options
& MT_ST_NOWAIT
) != 0)
2257 STp
->immediate
= value
;
2258 if ((options
& MT_ST_SYSV
) != 0)
2260 if ((options
& MT_ST_SILI
) != 0)
2263 if ((options
& MT_ST_DEBUGGING
) != 0)
2265 st_log_options(STp
, STm
, name
); )
2266 } else if (code
== MT_ST_WRITE_THRESHOLD
) {
2267 /* Retained for compatibility */
2268 } else if (code
== MT_ST_DEF_BLKSIZE
) {
2269 value
= (options
& ~MT_ST_OPTIONS
);
2270 if (value
== ~MT_ST_OPTIONS
) {
2271 STm
->default_blksize
= (-1);
2272 DEBC( printk(KERN_INFO
"%s: Default block size disabled.\n", name
));
2274 STm
->default_blksize
= value
;
2275 DEBC( printk(KERN_INFO
"%s: Default block size set to %d bytes.\n",
2276 name
, STm
->default_blksize
));
2277 if (STp
->ready
== ST_READY
) {
2278 STp
->blksize_changed
= 0;
2279 set_mode_densblk(STp
, STm
);
2282 } else if (code
== MT_ST_TIMEOUTS
) {
2283 value
= (options
& ~MT_ST_OPTIONS
);
2284 if ((value
& MT_ST_SET_LONG_TIMEOUT
) != 0) {
2285 STp
->long_timeout
= (value
& ~MT_ST_SET_LONG_TIMEOUT
) * HZ
;
2286 DEBC( printk(KERN_INFO
"%s: Long timeout set to %d seconds.\n", name
,
2287 (value
& ~MT_ST_SET_LONG_TIMEOUT
)));
2289 blk_queue_rq_timeout(STp
->device
->request_queue
,
2291 DEBC( printk(KERN_INFO
"%s: Normal timeout set to %d seconds.\n",
2294 } else if (code
== MT_ST_SET_CLN
) {
2295 value
= (options
& ~MT_ST_OPTIONS
) & 0xff;
2297 (value
< EXTENDED_SENSE_START
||
2298 value
>= SCSI_SENSE_BUFFERSIZE
))
2300 STp
->cln_mode
= value
;
2301 STp
->cln_sense_mask
= (options
>> 8) & 0xff;
2302 STp
->cln_sense_value
= (options
>> 16) & 0xff;
2304 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2305 name
, value
, STp
->cln_sense_mask
, STp
->cln_sense_value
);
2306 } else if (code
== MT_ST_DEF_OPTIONS
) {
2307 code
= (options
& ~MT_ST_CLEAR_DEFAULT
);
2308 value
= (options
& MT_ST_CLEAR_DEFAULT
);
2309 if (code
== MT_ST_DEF_DENSITY
) {
2310 if (value
== MT_ST_CLEAR_DEFAULT
) {
2311 STm
->default_density
= (-1);
2312 DEBC( printk(KERN_INFO
"%s: Density default disabled.\n",
2315 STm
->default_density
= value
& 0xff;
2316 DEBC( printk(KERN_INFO
"%s: Density default set to %x\n",
2317 name
, STm
->default_density
));
2318 if (STp
->ready
== ST_READY
) {
2319 STp
->density_changed
= 0;
2320 set_mode_densblk(STp
, STm
);
2323 } else if (code
== MT_ST_DEF_DRVBUFFER
) {
2324 if (value
== MT_ST_CLEAR_DEFAULT
) {
2325 STp
->default_drvbuffer
= 0xff;
2326 DEBC( printk(KERN_INFO
2327 "%s: Drive buffer default disabled.\n", name
));
2329 STp
->default_drvbuffer
= value
& 7;
2330 DEBC( printk(KERN_INFO
2331 "%s: Drive buffer default set to %x\n",
2332 name
, STp
->default_drvbuffer
));
2333 if (STp
->ready
== ST_READY
)
2334 st_int_ioctl(STp
, MTSETDRVBUFFER
, STp
->default_drvbuffer
);
2336 } else if (code
== MT_ST_DEF_COMPRESSION
) {
2337 if (value
== MT_ST_CLEAR_DEFAULT
) {
2338 STm
->default_compression
= ST_DONT_TOUCH
;
2339 DEBC( printk(KERN_INFO
2340 "%s: Compression default disabled.\n", name
));
2342 if ((value
& 0xff00) != 0) {
2343 STp
->c_algo
= (value
& 0xff00) >> 8;
2344 DEBC( printk(KERN_INFO
"%s: Compression algorithm set to 0x%x.\n",
2345 name
, STp
->c_algo
));
2347 if ((value
& 0xff) != 0xff) {
2348 STm
->default_compression
= (value
& 1 ? ST_YES
: ST_NO
);
2349 DEBC( printk(KERN_INFO
"%s: Compression default set to %x\n",
2350 name
, (value
& 1)));
2351 if (STp
->ready
== ST_READY
) {
2352 STp
->compression_changed
= 0;
2353 st_compression(STp
, (STm
->default_compression
== ST_YES
));
2364 #define MODE_HEADER_LENGTH 4
2366 /* Mode header and page byte offsets */
2367 #define MH_OFF_DATA_LENGTH 0
2368 #define MH_OFF_MEDIUM_TYPE 1
2369 #define MH_OFF_DEV_SPECIFIC 2
2370 #define MH_OFF_BDESCS_LENGTH 3
2371 #define MP_OFF_PAGE_NBR 0
2372 #define MP_OFF_PAGE_LENGTH 1
2374 /* Mode header and page bit masks */
2375 #define MH_BIT_WP 0x80
2376 #define MP_MSK_PAGE_NBR 0x3f
2378 /* Don't return block descriptors */
2379 #define MODE_SENSE_OMIT_BDESCS 0x08
2381 #define MODE_SELECT_PAGE_FORMAT 0x10
2383 /* Read a mode page into the tape buffer. The block descriptors are included
2384 if incl_block_descs is true. The page control is ored to the page number
2385 parameter, if necessary. */
2386 static int read_mode_page(struct scsi_tape
*STp
, int page
, int omit_block_descs
)
2388 unsigned char cmd
[MAX_COMMAND_SIZE
];
2389 struct st_request
*SRpnt
;
2391 memset(cmd
, 0, MAX_COMMAND_SIZE
);
2392 cmd
[0] = MODE_SENSE
;
2393 if (omit_block_descs
)
2394 cmd
[1] = MODE_SENSE_OMIT_BDESCS
;
2398 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, cmd
[4], DMA_FROM_DEVICE
,
2399 STp
->device
->request_queue
->rq_timeout
, 0, 1);
2401 return (STp
->buffer
)->syscall_result
;
2403 st_release_request(SRpnt
);
2405 return STp
->buffer
->syscall_result
;
2409 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2410 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2411 static int write_mode_page(struct scsi_tape
*STp
, int page
, int slow
)
2414 unsigned char cmd
[MAX_COMMAND_SIZE
];
2415 struct st_request
*SRpnt
;
2418 memset(cmd
, 0, MAX_COMMAND_SIZE
);
2419 cmd
[0] = MODE_SELECT
;
2420 cmd
[1] = MODE_SELECT_PAGE_FORMAT
;
2421 pgo
= MODE_HEADER_LENGTH
+ (STp
->buffer
)->b_data
[MH_OFF_BDESCS_LENGTH
];
2422 cmd
[4] = pgo
+ (STp
->buffer
)->b_data
[pgo
+ MP_OFF_PAGE_LENGTH
] + 2;
2424 /* Clear reserved fields */
2425 (STp
->buffer
)->b_data
[MH_OFF_DATA_LENGTH
] = 0;
2426 (STp
->buffer
)->b_data
[MH_OFF_MEDIUM_TYPE
] = 0;
2427 (STp
->buffer
)->b_data
[MH_OFF_DEV_SPECIFIC
] &= ~MH_BIT_WP
;
2428 (STp
->buffer
)->b_data
[pgo
+ MP_OFF_PAGE_NBR
] &= MP_MSK_PAGE_NBR
;
2431 STp
->long_timeout
: STp
->device
->request_queue
->rq_timeout
;
2432 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, cmd
[4], DMA_TO_DEVICE
,
2435 return (STp
->buffer
)->syscall_result
;
2437 st_release_request(SRpnt
);
2439 return STp
->buffer
->syscall_result
;
2443 #define COMPRESSION_PAGE 0x0f
2444 #define COMPRESSION_PAGE_LENGTH 16
2446 #define CP_OFF_DCE_DCC 2
2447 #define CP_OFF_C_ALGO 7
2449 #define DCE_MASK 0x80
2450 #define DCC_MASK 0x40
2451 #define RED_MASK 0x60
2454 /* Control the compression with mode page 15. Algorithm not changed if zero.
2456 The block descriptors are read and written because Sony SDT-7000 does not
2457 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2458 Including block descriptors should not cause any harm to other drives. */
2460 static int st_compression(struct scsi_tape
* STp
, int state
)
2463 int mpoffs
; /* Offset to mode page start */
2464 unsigned char *b_data
= (STp
->buffer
)->b_data
;
2465 DEB( char *name
= tape_name(STp
); )
2467 if (STp
->ready
!= ST_READY
)
2470 /* Read the current page contents */
2471 retval
= read_mode_page(STp
, COMPRESSION_PAGE
, 0);
2473 DEBC(printk(ST_DEB_MSG
"%s: Compression mode page not supported.\n",
2478 mpoffs
= MODE_HEADER_LENGTH
+ b_data
[MH_OFF_BDESCS_LENGTH
];
2479 DEBC(printk(ST_DEB_MSG
"%s: Compression state is %d.\n", name
,
2480 (b_data
[mpoffs
+ CP_OFF_DCE_DCC
] & DCE_MASK
? 1 : 0)));
2482 /* Check if compression can be changed */
2483 if ((b_data
[mpoffs
+ CP_OFF_DCE_DCC
] & DCC_MASK
) == 0) {
2484 DEBC(printk(ST_DEB_MSG
"%s: Compression not supported.\n", name
));
2490 b_data
[mpoffs
+ CP_OFF_DCE_DCC
] |= DCE_MASK
;
2491 if (STp
->c_algo
!= 0)
2492 b_data
[mpoffs
+ CP_OFF_C_ALGO
] = STp
->c_algo
;
2495 b_data
[mpoffs
+ CP_OFF_DCE_DCC
] &= ~DCE_MASK
;
2496 if (STp
->c_algo
!= 0)
2497 b_data
[mpoffs
+ CP_OFF_C_ALGO
] = 0; /* no compression */
2500 retval
= write_mode_page(STp
, COMPRESSION_PAGE
, 0);
2502 DEBC(printk(ST_DEB_MSG
"%s: Compression change failed.\n", name
));
2505 DEBC(printk(ST_DEB_MSG
"%s: Compression state changed to %d.\n",
2508 STp
->compression_changed
= 1;
2513 /* Process the load and unload commands (does unload if the load code is zero) */
2514 static int do_load_unload(struct scsi_tape
*STp
, struct file
*filp
, int load_code
)
2516 int retval
= (-EIO
), timeout
;
2517 DEB( char *name
= tape_name(STp
); )
2518 unsigned char cmd
[MAX_COMMAND_SIZE
];
2519 struct st_partstat
*STps
;
2520 struct st_request
*SRpnt
;
2522 if (STp
->ready
!= ST_READY
&& !load_code
) {
2523 if (STp
->ready
== ST_NO_TAPE
)
2524 return (-ENOMEDIUM
);
2529 memset(cmd
, 0, MAX_COMMAND_SIZE
);
2530 cmd
[0] = START_STOP
;
2534 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2536 if (load_code
>= 1 + MT_ST_HPLOADER_OFFSET
2537 && load_code
<= 6 + MT_ST_HPLOADER_OFFSET
) {
2538 DEBC(printk(ST_DEB_MSG
"%s: Enhanced %sload slot %2d.\n",
2539 name
, (cmd
[4]) ? "" : "un",
2540 load_code
- MT_ST_HPLOADER_OFFSET
));
2541 cmd
[3] = load_code
- MT_ST_HPLOADER_OFFSET
; /* MediaID field of C1553A */
2543 if (STp
->immediate
) {
2544 cmd
[1] = 1; /* Don't wait for completion */
2545 timeout
= STp
->device
->request_queue
->rq_timeout
;
2548 timeout
= STp
->long_timeout
;
2552 printk(ST_DEB_MSG
"%s: Unloading tape.\n", name
);
2554 printk(ST_DEB_MSG
"%s: Loading tape.\n", name
);
2557 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, 0, DMA_NONE
,
2558 timeout
, MAX_RETRIES
, 1);
2560 return (STp
->buffer
)->syscall_result
;
2562 retval
= (STp
->buffer
)->syscall_result
;
2563 st_release_request(SRpnt
);
2565 if (!retval
) { /* SCSI command successful */
2568 STp
->rew_at_close
= 0;
2569 STp
->ready
= ST_NO_TAPE
;
2572 STp
->rew_at_close
= STp
->autorew_dev
;
2573 retval
= check_tape(STp
, filp
);
2579 STps
= &(STp
->ps
[STp
->partition
]);
2580 STps
->drv_file
= STps
->drv_block
= (-1);
2587 #define ST_DEB_FORWARD 0
2588 #define ST_DEB_BACKWARD 1
2589 static void deb_space_print(char *name
, int direction
, char *units
, unsigned char *cmd
)
2593 sc
= cmd
[2] & 0x80 ? 0xff000000 : 0;
2594 sc
|= (cmd
[2] << 16) | (cmd
[3] << 8) | cmd
[4];
2597 printk(ST_DEB_MSG
"%s: Spacing tape %s over %d %s.\n", name
,
2598 direction
? "backward" : "forward", sc
, units
);
2603 /* Internal ioctl function */
2604 static int st_int_ioctl(struct scsi_tape
*STp
, unsigned int cmd_in
, unsigned long arg
)
2610 unsigned char cmd
[MAX_COMMAND_SIZE
];
2611 struct st_request
*SRpnt
;
2612 struct st_partstat
*STps
;
2613 int fileno
, blkno
, at_sm
, undone
;
2614 int datalen
= 0, direction
= DMA_NONE
;
2615 char *name
= tape_name(STp
);
2617 WARN_ON(STp
->buffer
->do_dio
!= 0);
2618 if (STp
->ready
!= ST_READY
) {
2619 if (STp
->ready
== ST_NO_TAPE
)
2620 return (-ENOMEDIUM
);
2624 timeout
= STp
->long_timeout
;
2625 STps
= &(STp
->ps
[STp
->partition
]);
2626 fileno
= STps
->drv_file
;
2627 blkno
= STps
->drv_block
;
2628 at_sm
= STps
->at_sm
;
2630 memset(cmd
, 0, MAX_COMMAND_SIZE
);
2633 chg_eof
= 0; /* Changed from the FSF after this */
2636 cmd
[1] = 0x01; /* Space FileMarks */
2637 cmd
[2] = (arg
>> 16);
2638 cmd
[3] = (arg
>> 8);
2640 DEBC(deb_space_print(name
, ST_DEB_FORWARD
, "filemarks", cmd
);)
2644 at_sm
&= (arg
== 0);
2647 chg_eof
= 0; /* Changed from the FSF after this */
2650 cmd
[1] = 0x01; /* Space FileMarks */
2652 cmd
[2] = (ltmp
>> 16);
2653 cmd
[3] = (ltmp
>> 8);
2655 DEBC(deb_space_print(name
, ST_DEB_BACKWARD
, "filemarks", cmd
);)
2658 blkno
= (-1); /* We can't know the block number */
2659 at_sm
&= (arg
== 0);
2663 cmd
[1] = 0x00; /* Space Blocks */
2664 cmd
[2] = (arg
>> 16);
2665 cmd
[3] = (arg
>> 8);
2667 DEBC(deb_space_print(name
, ST_DEB_FORWARD
, "blocks", cmd
);)
2670 at_sm
&= (arg
== 0);
2674 cmd
[1] = 0x00; /* Space Blocks */
2676 cmd
[2] = (ltmp
>> 16);
2677 cmd
[3] = (ltmp
>> 8);
2679 DEBC(deb_space_print(name
, ST_DEB_BACKWARD
, "blocks", cmd
);)
2682 at_sm
&= (arg
== 0);
2686 cmd
[1] = 0x04; /* Space Setmarks */
2687 cmd
[2] = (arg
>> 16);
2688 cmd
[3] = (arg
>> 8);
2690 DEBC(deb_space_print(name
, ST_DEB_FORWARD
, "setmarks", cmd
);)
2692 blkno
= fileno
= (-1);
2698 cmd
[1] = 0x04; /* Space Setmarks */
2700 cmd
[2] = (ltmp
>> 16);
2701 cmd
[3] = (ltmp
>> 8);
2703 DEBC(deb_space_print(name
, ST_DEB_BACKWARD
, "setmarks", cmd
);)
2705 blkno
= fileno
= (-1);
2712 if (STp
->write_prot
)
2714 cmd
[0] = WRITE_FILEMARKS
;
2715 if (cmd_in
== MTWSM
)
2717 if (cmd_in
== MTWEOFI
)
2719 cmd
[2] = (arg
>> 16);
2720 cmd
[3] = (arg
>> 8);
2722 timeout
= STp
->device
->request_queue
->rq_timeout
;
2724 if (cmd_in
!= MTWSM
)
2725 printk(ST_DEB_MSG
"%s: Writing %d filemarks.\n", name
,
2726 cmd
[2] * 65536 + cmd
[3] * 256 + cmd
[4]);
2728 printk(ST_DEB_MSG
"%s: Writing %d setmarks.\n", name
,
2729 cmd
[2] * 65536 + cmd
[3] * 256 + cmd
[4]);
2734 at_sm
= (cmd_in
== MTWSM
);
2737 cmd
[0] = REZERO_UNIT
;
2738 if (STp
->immediate
) {
2739 cmd
[1] = 1; /* Don't wait for completion */
2740 timeout
= STp
->device
->request_queue
->rq_timeout
;
2742 DEBC(printk(ST_DEB_MSG
"%s: Rewinding tape.\n", name
));
2743 fileno
= blkno
= at_sm
= 0;
2746 DEBC(printk(ST_DEB_MSG
"%s: No op on tape.\n", name
));
2747 return 0; /* Should do something ? */
2750 cmd
[0] = START_STOP
;
2751 if (STp
->immediate
) {
2752 cmd
[1] = 1; /* Don't wait for completion */
2753 timeout
= STp
->device
->request_queue
->rq_timeout
;
2756 DEBC(printk(ST_DEB_MSG
"%s: Retensioning tape.\n", name
));
2757 fileno
= blkno
= at_sm
= 0;
2760 if (!STp
->fast_mteom
) {
2761 /* space to the end of tape */
2762 ioctl_result
= st_int_ioctl(STp
, MTFSF
, 0x7fffff);
2763 fileno
= STps
->drv_file
;
2764 if (STps
->eof
>= ST_EOD_1
)
2766 /* The next lines would hide the number of spaced FileMarks
2767 That's why I inserted the previous lines. I had no luck
2768 with detecting EOM with FSF, so we go now to EOM.
2774 DEBC(printk(ST_DEB_MSG
"%s: Spacing to end of recorded medium.\n",
2780 if (STp
->write_prot
)
2783 cmd
[1] = (arg
? 1 : 0); /* Long erase with non-zero argument */
2784 if (STp
->immediate
) {
2785 cmd
[1] |= 2; /* Don't wait for completion */
2786 timeout
= STp
->device
->request_queue
->rq_timeout
;
2789 timeout
= STp
->long_timeout
* 8;
2791 DEBC(printk(ST_DEB_MSG
"%s: Erasing tape.\n", name
));
2792 fileno
= blkno
= at_sm
= 0;
2794 case MTSETBLK
: /* Set block length */
2795 case MTSETDENSITY
: /* Set tape density */
2796 case MTSETDRVBUFFER
: /* Set drive buffering */
2797 case SET_DENS_AND_BLK
: /* Set density and block size */
2799 if (STp
->dirty
|| (STp
->buffer
)->buffer_bytes
!= 0)
2800 return (-EIO
); /* Not allowed if data in buffer */
2801 if ((cmd_in
== MTSETBLK
|| cmd_in
== SET_DENS_AND_BLK
) &&
2802 (arg
& MT_ST_BLKSIZE_MASK
) != 0 &&
2803 STp
->max_block
> 0 &&
2804 ((arg
& MT_ST_BLKSIZE_MASK
) < STp
->min_block
||
2805 (arg
& MT_ST_BLKSIZE_MASK
) > STp
->max_block
)) {
2806 printk(KERN_WARNING
"%s: Illegal block size.\n", name
);
2809 cmd
[0] = MODE_SELECT
;
2810 if ((STp
->use_pf
& USE_PF
))
2811 cmd
[1] = MODE_SELECT_PAGE_FORMAT
;
2812 cmd
[4] = datalen
= 12;
2813 direction
= DMA_TO_DEVICE
;
2815 memset((STp
->buffer
)->b_data
, 0, 12);
2816 if (cmd_in
== MTSETDRVBUFFER
)
2817 (STp
->buffer
)->b_data
[2] = (arg
& 7) << 4;
2819 (STp
->buffer
)->b_data
[2] =
2820 STp
->drv_buffer
<< 4;
2821 (STp
->buffer
)->b_data
[3] = 8; /* block descriptor length */
2822 if (cmd_in
== MTSETDENSITY
) {
2823 (STp
->buffer
)->b_data
[4] = arg
;
2824 STp
->density_changed
= 1; /* At least we tried ;-) */
2825 } else if (cmd_in
== SET_DENS_AND_BLK
)
2826 (STp
->buffer
)->b_data
[4] = arg
>> 24;
2828 (STp
->buffer
)->b_data
[4] = STp
->density
;
2829 if (cmd_in
== MTSETBLK
|| cmd_in
== SET_DENS_AND_BLK
) {
2830 ltmp
= arg
& MT_ST_BLKSIZE_MASK
;
2831 if (cmd_in
== MTSETBLK
)
2832 STp
->blksize_changed
= 1; /* At least we tried ;-) */
2834 ltmp
= STp
->block_size
;
2835 (STp
->buffer
)->b_data
[9] = (ltmp
>> 16);
2836 (STp
->buffer
)->b_data
[10] = (ltmp
>> 8);
2837 (STp
->buffer
)->b_data
[11] = ltmp
;
2838 timeout
= STp
->device
->request_queue
->rq_timeout
;
2840 if (cmd_in
== MTSETBLK
|| cmd_in
== SET_DENS_AND_BLK
)
2842 "%s: Setting block size to %d bytes.\n", name
,
2843 (STp
->buffer
)->b_data
[9] * 65536 +
2844 (STp
->buffer
)->b_data
[10] * 256 +
2845 (STp
->buffer
)->b_data
[11]);
2846 if (cmd_in
== MTSETDENSITY
|| cmd_in
== SET_DENS_AND_BLK
)
2848 "%s: Setting density code to %x.\n", name
,
2849 (STp
->buffer
)->b_data
[4]);
2850 if (cmd_in
== MTSETDRVBUFFER
)
2852 "%s: Setting drive buffer code to %d.\n", name
,
2853 ((STp
->buffer
)->b_data
[2] >> 4) & 7);
2860 SRpnt
= st_do_scsi(NULL
, STp
, cmd
, datalen
, direction
,
2861 timeout
, MAX_RETRIES
, 1);
2863 return (STp
->buffer
)->syscall_result
;
2865 ioctl_result
= (STp
->buffer
)->syscall_result
;
2867 if (!ioctl_result
) { /* SCSI command successful */
2868 st_release_request(SRpnt
);
2870 STps
->drv_block
= blkno
;
2871 STps
->drv_file
= fileno
;
2872 STps
->at_sm
= at_sm
;
2874 if (cmd_in
== MTBSFM
)
2875 ioctl_result
= st_int_ioctl(STp
, MTFSF
, 1);
2876 else if (cmd_in
== MTFSFM
)
2877 ioctl_result
= st_int_ioctl(STp
, MTBSF
, 1);
2879 if (cmd_in
== MTSETBLK
|| cmd_in
== SET_DENS_AND_BLK
) {
2880 STp
->block_size
= arg
& MT_ST_BLKSIZE_MASK
;
2881 if (STp
->block_size
!= 0) {
2882 (STp
->buffer
)->buffer_blocks
=
2883 (STp
->buffer
)->buffer_size
/ STp
->block_size
;
2885 (STp
->buffer
)->buffer_bytes
= (STp
->buffer
)->read_pointer
= 0;
2886 if (cmd_in
== SET_DENS_AND_BLK
)
2887 STp
->density
= arg
>> MT_ST_DENSITY_SHIFT
;
2888 } else if (cmd_in
== MTSETDRVBUFFER
)
2889 STp
->drv_buffer
= (arg
& 7);
2890 else if (cmd_in
== MTSETDENSITY
)
2893 if (cmd_in
== MTEOM
)
2895 else if (cmd_in
== MTFSF
)
2898 STps
->eof
= ST_NOEOF
;
2900 if (cmd_in
== MTWEOF
|| cmd_in
== MTWEOFI
)
2901 STps
->rw
= ST_IDLE
; /* prevent automatic WEOF at close */
2902 } else { /* SCSI command was not completely successful. Don't return
2903 from this block without releasing the SCSI command block! */
2904 struct st_cmdstatus
*cmdstatp
= &STp
->buffer
->cmdstat
;
2906 if (cmdstatp
->flags
& SENSE_EOM
) {
2907 if (cmd_in
!= MTBSF
&& cmd_in
!= MTBSFM
&&
2908 cmd_in
!= MTBSR
&& cmd_in
!= MTBSS
)
2909 STps
->eof
= ST_EOM_OK
;
2910 STps
->drv_block
= 0;
2913 if (cmdstatp
->remainder_valid
)
2914 undone
= (int)cmdstatp
->uremainder64
;
2918 if ((cmd_in
== MTWEOF
|| cmd_in
== MTWEOFI
) &&
2919 cmdstatp
->have_sense
&&
2920 (cmdstatp
->flags
& SENSE_EOM
)) {
2921 if (cmdstatp
->sense_hdr
.sense_key
== NO_SENSE
||
2922 cmdstatp
->sense_hdr
.sense_key
== RECOVERED_ERROR
) {
2923 ioctl_result
= 0; /* EOF(s) written successfully at EOM */
2924 STps
->eof
= ST_NOEOF
;
2925 } else { /* Writing EOF(s) failed */
2929 STps
->eof
= ST_NOEOF
;
2931 STps
->drv_file
= fileno
;
2932 } else if ((cmd_in
== MTFSF
) || (cmd_in
== MTFSFM
)) {
2934 STps
->drv_file
= fileno
- undone
;
2936 STps
->drv_file
= fileno
;
2937 STps
->drv_block
= -1;
2938 STps
->eof
= ST_NOEOF
;
2939 } else if ((cmd_in
== MTBSF
) || (cmd_in
== MTBSFM
)) {
2940 if (arg
> 0 && undone
< 0) /* Some drives get this wrong */
2942 if (STps
->drv_file
>= 0)
2943 STps
->drv_file
= fileno
+ undone
;
2944 STps
->drv_block
= 0;
2945 STps
->eof
= ST_NOEOF
;
2946 } else if (cmd_in
== MTFSR
) {
2947 if (cmdstatp
->flags
& SENSE_FMK
) { /* Hit filemark */
2948 if (STps
->drv_file
>= 0)
2950 STps
->drv_block
= 0;
2953 if (blkno
>= undone
)
2954 STps
->drv_block
= blkno
- undone
;
2956 STps
->drv_block
= (-1);
2957 STps
->eof
= ST_NOEOF
;
2959 } else if (cmd_in
== MTBSR
) {
2960 if (cmdstatp
->flags
& SENSE_FMK
) { /* Hit filemark */
2962 STps
->drv_block
= (-1);
2964 if (arg
> 0 && undone
< 0) /* Some drives get this wrong */
2966 if (STps
->drv_block
>= 0)
2967 STps
->drv_block
= blkno
+ undone
;
2969 STps
->eof
= ST_NOEOF
;
2970 } else if (cmd_in
== MTEOM
) {
2971 STps
->drv_file
= (-1);
2972 STps
->drv_block
= (-1);
2974 } else if (cmd_in
== MTSETBLK
||
2975 cmd_in
== MTSETDENSITY
||
2976 cmd_in
== MTSETDRVBUFFER
||
2977 cmd_in
== SET_DENS_AND_BLK
) {
2978 if (cmdstatp
->sense_hdr
.sense_key
== ILLEGAL_REQUEST
&&
2979 !(STp
->use_pf
& PF_TESTED
)) {
2980 /* Try the other possible state of Page Format if not
2982 STp
->use_pf
= (STp
->use_pf
^ USE_PF
) | PF_TESTED
;
2983 st_release_request(SRpnt
);
2985 return st_int_ioctl(STp
, cmd_in
, arg
);
2988 STps
->eof
= ST_NOEOF
;
2990 if (cmdstatp
->sense_hdr
.sense_key
== BLANK_CHECK
)
2993 st_release_request(SRpnt
);
2997 return ioctl_result
;
3001 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3004 static int get_location(struct scsi_tape
*STp
, unsigned int *block
, int *partition
,
3008 unsigned char scmd
[MAX_COMMAND_SIZE
];
3009 struct st_request
*SRpnt
;
3010 DEB( char *name
= tape_name(STp
); )
3012 if (STp
->ready
!= ST_READY
)
3015 memset(scmd
, 0, MAX_COMMAND_SIZE
);
3016 if ((STp
->device
)->scsi_level
< SCSI_2
) {
3017 scmd
[0] = QFA_REQUEST_BLOCK
;
3020 scmd
[0] = READ_POSITION
;
3021 if (!logical
&& !STp
->scsi2_logical
)
3024 SRpnt
= st_do_scsi(NULL
, STp
, scmd
, 20, DMA_FROM_DEVICE
,
3025 STp
->device
->request_queue
->rq_timeout
,
3026 MAX_READY_RETRIES
, 1);
3028 return (STp
->buffer
)->syscall_result
;
3030 if ((STp
->buffer
)->syscall_result
!= 0 ||
3031 (STp
->device
->scsi_level
>= SCSI_2
&&
3032 ((STp
->buffer
)->b_data
[0] & 4) != 0)) {
3033 *block
= *partition
= 0;
3034 DEBC(printk(ST_DEB_MSG
"%s: Can't read tape position.\n", name
));
3038 if ((STp
->device
)->scsi_level
< SCSI_2
) {
3039 *block
= ((STp
->buffer
)->b_data
[0] << 16)
3040 + ((STp
->buffer
)->b_data
[1] << 8)
3041 + (STp
->buffer
)->b_data
[2];
3044 *block
= ((STp
->buffer
)->b_data
[4] << 24)
3045 + ((STp
->buffer
)->b_data
[5] << 16)
3046 + ((STp
->buffer
)->b_data
[6] << 8)
3047 + (STp
->buffer
)->b_data
[7];
3048 *partition
= (STp
->buffer
)->b_data
[1];
3049 if (((STp
->buffer
)->b_data
[0] & 0x80) &&
3050 (STp
->buffer
)->b_data
[1] == 0) /* BOP of partition 0 */
3051 STp
->ps
[0].drv_block
= STp
->ps
[0].drv_file
= 0;
3053 DEBC(printk(ST_DEB_MSG
"%s: Got tape pos. blk %d part %d.\n", name
,
3054 *block
, *partition
));
3056 st_release_request(SRpnt
);
3063 /* Set the tape block and partition. Negative partition means that only the
3064 block should be set in vendor specific way. */
3065 static int set_location(struct scsi_tape
*STp
, unsigned int block
, int partition
,
3068 struct st_partstat
*STps
;
3072 unsigned char scmd
[MAX_COMMAND_SIZE
];
3073 struct st_request
*SRpnt
;
3074 DEB( char *name
= tape_name(STp
); )
3076 if (STp
->ready
!= ST_READY
)
3078 timeout
= STp
->long_timeout
;
3079 STps
= &(STp
->ps
[STp
->partition
]);
3081 DEBC(printk(ST_DEB_MSG
"%s: Setting block to %d and partition to %d.\n",
3082 name
, block
, partition
));
3083 DEB(if (partition
< 0)
3086 /* Update the location at the partition we are leaving */
3087 if ((!STp
->can_partitions
&& partition
!= 0) ||
3088 partition
>= ST_NBR_PARTITIONS
)
3090 if (partition
!= STp
->partition
) {
3091 if (get_location(STp
, &blk
, &p
, 1))
3092 STps
->last_block_valid
= 0;
3094 STps
->last_block_valid
= 1;
3095 STps
->last_block_visited
= blk
;
3096 DEBC(printk(ST_DEB_MSG
3097 "%s: Visited block %d for partition %d saved.\n",
3098 name
, blk
, STp
->partition
));
3102 memset(scmd
, 0, MAX_COMMAND_SIZE
);
3103 if ((STp
->device
)->scsi_level
< SCSI_2
) {
3104 scmd
[0] = QFA_SEEK_BLOCK
;
3105 scmd
[2] = (block
>> 16);
3106 scmd
[3] = (block
>> 8);
3111 scmd
[3] = (block
>> 24);
3112 scmd
[4] = (block
>> 16);
3113 scmd
[5] = (block
>> 8);
3115 if (!logical
&& !STp
->scsi2_logical
)
3117 if (STp
->partition
!= partition
) {
3119 scmd
[8] = partition
;
3120 DEBC(printk(ST_DEB_MSG
3121 "%s: Trying to change partition from %d to %d\n",
3122 name
, STp
->partition
, partition
));
3125 if (STp
->immediate
) {
3126 scmd
[1] |= 1; /* Don't wait for completion */
3127 timeout
= STp
->device
->request_queue
->rq_timeout
;
3130 SRpnt
= st_do_scsi(NULL
, STp
, scmd
, 0, DMA_NONE
,
3131 timeout
, MAX_READY_RETRIES
, 1);
3133 return (STp
->buffer
)->syscall_result
;
3135 STps
->drv_block
= STps
->drv_file
= (-1);
3136 STps
->eof
= ST_NOEOF
;
3137 if ((STp
->buffer
)->syscall_result
!= 0) {
3139 if (STp
->can_partitions
&&
3140 (STp
->device
)->scsi_level
>= SCSI_2
&&
3141 (p
= find_partition(STp
)) >= 0)
3144 if (STp
->can_partitions
) {
3145 STp
->partition
= partition
;
3146 STps
= &(STp
->ps
[partition
]);
3147 if (!STps
->last_block_valid
||
3148 STps
->last_block_visited
!= block
) {
3155 STps
->drv_block
= STps
->drv_file
= 0;
3159 st_release_request(SRpnt
);
3166 /* Find the current partition number for the drive status. Called from open and
3167 returns either partition number of negative error code. */
3168 static int find_partition(struct scsi_tape
*STp
)
3173 if ((i
= get_location(STp
, &block
, &partition
, 1)) < 0)
3175 if (partition
>= ST_NBR_PARTITIONS
)
3181 /* Change the partition if necessary */
3182 static int switch_partition(struct scsi_tape
*STp
)
3184 struct st_partstat
*STps
;
3186 if (STp
->partition
== STp
->new_partition
)
3188 STps
= &(STp
->ps
[STp
->new_partition
]);
3189 if (!STps
->last_block_valid
)
3190 STps
->last_block_visited
= 0;
3191 return set_location(STp
, STps
->last_block_visited
, STp
->new_partition
, 1);
3194 /* Functions for reading and writing the medium partition mode page. */
3196 #define PART_PAGE 0x11
3197 #define PART_PAGE_FIXED_LENGTH 8
3199 #define PP_OFF_MAX_ADD_PARTS 2
3200 #define PP_OFF_NBR_ADD_PARTS 3
3201 #define PP_OFF_FLAGS 4
3202 #define PP_OFF_PART_UNITS 6
3203 #define PP_OFF_RESERVED 7
3205 #define PP_BIT_IDP 0x20
3206 #define PP_MSK_PSUM_MB 0x10
3208 /* Get the number of partitions on the tape. As a side effect reads the
3209 mode page into the tape buffer. */
3210 static int nbr_partitions(struct scsi_tape
*STp
)
3213 DEB( char *name
= tape_name(STp
); )
3215 if (STp
->ready
!= ST_READY
)
3218 result
= read_mode_page(STp
, PART_PAGE
, 1);
3221 DEBC(printk(ST_DEB_MSG
"%s: Can't read medium partition page.\n",
3225 result
= (STp
->buffer
)->b_data
[MODE_HEADER_LENGTH
+
3226 PP_OFF_NBR_ADD_PARTS
] + 1;
3227 DEBC(printk(ST_DEB_MSG
"%s: Number of partitions %d.\n", name
, result
));
3234 /* Partition the tape into two partitions if size > 0 or one partition if
3237 The block descriptors are read and written because Sony SDT-7000 does not
3238 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3240 My HP C1533A drive returns only one partition size field. This is used to
3241 set the size of partition 1. There is no size field for the default partition.
3242 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3243 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3244 The following algorithm is used to accommodate both drives: if the number of
3245 partition size fields is greater than the maximum number of additional partitions
3246 in the mode page, the second field is used. Otherwise the first field is used.
3248 For Seagate DDS drives the page length must be 8 when no partitions is defined
3249 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3250 is acceptable also to some other old drives and enforced if the first partition
3251 size field is used for the first additional partition size.
3253 static int partition_tape(struct scsi_tape
*STp
, int size
)
3255 char *name
= tape_name(STp
);
3257 int pgo
, psd_cnt
, psdo
;
3260 result
= read_mode_page(STp
, PART_PAGE
, 0);
3262 DEBC(printk(ST_DEB_MSG
"%s: Can't read partition mode page.\n", name
));
3265 /* The mode page is in the buffer. Let's modify it and write it. */
3266 bp
= (STp
->buffer
)->b_data
;
3267 pgo
= MODE_HEADER_LENGTH
+ bp
[MH_OFF_BDESCS_LENGTH
];
3268 DEBC(printk(ST_DEB_MSG
"%s: Partition page length is %d bytes.\n",
3269 name
, bp
[pgo
+ MP_OFF_PAGE_LENGTH
] + 2));
3271 psd_cnt
= (bp
[pgo
+ MP_OFF_PAGE_LENGTH
] + 2 - PART_PAGE_FIXED_LENGTH
) / 2;
3272 psdo
= pgo
+ PART_PAGE_FIXED_LENGTH
;
3273 if (psd_cnt
> bp
[pgo
+ PP_OFF_MAX_ADD_PARTS
]) {
3274 bp
[psdo
] = bp
[psdo
+ 1] = 0xff; /* Rest of the tape */
3277 memset(bp
+ psdo
, 0, bp
[pgo
+ PP_OFF_NBR_ADD_PARTS
] * 2);
3279 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name
,
3280 psd_cnt
, bp
[pgo
+ PP_OFF_MAX_ADD_PARTS
],
3281 bp
[pgo
+ PP_OFF_NBR_ADD_PARTS
]));
3284 bp
[pgo
+ PP_OFF_NBR_ADD_PARTS
] = 0;
3285 if (psd_cnt
<= bp
[pgo
+ PP_OFF_MAX_ADD_PARTS
])
3286 bp
[pgo
+ MP_OFF_PAGE_LENGTH
] = 6;
3287 DEBC(printk(ST_DEB_MSG
"%s: Formatting tape with one partition.\n",
3290 bp
[psdo
] = (size
>> 8) & 0xff;
3291 bp
[psdo
+ 1] = size
& 0xff;
3293 if (bp
[pgo
+ MP_OFF_PAGE_LENGTH
] < 8)
3294 bp
[pgo
+ MP_OFF_PAGE_LENGTH
] = 8;
3295 DEBC(printk(ST_DEB_MSG
3296 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3299 bp
[pgo
+ PP_OFF_PART_UNITS
] = 0;
3300 bp
[pgo
+ PP_OFF_RESERVED
] = 0;
3301 bp
[pgo
+ PP_OFF_FLAGS
] = PP_BIT_IDP
| PP_MSK_PSUM_MB
;
3303 result
= write_mode_page(STp
, PART_PAGE
, 1);
3305 printk(KERN_INFO
"%s: Partitioning of tape failed.\n", name
);
3314 /* The ioctl command */
3315 static long st_ioctl(struct file
*file
, unsigned int cmd_in
, unsigned long arg
)
3317 int i
, cmd_nr
, cmd_type
, bt
;
3320 struct scsi_tape
*STp
= file
->private_data
;
3321 struct st_modedef
*STm
;
3322 struct st_partstat
*STps
;
3323 char *name
= tape_name(STp
);
3324 void __user
*p
= (void __user
*)arg
;
3326 if (mutex_lock_interruptible(&STp
->lock
))
3327 return -ERESTARTSYS
;
3330 if (debugging
&& !STp
->in_use
) {
3331 printk(ST_DEB_MSG
"%s: Incorrect device.\n", name
);
3336 STm
= &(STp
->modes
[STp
->current_mode
]);
3337 STps
= &(STp
->ps
[STp
->partition
]);
3340 * If we are in the middle of error recovery, don't let anyone
3341 * else try and use this device. Also, if error recovery fails, it
3342 * may try and take the device offline, in which case all further
3343 * access to the device is prohibited.
3345 retval
= scsi_nonblockable_ioctl(STp
->device
, cmd_in
, p
,
3346 file
->f_flags
& O_NDELAY
);
3347 if (!scsi_block_when_processing_errors(STp
->device
) || retval
!= -ENODEV
)
3351 cmd_type
= _IOC_TYPE(cmd_in
);
3352 cmd_nr
= _IOC_NR(cmd_in
);
3354 if (cmd_type
== _IOC_TYPE(MTIOCTOP
) && cmd_nr
== _IOC_NR(MTIOCTOP
)) {
3357 if (_IOC_SIZE(cmd_in
) != sizeof(mtc
)) {
3362 i
= copy_from_user(&mtc
, p
, sizeof(struct mtop
));
3368 if (mtc
.mt_op
== MTSETDRVBUFFER
&& !capable(CAP_SYS_ADMIN
)) {
3370 "%s: MTSETDRVBUFFER only allowed for root.\n", name
);
3374 if (!STm
->defined
&&
3375 (mtc
.mt_op
!= MTSETDRVBUFFER
&&
3376 (mtc
.mt_count
& MT_ST_OPTIONS
) == 0)) {
3381 if (!STp
->pos_unknown
) {
3383 if (STps
->eof
== ST_FM_HIT
) {
3384 if (mtc
.mt_op
== MTFSF
|| mtc
.mt_op
== MTFSFM
||
3385 mtc
.mt_op
== MTEOM
) {
3387 if (STps
->drv_file
>= 0)
3388 STps
->drv_file
+= 1;
3389 } else if (mtc
.mt_op
== MTBSF
|| mtc
.mt_op
== MTBSFM
) {
3391 if (STps
->drv_file
>= 0)
3392 STps
->drv_file
+= 1;
3396 if (mtc
.mt_op
== MTSEEK
) {
3397 /* Old position must be restored if partition will be
3399 i
= !STp
->can_partitions
||
3400 (STp
->new_partition
!= STp
->partition
);
3402 i
= mtc
.mt_op
== MTREW
|| mtc
.mt_op
== MTOFFL
||
3403 mtc
.mt_op
== MTRETEN
|| mtc
.mt_op
== MTEOM
||
3404 mtc
.mt_op
== MTLOCK
|| mtc
.mt_op
== MTLOAD
||
3405 mtc
.mt_op
== MTFSF
|| mtc
.mt_op
== MTFSFM
||
3406 mtc
.mt_op
== MTBSF
|| mtc
.mt_op
== MTBSFM
||
3407 mtc
.mt_op
== MTCOMPRESSION
;
3409 i
= flush_buffer(STp
, i
);
3414 if (STps
->rw
== ST_WRITING
&&
3415 (mtc
.mt_op
== MTREW
|| mtc
.mt_op
== MTOFFL
||
3416 mtc
.mt_op
== MTSEEK
||
3417 mtc
.mt_op
== MTBSF
|| mtc
.mt_op
== MTBSFM
)) {
3418 i
= st_int_ioctl(STp
, MTWEOF
, 1);
3423 if (mtc
.mt_op
== MTBSF
|| mtc
.mt_op
== MTBSFM
)
3430 * If there was a bus reset, block further access
3431 * to this device. If the user wants to rewind the tape,
3432 * then reset the flag and allow access again.
3434 if (mtc
.mt_op
!= MTREW
&&
3435 mtc
.mt_op
!= MTOFFL
&&
3436 mtc
.mt_op
!= MTRETEN
&&
3437 mtc
.mt_op
!= MTERASE
&&
3438 mtc
.mt_op
!= MTSEEK
&&
3439 mtc
.mt_op
!= MTEOM
) {
3444 /* remove this when the midlevel properly clears was_reset */
3445 STp
->device
->was_reset
= 0;
3448 if (mtc
.mt_op
!= MTNOP
&& mtc
.mt_op
!= MTSETBLK
&&
3449 mtc
.mt_op
!= MTSETDENSITY
&& mtc
.mt_op
!= MTWSM
&&
3450 mtc
.mt_op
!= MTSETDRVBUFFER
&& mtc
.mt_op
!= MTSETPART
)
3451 STps
->rw
= ST_IDLE
; /* Prevent automatic WEOF and fsf */
3453 if (mtc
.mt_op
== MTOFFL
&& STp
->door_locked
!= ST_UNLOCKED
)
3454 do_door_lock(STp
, 0); /* Ignore result! */
3456 if (mtc
.mt_op
== MTSETDRVBUFFER
&&
3457 (mtc
.mt_count
& MT_ST_OPTIONS
) != 0) {
3458 retval
= st_set_options(STp
, mtc
.mt_count
);
3462 if (mtc
.mt_op
== MTSETPART
) {
3463 if (!STp
->can_partitions
||
3464 mtc
.mt_count
< 0 || mtc
.mt_count
>= ST_NBR_PARTITIONS
) {
3468 if (mtc
.mt_count
>= STp
->nbr_partitions
&&
3469 (STp
->nbr_partitions
= nbr_partitions(STp
)) < 0) {
3473 if (mtc
.mt_count
>= STp
->nbr_partitions
) {
3477 STp
->new_partition
= mtc
.mt_count
;
3482 if (mtc
.mt_op
== MTMKPART
) {
3483 if (!STp
->can_partitions
) {
3487 if ((i
= st_int_ioctl(STp
, MTREW
, 0)) < 0 ||
3488 (i
= partition_tape(STp
, mtc
.mt_count
)) < 0) {
3492 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
3493 STp
->ps
[i
].rw
= ST_IDLE
;
3494 STp
->ps
[i
].at_sm
= 0;
3495 STp
->ps
[i
].last_block_valid
= 0;
3497 STp
->partition
= STp
->new_partition
= 0;
3498 STp
->nbr_partitions
= 1; /* Bad guess ?-) */
3499 STps
->drv_block
= STps
->drv_file
= 0;
3504 if (mtc
.mt_op
== MTSEEK
) {
3505 i
= set_location(STp
, mtc
.mt_count
, STp
->new_partition
, 0);
3506 if (!STp
->can_partitions
)
3507 STp
->ps
[0].rw
= ST_IDLE
;
3512 if (mtc
.mt_op
== MTUNLOAD
|| mtc
.mt_op
== MTOFFL
) {
3513 retval
= do_load_unload(STp
, file
, 0);
3517 if (mtc
.mt_op
== MTLOAD
) {
3518 retval
= do_load_unload(STp
, file
, max(1, mtc
.mt_count
));
3522 if (mtc
.mt_op
== MTLOCK
|| mtc
.mt_op
== MTUNLOCK
) {
3523 retval
= do_door_lock(STp
, (mtc
.mt_op
== MTLOCK
));
3527 if (STp
->can_partitions
&& STp
->ready
== ST_READY
&&
3528 (i
= switch_partition(STp
)) < 0) {
3533 if (mtc
.mt_op
== MTCOMPRESSION
)
3534 retval
= st_compression(STp
, (mtc
.mt_count
& 1));
3536 retval
= st_int_ioctl(STp
, mtc
.mt_op
, mtc
.mt_count
);
3539 if (!STm
->defined
) {
3544 if ((i
= flush_buffer(STp
, 0)) < 0) {
3548 if (STp
->can_partitions
&&
3549 (i
= switch_partition(STp
)) < 0) {
3554 if (cmd_type
== _IOC_TYPE(MTIOCGET
) && cmd_nr
== _IOC_NR(MTIOCGET
)) {
3555 struct mtget mt_status
;
3557 if (_IOC_SIZE(cmd_in
) != sizeof(struct mtget
)) {
3562 mt_status
.mt_type
= STp
->tape_type
;
3563 mt_status
.mt_dsreg
=
3564 ((STp
->block_size
<< MT_ST_BLKSIZE_SHIFT
) & MT_ST_BLKSIZE_MASK
) |
3565 ((STp
->density
<< MT_ST_DENSITY_SHIFT
) & MT_ST_DENSITY_MASK
);
3566 mt_status
.mt_blkno
= STps
->drv_block
;
3567 mt_status
.mt_fileno
= STps
->drv_file
;
3568 if (STp
->block_size
!= 0) {
3569 if (STps
->rw
== ST_WRITING
)
3570 mt_status
.mt_blkno
+=
3571 (STp
->buffer
)->buffer_bytes
/ STp
->block_size
;
3572 else if (STps
->rw
== ST_READING
)
3573 mt_status
.mt_blkno
-=
3574 ((STp
->buffer
)->buffer_bytes
+
3575 STp
->block_size
- 1) / STp
->block_size
;
3578 mt_status
.mt_gstat
= 0;
3579 if (STp
->drv_write_prot
)
3580 mt_status
.mt_gstat
|= GMT_WR_PROT(0xffffffff);
3581 if (mt_status
.mt_blkno
== 0) {
3582 if (mt_status
.mt_fileno
== 0)
3583 mt_status
.mt_gstat
|= GMT_BOT(0xffffffff);
3585 mt_status
.mt_gstat
|= GMT_EOF(0xffffffff);
3587 mt_status
.mt_erreg
= (STp
->recover_reg
<< MT_ST_SOFTERR_SHIFT
);
3588 mt_status
.mt_resid
= STp
->partition
;
3589 if (STps
->eof
== ST_EOM_OK
|| STps
->eof
== ST_EOM_ERROR
)
3590 mt_status
.mt_gstat
|= GMT_EOT(0xffffffff);
3591 else if (STps
->eof
>= ST_EOM_OK
)
3592 mt_status
.mt_gstat
|= GMT_EOD(0xffffffff);
3593 if (STp
->density
== 1)
3594 mt_status
.mt_gstat
|= GMT_D_800(0xffffffff);
3595 else if (STp
->density
== 2)
3596 mt_status
.mt_gstat
|= GMT_D_1600(0xffffffff);
3597 else if (STp
->density
== 3)
3598 mt_status
.mt_gstat
|= GMT_D_6250(0xffffffff);
3599 if (STp
->ready
== ST_READY
)
3600 mt_status
.mt_gstat
|= GMT_ONLINE(0xffffffff);
3601 if (STp
->ready
== ST_NO_TAPE
)
3602 mt_status
.mt_gstat
|= GMT_DR_OPEN(0xffffffff);
3604 mt_status
.mt_gstat
|= GMT_SM(0xffffffff);
3605 if (STm
->do_async_writes
||
3606 (STm
->do_buffer_writes
&& STp
->block_size
!= 0) ||
3607 STp
->drv_buffer
!= 0)
3608 mt_status
.mt_gstat
|= GMT_IM_REP_EN(0xffffffff);
3609 if (STp
->cleaning_req
)
3610 mt_status
.mt_gstat
|= GMT_CLN(0xffffffff);
3612 i
= copy_to_user(p
, &mt_status
, sizeof(struct mtget
));
3618 STp
->recover_reg
= 0; /* Clear after read */
3621 } /* End of MTIOCGET */
3622 if (cmd_type
== _IOC_TYPE(MTIOCPOS
) && cmd_nr
== _IOC_NR(MTIOCPOS
)) {
3623 struct mtpos mt_pos
;
3624 if (_IOC_SIZE(cmd_in
) != sizeof(struct mtpos
)) {
3628 if ((i
= get_location(STp
, &blk
, &bt
, 0)) < 0) {
3632 mt_pos
.mt_blkno
= blk
;
3633 i
= copy_to_user(p
, &mt_pos
, sizeof(struct mtpos
));
3638 mutex_unlock(&STp
->lock
);
3640 case SCSI_IOCTL_GET_IDLUN
:
3641 case SCSI_IOCTL_GET_BUS_NUMBER
:
3644 if ((cmd_in
== SG_IO
||
3645 cmd_in
== SCSI_IOCTL_SEND_COMMAND
||
3646 cmd_in
== CDROM_SEND_PACKET
) &&
3647 !capable(CAP_SYS_RAWIO
))
3650 i
= scsi_cmd_ioctl(STp
->disk
->queue
, STp
->disk
,
3651 file
->f_mode
, cmd_in
, p
);
3656 retval
= scsi_ioctl(STp
->device
, cmd_in
, p
);
3657 if (!retval
&& cmd_in
== SCSI_IOCTL_STOP_UNIT
) { /* unload */
3658 STp
->rew_at_close
= 0;
3659 STp
->ready
= ST_NO_TAPE
;
3664 mutex_unlock(&STp
->lock
);
3668 #ifdef CONFIG_COMPAT
3669 static long st_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
3671 struct scsi_tape
*STp
= file
->private_data
;
3672 struct scsi_device
*sdev
= STp
->device
;
3673 int ret
= -ENOIOCTLCMD
;
3674 if (sdev
->host
->hostt
->compat_ioctl
) {
3676 ret
= sdev
->host
->hostt
->compat_ioctl(sdev
, cmd
, (void __user
*)arg
);
3685 /* Try to allocate a new tape buffer. Calling function must not hold
3687 static struct st_buffer
*new_tape_buffer(int need_dma
, int max_sg
)
3689 struct st_buffer
*tb
;
3691 tb
= kzalloc(sizeof(struct st_buffer
), GFP_ATOMIC
);
3693 printk(KERN_NOTICE
"st: Can't allocate new tape buffer.\n");
3697 tb
->use_sg
= max_sg
;
3699 tb
->buffer_size
= 0;
3701 tb
->reserved_pages
= kzalloc(max_sg
* sizeof(struct page
*),
3703 if (!tb
->reserved_pages
) {
3712 /* Try to allocate enough space in the tape buffer */
3713 #define ST_MAX_ORDER 6
3715 static int enlarge_buffer(struct st_buffer
* STbuffer
, int new_size
, int need_dma
)
3717 int segs
, nbr
, max_segs
, b_size
, order
, got
;
3720 if (new_size
<= STbuffer
->buffer_size
)
3723 if (STbuffer
->buffer_size
<= PAGE_SIZE
)
3724 normalize_buffer(STbuffer
); /* Avoid extra segment */
3726 max_segs
= STbuffer
->use_sg
;
3727 nbr
= max_segs
- STbuffer
->frp_segs
;
3731 priority
= GFP_KERNEL
| __GFP_NOWARN
;
3733 priority
|= GFP_DMA
;
3735 if (STbuffer
->cleared
)
3736 priority
|= __GFP_ZERO
;
3738 if (STbuffer
->frp_segs
) {
3739 order
= STbuffer
->reserved_page_order
;
3740 b_size
= PAGE_SIZE
<< order
;
3742 for (b_size
= PAGE_SIZE
, order
= 0;
3743 order
< ST_MAX_ORDER
&&
3744 max_segs
* (PAGE_SIZE
<< order
) < new_size
;
3745 order
++, b_size
*= 2)
3747 STbuffer
->reserved_page_order
= order
;
3749 if (max_segs
* (PAGE_SIZE
<< order
) < new_size
) {
3750 if (order
== ST_MAX_ORDER
)
3752 normalize_buffer(STbuffer
);
3753 return enlarge_buffer(STbuffer
, new_size
, need_dma
);
3756 for (segs
= STbuffer
->frp_segs
, got
= STbuffer
->buffer_size
;
3757 segs
< max_segs
&& got
< new_size
;) {
3760 page
= alloc_pages(priority
, order
);
3762 DEB(STbuffer
->buffer_size
= got
);
3763 normalize_buffer(STbuffer
);
3767 STbuffer
->frp_segs
+= 1;
3769 STbuffer
->buffer_size
= got
;
3770 STbuffer
->reserved_pages
[segs
] = page
;
3773 STbuffer
->b_data
= page_address(STbuffer
->reserved_pages
[0]);
3779 /* Make sure that no data from previous user is in the internal buffer */
3780 static void clear_buffer(struct st_buffer
* st_bp
)
3784 for (i
=0; i
< st_bp
->frp_segs
; i
++)
3785 memset(page_address(st_bp
->reserved_pages
[i
]), 0,
3786 PAGE_SIZE
<< st_bp
->reserved_page_order
);
3791 /* Release the extra buffer */
3792 static void normalize_buffer(struct st_buffer
* STbuffer
)
3794 int i
, order
= STbuffer
->reserved_page_order
;
3796 for (i
= 0; i
< STbuffer
->frp_segs
; i
++) {
3797 __free_pages(STbuffer
->reserved_pages
[i
], order
);
3798 STbuffer
->buffer_size
-= (PAGE_SIZE
<< order
);
3800 STbuffer
->frp_segs
= 0;
3801 STbuffer
->sg_segs
= 0;
3802 STbuffer
->reserved_page_order
= 0;
3803 STbuffer
->map_data
.offset
= 0;
3807 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3808 negative error code. */
3809 static int append_to_buffer(const char __user
*ubp
, struct st_buffer
* st_bp
, int do_count
)
3811 int i
, cnt
, res
, offset
;
3812 int length
= PAGE_SIZE
<< st_bp
->reserved_page_order
;
3814 for (i
= 0, offset
= st_bp
->buffer_bytes
;
3815 i
< st_bp
->frp_segs
&& offset
>= length
; i
++)
3817 if (i
== st_bp
->frp_segs
) { /* Should never happen */
3818 printk(KERN_WARNING
"st: append_to_buffer offset overflow.\n");
3821 for (; i
< st_bp
->frp_segs
&& do_count
> 0; i
++) {
3822 struct page
*page
= st_bp
->reserved_pages
[i
];
3823 cnt
= length
- offset
< do_count
? length
- offset
: do_count
;
3824 res
= copy_from_user(page_address(page
) + offset
, ubp
, cnt
);
3828 st_bp
->buffer_bytes
+= cnt
;
3832 if (do_count
) /* Should never happen */
3839 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3840 negative error code. */
3841 static int from_buffer(struct st_buffer
* st_bp
, char __user
*ubp
, int do_count
)
3843 int i
, cnt
, res
, offset
;
3844 int length
= PAGE_SIZE
<< st_bp
->reserved_page_order
;
3846 for (i
= 0, offset
= st_bp
->read_pointer
;
3847 i
< st_bp
->frp_segs
&& offset
>= length
; i
++)
3849 if (i
== st_bp
->frp_segs
) { /* Should never happen */
3850 printk(KERN_WARNING
"st: from_buffer offset overflow.\n");
3853 for (; i
< st_bp
->frp_segs
&& do_count
> 0; i
++) {
3854 struct page
*page
= st_bp
->reserved_pages
[i
];
3855 cnt
= length
- offset
< do_count
? length
- offset
: do_count
;
3856 res
= copy_to_user(ubp
, page_address(page
) + offset
, cnt
);
3860 st_bp
->buffer_bytes
-= cnt
;
3861 st_bp
->read_pointer
+= cnt
;
3865 if (do_count
) /* Should never happen */
3872 /* Move data towards start of buffer */
3873 static void move_buffer_data(struct st_buffer
* st_bp
, int offset
)
3875 int src_seg
, dst_seg
, src_offset
= 0, dst_offset
;
3877 int length
= PAGE_SIZE
<< st_bp
->reserved_page_order
;
3882 total
=st_bp
->buffer_bytes
- offset
;
3883 for (src_seg
=0; src_seg
< st_bp
->frp_segs
; src_seg
++) {
3884 src_offset
= offset
;
3885 if (src_offset
< length
)
3890 st_bp
->buffer_bytes
= st_bp
->read_pointer
= total
;
3891 for (dst_seg
=dst_offset
=0; total
> 0; ) {
3892 struct page
*dpage
= st_bp
->reserved_pages
[dst_seg
];
3893 struct page
*spage
= st_bp
->reserved_pages
[src_seg
];
3895 count
= min(length
- dst_offset
, length
- src_offset
);
3896 memmove(page_address(dpage
) + dst_offset
,
3897 page_address(spage
) + src_offset
, count
);
3898 src_offset
+= count
;
3899 if (src_offset
>= length
) {
3903 dst_offset
+= count
;
3904 if (dst_offset
>= length
) {
3912 /* Validate the options from command line or module parameters */
3913 static void validate_options(void)
3916 st_fixed_buffer_size
= buffer_kbs
* ST_KILOBYTE
;
3917 if (max_sg_segs
>= ST_FIRST_SG
)
3918 st_max_sg_segs
= max_sg_segs
;
3922 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3924 static int __init
st_setup(char *str
)
3926 int i
, len
, ints
[5];
3929 stp
= get_options(str
, ARRAY_SIZE(ints
), ints
);
3932 for (i
= 0; i
< ints
[0] && i
< ARRAY_SIZE(parms
); i
++)
3934 *parms
[i
].val
= ints
[i
+ 1];
3936 while (stp
!= NULL
) {
3937 for (i
= 0; i
< ARRAY_SIZE(parms
); i
++) {
3938 len
= strlen(parms
[i
].name
);
3939 if (!strncmp(stp
, parms
[i
].name
, len
) &&
3940 (*(stp
+ len
) == ':' || *(stp
+ len
) == '=')) {
3943 simple_strtoul(stp
+ len
+ 1, NULL
, 0);
3945 printk(KERN_WARNING
"st: Obsolete parameter %s\n",
3950 if (i
>= ARRAY_SIZE(parms
))
3951 printk(KERN_WARNING
"st: invalid parameter in '%s'\n",
3953 stp
= strchr(stp
, ',');
3964 __setup("st=", st_setup
);
3968 static const struct file_operations st_fops
=
3970 .owner
= THIS_MODULE
,
3973 .unlocked_ioctl
= st_ioctl
,
3974 #ifdef CONFIG_COMPAT
3975 .compat_ioctl
= st_compat_ioctl
,
3979 .release
= st_release
,
3980 .llseek
= noop_llseek
,
3983 static int st_probe(struct device
*dev
)
3985 struct scsi_device
*SDp
= to_scsi_device(dev
);
3986 struct gendisk
*disk
= NULL
;
3987 struct cdev
*cdev
= NULL
;
3988 struct scsi_tape
*tpnt
= NULL
;
3989 struct st_modedef
*STm
;
3990 struct st_partstat
*STps
;
3991 struct st_buffer
*buffer
;
3992 int i
, j
, mode
, dev_num
, error
;
3995 if (SDp
->type
!= TYPE_TAPE
)
3997 if ((stp
= st_incompatible(SDp
))) {
3998 sdev_printk(KERN_INFO
, SDp
, "Found incompatible tape\n");
3999 printk(KERN_INFO
"st: The suggested driver is %s.\n", stp
);
4003 i
= queue_max_segments(SDp
->request_queue
);
4004 if (st_max_sg_segs
< i
)
4006 buffer
= new_tape_buffer((SDp
->host
)->unchecked_isa_dma
, i
);
4007 if (buffer
== NULL
) {
4009 "st: Can't allocate new tape buffer. Device not attached.\n");
4013 disk
= alloc_disk(1);
4015 printk(KERN_ERR
"st: out of memory. Device not attached.\n");
4016 goto out_buffer_free
;
4019 write_lock(&st_dev_arr_lock
);
4020 if (st_nr_dev
>= st_dev_max
) {
4021 struct scsi_tape
**tmp_da
;
4024 tmp_dev_max
= max(st_nr_dev
* 2, 8);
4025 if (tmp_dev_max
> ST_MAX_TAPES
)
4026 tmp_dev_max
= ST_MAX_TAPES
;
4027 if (tmp_dev_max
<= st_nr_dev
) {
4028 write_unlock(&st_dev_arr_lock
);
4029 printk(KERN_ERR
"st: Too many tape devices (max. %d).\n",
4034 tmp_da
= kzalloc(tmp_dev_max
* sizeof(struct scsi_tape
*), GFP_ATOMIC
);
4035 if (tmp_da
== NULL
) {
4036 write_unlock(&st_dev_arr_lock
);
4037 printk(KERN_ERR
"st: Can't extend device array.\n");
4041 if (scsi_tapes
!= NULL
) {
4042 memcpy(tmp_da
, scsi_tapes
,
4043 st_dev_max
* sizeof(struct scsi_tape
*));
4046 scsi_tapes
= tmp_da
;
4048 st_dev_max
= tmp_dev_max
;
4051 for (i
= 0; i
< st_dev_max
; i
++)
4052 if (scsi_tapes
[i
] == NULL
)
4054 if (i
>= st_dev_max
)
4055 panic("scsi_devices corrupt (st)");
4057 tpnt
= kzalloc(sizeof(struct scsi_tape
), GFP_ATOMIC
);
4059 write_unlock(&st_dev_arr_lock
);
4060 printk(KERN_ERR
"st: Can't allocate device descriptor.\n");
4063 kref_init(&tpnt
->kref
);
4065 sprintf(disk
->disk_name
, "st%d", i
);
4066 disk
->private_data
= &tpnt
->driver
;
4067 disk
->queue
= SDp
->request_queue
;
4068 tpnt
->driver
= &st_template
;
4069 scsi_tapes
[i
] = tpnt
;
4073 if (SDp
->scsi_level
<= 2)
4074 tpnt
->tape_type
= MT_ISSCSI1
;
4076 tpnt
->tape_type
= MT_ISSCSI2
;
4078 tpnt
->buffer
= buffer
;
4079 tpnt
->buffer
->last_SRpnt
= NULL
;
4084 tpnt
->drv_buffer
= 1; /* Try buffering if no mode sense */
4085 tpnt
->restr_dma
= (SDp
->host
)->unchecked_isa_dma
;
4086 tpnt
->use_pf
= (SDp
->scsi_level
>= SCSI_2
);
4088 tpnt
->do_auto_lock
= ST_AUTO_LOCK
;
4089 tpnt
->can_bsr
= (SDp
->scsi_level
> 2 ? 1 : ST_IN_FILE_POS
); /* BSR mandatory in SCSI3 */
4090 tpnt
->can_partitions
= 0;
4091 tpnt
->two_fm
= ST_TWO_FM
;
4092 tpnt
->fast_mteom
= ST_FAST_MTEOM
;
4093 tpnt
->scsi2_logical
= ST_SCSI2LOGICAL
;
4094 tpnt
->sili
= ST_SILI
;
4095 tpnt
->immediate
= ST_NOWAIT
;
4096 tpnt
->default_drvbuffer
= 0xff; /* No forced buffering */
4097 tpnt
->partition
= 0;
4098 tpnt
->new_partition
= 0;
4099 tpnt
->nbr_partitions
= 0;
4100 blk_queue_rq_timeout(tpnt
->device
->request_queue
, ST_TIMEOUT
);
4101 tpnt
->long_timeout
= ST_LONG_TIMEOUT
;
4102 tpnt
->try_dio
= try_direct_io
&& !SDp
->host
->unchecked_isa_dma
;
4104 for (i
= 0; i
< ST_NBR_MODES
; i
++) {
4105 STm
= &(tpnt
->modes
[i
]);
4107 STm
->sysv
= ST_SYSV
;
4108 STm
->defaults_for_writes
= 0;
4109 STm
->do_async_writes
= ST_ASYNC_WRITES
;
4110 STm
->do_buffer_writes
= ST_BUFFER_WRITES
;
4111 STm
->do_read_ahead
= ST_READ_AHEAD
;
4112 STm
->default_compression
= ST_DONT_TOUCH
;
4113 STm
->default_blksize
= (-1); /* No forced size */
4114 STm
->default_density
= (-1); /* No forced density */
4117 for (i
= 0; i
< ST_NBR_PARTITIONS
; i
++) {
4118 STps
= &(tpnt
->ps
[i
]);
4120 STps
->eof
= ST_NOEOF
;
4122 STps
->last_block_valid
= 0;
4123 STps
->drv_block
= (-1);
4124 STps
->drv_file
= (-1);
4127 tpnt
->current_mode
= 0;
4128 tpnt
->modes
[0].defined
= 1;
4130 tpnt
->density_changed
= tpnt
->compression_changed
=
4131 tpnt
->blksize_changed
= 0;
4132 mutex_init(&tpnt
->lock
);
4135 write_unlock(&st_dev_arr_lock
);
4137 for (mode
= 0; mode
< ST_NBR_MODES
; ++mode
) {
4138 STm
= &(tpnt
->modes
[mode
]);
4139 for (j
=0; j
< 2; j
++) {
4140 cdev
= cdev_alloc();
4143 "st%d: out of memory. Device not attached.\n",
4147 cdev
->owner
= THIS_MODULE
;
4148 cdev
->ops
= &st_fops
;
4150 error
= cdev_add(cdev
,
4151 MKDEV(SCSI_TAPE_MAJOR
, TAPE_MINOR(dev_num
, mode
, j
)),
4154 printk(KERN_ERR
"st%d: Can't add %s-rewind mode %d\n",
4155 dev_num
, j
? "non" : "auto", mode
);
4156 printk(KERN_ERR
"st%d: Device not attached.\n", dev_num
);
4159 STm
->cdevs
[j
] = cdev
;
4162 error
= do_create_class_files(tpnt
, dev_num
, mode
);
4166 scsi_autopm_put_device(SDp
);
4168 sdev_printk(KERN_NOTICE
, SDp
,
4169 "Attached scsi tape %s\n", tape_name(tpnt
));
4170 sdev_printk(KERN_INFO
, SDp
, "%s: try direct i/o: %s (alignment %d B)\n",
4171 tape_name(tpnt
), tpnt
->try_dio
? "yes" : "no",
4172 queue_dma_alignment(SDp
->request_queue
) + 1);
4177 for (mode
=0; mode
< ST_NBR_MODES
; mode
++) {
4178 STm
= &(tpnt
->modes
[mode
]);
4179 sysfs_remove_link(&tpnt
->device
->sdev_gendev
.kobj
,
4181 for (j
=0; j
< 2; j
++) {
4182 if (STm
->cdevs
[j
]) {
4183 if (cdev
== STm
->cdevs
[j
])
4185 device_destroy(st_sysfs_class
,
4186 MKDEV(SCSI_TAPE_MAJOR
,
4187 TAPE_MINOR(i
, mode
, j
)));
4188 cdev_del(STm
->cdevs
[j
]);
4194 write_lock(&st_dev_arr_lock
);
4195 scsi_tapes
[dev_num
] = NULL
;
4197 write_unlock(&st_dev_arr_lock
);
4208 static int st_remove(struct device
*dev
)
4210 struct scsi_device
*SDp
= to_scsi_device(dev
);
4211 struct scsi_tape
*tpnt
;
4214 scsi_autopm_get_device(SDp
);
4215 write_lock(&st_dev_arr_lock
);
4216 for (i
= 0; i
< st_dev_max
; i
++) {
4217 tpnt
= scsi_tapes
[i
];
4218 if (tpnt
!= NULL
&& tpnt
->device
== SDp
) {
4219 scsi_tapes
[i
] = NULL
;
4221 write_unlock(&st_dev_arr_lock
);
4222 sysfs_remove_link(&tpnt
->device
->sdev_gendev
.kobj
,
4224 for (mode
= 0; mode
< ST_NBR_MODES
; ++mode
) {
4225 for (j
=0; j
< 2; j
++) {
4226 device_destroy(st_sysfs_class
,
4227 MKDEV(SCSI_TAPE_MAJOR
,
4228 TAPE_MINOR(i
, mode
, j
)));
4229 cdev_del(tpnt
->modes
[mode
].cdevs
[j
]);
4230 tpnt
->modes
[mode
].cdevs
[j
] = NULL
;
4234 mutex_lock(&st_ref_mutex
);
4235 kref_put(&tpnt
->kref
, scsi_tape_release
);
4236 mutex_unlock(&st_ref_mutex
);
4241 write_unlock(&st_dev_arr_lock
);
4246 * scsi_tape_release - Called to free the Scsi_Tape structure
4247 * @kref: pointer to embedded kref
4249 * st_ref_mutex must be held entering this routine. Because it is
4250 * called on last put, you should always use the scsi_tape_get()
4251 * scsi_tape_put() helpers which manipulate the semaphore directly
4252 * and never do a direct kref_put().
4254 static void scsi_tape_release(struct kref
*kref
)
4256 struct scsi_tape
*tpnt
= to_scsi_tape(kref
);
4257 struct gendisk
*disk
= tpnt
->disk
;
4259 tpnt
->device
= NULL
;
4262 normalize_buffer(tpnt
->buffer
);
4263 kfree(tpnt
->buffer
->reserved_pages
);
4264 kfree(tpnt
->buffer
);
4267 disk
->private_data
= NULL
;
4273 static int __init
init_st(void)
4279 printk(KERN_INFO
"st: Version %s, fixed bufsize %d, s/g segs %d\n",
4280 verstr
, st_fixed_buffer_size
, st_max_sg_segs
);
4282 st_sysfs_class
= class_create(THIS_MODULE
, "scsi_tape");
4283 if (IS_ERR(st_sysfs_class
)) {
4284 printk(KERN_ERR
"Unable create sysfs class for SCSI tapes\n");
4285 return PTR_ERR(st_sysfs_class
);
4288 err
= register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR
, 0),
4289 ST_MAX_TAPE_ENTRIES
, "st");
4291 printk(KERN_ERR
"Unable to get major %d for SCSI tapes\n",
4296 err
= scsi_register_driver(&st_template
.gendrv
);
4300 err
= do_create_sysfs_files();
4307 scsi_unregister_driver(&st_template
.gendrv
);
4309 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR
, 0),
4310 ST_MAX_TAPE_ENTRIES
);
4312 class_destroy(st_sysfs_class
);
4316 static void __exit
exit_st(void)
4318 do_remove_sysfs_files();
4319 scsi_unregister_driver(&st_template
.gendrv
);
4320 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR
, 0),
4321 ST_MAX_TAPE_ENTRIES
);
4322 class_destroy(st_sysfs_class
);
4324 printk(KERN_INFO
"st: Unloaded.\n");
4327 module_init(init_st
);
4328 module_exit(exit_st
);
4331 /* The sysfs driver interface. Read-only at the moment */
4332 static ssize_t
st_try_direct_io_show(struct device_driver
*ddp
, char *buf
)
4334 return snprintf(buf
, PAGE_SIZE
, "%d\n", try_direct_io
);
4336 static DRIVER_ATTR(try_direct_io
, S_IRUGO
, st_try_direct_io_show
, NULL
);
4338 static ssize_t
st_fixed_buffer_size_show(struct device_driver
*ddp
, char *buf
)
4340 return snprintf(buf
, PAGE_SIZE
, "%d\n", st_fixed_buffer_size
);
4342 static DRIVER_ATTR(fixed_buffer_size
, S_IRUGO
, st_fixed_buffer_size_show
, NULL
);
4344 static ssize_t
st_max_sg_segs_show(struct device_driver
*ddp
, char *buf
)
4346 return snprintf(buf
, PAGE_SIZE
, "%d\n", st_max_sg_segs
);
4348 static DRIVER_ATTR(max_sg_segs
, S_IRUGO
, st_max_sg_segs_show
, NULL
);
4350 static ssize_t
st_version_show(struct device_driver
*ddd
, char *buf
)
4352 return snprintf(buf
, PAGE_SIZE
, "[%s]\n", verstr
);
4354 static DRIVER_ATTR(version
, S_IRUGO
, st_version_show
, NULL
);
4356 static int do_create_sysfs_files(void)
4358 struct device_driver
*sysfs
= &st_template
.gendrv
;
4361 err
= driver_create_file(sysfs
, &driver_attr_try_direct_io
);
4364 err
= driver_create_file(sysfs
, &driver_attr_fixed_buffer_size
);
4366 goto err_try_direct_io
;
4367 err
= driver_create_file(sysfs
, &driver_attr_max_sg_segs
);
4369 goto err_attr_fixed_buf
;
4370 err
= driver_create_file(sysfs
, &driver_attr_version
);
4372 goto err_attr_max_sg
;
4377 driver_remove_file(sysfs
, &driver_attr_max_sg_segs
);
4379 driver_remove_file(sysfs
, &driver_attr_fixed_buffer_size
);
4381 driver_remove_file(sysfs
, &driver_attr_try_direct_io
);
4385 static void do_remove_sysfs_files(void)
4387 struct device_driver
*sysfs
= &st_template
.gendrv
;
4389 driver_remove_file(sysfs
, &driver_attr_version
);
4390 driver_remove_file(sysfs
, &driver_attr_max_sg_segs
);
4391 driver_remove_file(sysfs
, &driver_attr_fixed_buffer_size
);
4392 driver_remove_file(sysfs
, &driver_attr_try_direct_io
);
4396 /* The sysfs simple class interface */
4398 st_defined_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4400 struct st_modedef
*STm
= dev_get_drvdata(dev
);
4403 l
= snprintf(buf
, PAGE_SIZE
, "%d\n", STm
->defined
);
4407 DEVICE_ATTR(defined
, S_IRUGO
, st_defined_show
, NULL
);
4410 st_defblk_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4412 struct st_modedef
*STm
= dev_get_drvdata(dev
);
4415 l
= snprintf(buf
, PAGE_SIZE
, "%d\n", STm
->default_blksize
);
4419 DEVICE_ATTR(default_blksize
, S_IRUGO
, st_defblk_show
, NULL
);
4422 st_defdensity_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4424 struct st_modedef
*STm
= dev_get_drvdata(dev
);
4428 fmt
= STm
->default_density
>= 0 ? "0x%02x\n" : "%d\n";
4429 l
= snprintf(buf
, PAGE_SIZE
, fmt
, STm
->default_density
);
4433 DEVICE_ATTR(default_density
, S_IRUGO
, st_defdensity_show
, NULL
);
4436 st_defcompression_show(struct device
*dev
, struct device_attribute
*attr
,
4439 struct st_modedef
*STm
= dev_get_drvdata(dev
);
4442 l
= snprintf(buf
, PAGE_SIZE
, "%d\n", STm
->default_compression
- 1);
4446 DEVICE_ATTR(default_compression
, S_IRUGO
, st_defcompression_show
, NULL
);
4449 st_options_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4451 struct st_modedef
*STm
= dev_get_drvdata(dev
);
4452 struct scsi_tape
*STp
;
4456 for (i
=0; i
< st_dev_max
; i
++) {
4457 for (j
=0; j
< ST_NBR_MODES
; j
++)
4458 if (&scsi_tapes
[i
]->modes
[j
] == STm
)
4460 if (j
< ST_NBR_MODES
)
4463 if (i
== st_dev_max
)
4464 return 0; /* should never happen */
4466 STp
= scsi_tapes
[i
];
4468 options
= STm
->do_buffer_writes
? MT_ST_BUFFER_WRITES
: 0;
4469 options
|= STm
->do_async_writes
? MT_ST_ASYNC_WRITES
: 0;
4470 options
|= STm
->do_read_ahead
? MT_ST_READ_AHEAD
: 0;
4471 DEB( options
|= debugging
? MT_ST_DEBUGGING
: 0 );
4472 options
|= STp
->two_fm
? MT_ST_TWO_FM
: 0;
4473 options
|= STp
->fast_mteom
? MT_ST_FAST_MTEOM
: 0;
4474 options
|= STm
->defaults_for_writes
? MT_ST_DEF_WRITES
: 0;
4475 options
|= STp
->can_bsr
? MT_ST_CAN_BSR
: 0;
4476 options
|= STp
->omit_blklims
? MT_ST_NO_BLKLIMS
: 0;
4477 options
|= STp
->can_partitions
? MT_ST_CAN_PARTITIONS
: 0;
4478 options
|= STp
->scsi2_logical
? MT_ST_SCSI2LOGICAL
: 0;
4479 options
|= STm
->sysv
? MT_ST_SYSV
: 0;
4480 options
|= STp
->immediate
? MT_ST_NOWAIT
: 0;
4481 options
|= STp
->sili
? MT_ST_SILI
: 0;
4483 l
= snprintf(buf
, PAGE_SIZE
, "0x%08x\n", options
);
4487 DEVICE_ATTR(options
, S_IRUGO
, st_options_show
, NULL
);
4489 static int do_create_class_files(struct scsi_tape
*STp
, int dev_num
, int mode
)
4493 struct device
*st_class_member
;
4495 for (rew
=0; rew
< 2; rew
++) {
4496 /* Make sure that the minor numbers corresponding to the four
4497 first modes always get the same names */
4498 i
= mode
<< (4 - ST_NBR_MODE_BITS
);
4499 snprintf(name
, 10, "%s%s%s", rew
? "n" : "",
4500 STp
->disk
->disk_name
, st_formats
[i
]);
4502 device_create(st_sysfs_class
, &STp
->device
->sdev_gendev
,
4503 MKDEV(SCSI_TAPE_MAJOR
,
4504 TAPE_MINOR(dev_num
, mode
, rew
)),
4505 &STp
->modes
[mode
], "%s", name
);
4506 if (IS_ERR(st_class_member
)) {
4507 printk(KERN_WARNING
"st%d: device_create failed\n",
4509 error
= PTR_ERR(st_class_member
);
4513 error
= device_create_file(st_class_member
,
4515 if (error
) goto out
;
4516 error
= device_create_file(st_class_member
,
4517 &dev_attr_default_blksize
);
4518 if (error
) goto out
;
4519 error
= device_create_file(st_class_member
,
4520 &dev_attr_default_density
);
4521 if (error
) goto out
;
4522 error
= device_create_file(st_class_member
,
4523 &dev_attr_default_compression
);
4524 if (error
) goto out
;
4525 error
= device_create_file(st_class_member
,
4527 if (error
) goto out
;
4529 if (mode
== 0 && rew
== 0) {
4530 error
= sysfs_create_link(&STp
->device
->sdev_gendev
.kobj
,
4531 &st_class_member
->kobj
,
4535 "st%d: Can't create sysfs link from SCSI device.\n",
4548 /* The following functions may be useful for a larger audience. */
4549 static int sgl_map_user_pages(struct st_buffer
*STbp
,
4550 const unsigned int max_pages
, unsigned long uaddr
,
4551 size_t count
, int rw
)
4553 unsigned long end
= (uaddr
+ count
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
4554 unsigned long start
= uaddr
>> PAGE_SHIFT
;
4555 const int nr_pages
= end
- start
;
4557 struct page
**pages
;
4558 struct rq_map_data
*mdata
= &STbp
->map_data
;
4560 /* User attempted Overflow! */
4561 if ((uaddr
+ count
) < uaddr
)
4565 if (nr_pages
> max_pages
)
4572 if ((pages
= kmalloc(max_pages
* sizeof(*pages
), GFP_KERNEL
)) == NULL
)
4575 /* Try to fault in all of the necessary pages */
4576 down_read(¤t
->mm
->mmap_sem
);
4577 /* rw==READ means read from drive, write into memory area */
4578 res
= get_user_pages(
4584 0, /* don't force */
4587 up_read(¤t
->mm
->mmap_sem
);
4589 /* Errors and no page mapped should return here */
4593 for (i
=0; i
< nr_pages
; i
++) {
4594 /* FIXME: flush superflous for rw==READ,
4595 * probably wrong function for rw==WRITE
4597 flush_dcache_page(pages
[i
]);
4600 mdata
->offset
= uaddr
& ~PAGE_MASK
;
4601 STbp
->mapped_pages
= pages
;
4606 for (j
=0; j
< res
; j
++)
4607 page_cache_release(pages
[j
]);
4615 /* And unmap them... */
4616 static int sgl_unmap_user_pages(struct st_buffer
*STbp
,
4617 const unsigned int nr_pages
, int dirtied
)
4621 for (i
=0; i
< nr_pages
; i
++) {
4622 struct page
*page
= STbp
->mapped_pages
[i
];
4626 /* FIXME: cache flush missing for rw==READ
4627 * FIXME: call the correct reference counting function
4629 page_cache_release(page
);
4631 kfree(STbp
->mapped_pages
);
4632 STbp
->mapped_pages
= NULL
;