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 - 2008 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 = "20080504";
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/errno.h>
31 #include <linux/mtio.h>
32 #include <linux/cdrom.h>
33 #include <linux/ioctl.h>
34 #include <linux/fcntl.h>
35 #include <linux/spinlock.h>
36 #include <linux/blkdev.h>
37 #include <linux/moduleparam.h>
38 #include <linux/cdev.h>
39 #include <linux/delay.h>
40 #include <linux/mutex.h>
41 #include <linux/smp_lock.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 int buffer_kbs;
79 static int max_sg_segs;
80 static int try_direct_io = TRY_DIRECT_IO;
81 static int try_rdio = 1;
82 static int try_wdio = 1;
84 static int st_dev_max;
87 static struct class *st_sysfs_class;
89 MODULE_AUTHOR("Kai Makisara");
90 MODULE_DESCRIPTION("SCSI tape (st) driver");
91 MODULE_LICENSE("GPL");
92 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
93 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
95 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
96 * of sysfs parameters (which module_param doesn't yet support).
97 * Sysfs parameters defined explicitly later.
99 module_param_named(buffer_kbs, buffer_kbs, int, 0);
100 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
101 module_param_named(max_sg_segs, max_sg_segs, int, 0);
102 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
103 module_param_named(try_direct_io, try_direct_io, int, 0);
104 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
106 /* Extra parameters for testing */
107 module_param_named(try_rdio, try_rdio, int, 0);
108 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
109 module_param_named(try_wdio, try_wdio, int, 0);
110 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
113 static int write_threshold_kbs; /* retained for compatibility */
114 static struct st_dev_parm {
117 } parms[] __initdata = {
119 "buffer_kbs", &buffer_kbs
121 { /* Retained for compatibility with 2.4 */
122 "write_threshold_kbs", &write_threshold_kbs
128 "try_direct_io", &try_direct_io
133 /* Restrict the number of modes so that names for all are assigned */
134 #if ST_NBR_MODES > 16
135 #error "Maximum number of modes is 16"
137 /* Bit reversed order to get same names for same minors with all
139 static const char *st_formats[] = {
140 "", "r", "k", "s", "l", "t", "o", "u",
141 "m", "v", "p", "x", "a", "y", "q", "z"};
143 /* The default definitions have been moved to st_options.h */
145 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
147 /* The buffer size should fit into the 24 bits for length in the
148 6-byte SCSI read and write commands. */
149 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
150 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
153 static int debugging = DEBUG;
155 #define MAX_RETRIES 0
156 #define MAX_WRITE_RETRIES 0
157 #define MAX_READY_RETRIES 0
158 #define NO_TAPE NOT_READY
160 #define ST_TIMEOUT (900 * HZ)
161 #define ST_LONG_TIMEOUT (14000 * HZ)
163 /* Remove mode bits and auto-rewind bit (7) */
164 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
165 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
166 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
168 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
169 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
170 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
172 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
174 #define SET_DENS_AND_BLK 0x10001
176 static DEFINE_RWLOCK(st_dev_arr_lock);
178 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
179 static int st_max_sg_segs = ST_MAX_SG;
181 static struct scsi_tape **scsi_tapes = NULL;
183 static int modes_defined;
185 static struct st_buffer *new_tape_buffer(int, int, int);
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);
192 static void buf_to_sg(struct st_buffer *, unsigned int);
194 static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
195 unsigned long, size_t, int);
196 static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
198 static int st_probe(struct device *);
199 static int st_remove(struct device *);
201 static int do_create_sysfs_files(void);
202 static void do_remove_sysfs_files(void);
203 static int do_create_class_files(struct scsi_tape *, int, int);
205 static struct scsi_driver st_template = {
206 .owner = THIS_MODULE,
214 static int st_compression(struct scsi_tape *, int);
216 static int find_partition(struct scsi_tape *);
217 static int switch_partition(struct scsi_tape *);
219 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
221 static void scsi_tape_release(struct kref *);
223 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
225 static DEFINE_MUTEX(st_ref_mutex);
228 #include "osst_detect.h"
229 #ifndef SIGS_FROM_OSST
230 #define SIGS_FROM_OSST \
231 {"OnStream", "SC-", "", "osst"}, \
232 {"OnStream", "DI-", "", "osst"}, \
233 {"OnStream", "DP-", "", "osst"}, \
234 {"OnStream", "USB", "", "osst"}, \
235 {"OnStream", "FW-", "", "osst"}
238 static struct scsi_tape *scsi_tape_get(int dev)
240 struct scsi_tape *STp = NULL;
242 mutex_lock(&st_ref_mutex);
243 write_lock(&st_dev_arr_lock);
245 if (dev < st_dev_max && scsi_tapes != NULL)
246 STp = scsi_tapes[dev];
249 kref_get(&STp->kref);
254 if (scsi_device_get(STp->device))
260 kref_put(&STp->kref, scsi_tape_release);
263 write_unlock(&st_dev_arr_lock);
264 mutex_unlock(&st_ref_mutex);
268 static void scsi_tape_put(struct scsi_tape *STp)
270 struct scsi_device *sdev = STp->device;
272 mutex_lock(&st_ref_mutex);
273 kref_put(&STp->kref, scsi_tape_release);
274 scsi_device_put(sdev);
275 mutex_unlock(&st_ref_mutex);
278 struct st_reject_data {
282 char *driver_hint; /* Name of the correct driver, NULL if unknown */
285 static struct st_reject_data reject_list[] = {
286 /* {"XXX", "Yy-", "", NULL}, example */
290 /* If the device signature is on the list of incompatible drives, the
291 function returns a pointer to the name of the correct driver (if known) */
292 static char * st_incompatible(struct scsi_device* SDp)
294 struct st_reject_data *rp;
296 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
297 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
298 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
299 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
301 return rp->driver_hint;
309 static inline char *tape_name(struct scsi_tape *tape)
311 return tape->disk->disk_name;
315 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
318 const u8 *sense = SRpnt->sense;
320 s->have_sense = scsi_normalize_sense(SRpnt->sense,
321 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
327 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
328 switch (sense[0] & 0x7f) {
333 s->flags = sense[2] & 0xe0;
339 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
340 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
347 /* Convert the result to success code */
348 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
350 int result = SRpnt->result;
352 DEB(const char *stp;)
353 char *name = tape_name(STp);
354 struct st_cmdstatus *cmdstatp;
359 cmdstatp = &STp->buffer->cmdstat;
360 st_analyze_sense(SRpnt, cmdstatp);
362 if (cmdstatp->have_sense)
363 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
369 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
371 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
372 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
373 if (cmdstatp->have_sense)
374 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
376 if (!debugging) { /* Abnormal conditions for tape */
377 if (!cmdstatp->have_sense)
379 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
380 name, result, suggestion(result),
381 driver_byte(result) & DRIVER_MASK, host_byte(result));
382 else if (cmdstatp->have_sense &&
384 scode != RECOVERED_ERROR &&
385 /* scode != UNIT_ATTENTION && */
386 scode != BLANK_CHECK &&
387 scode != VOLUME_OVERFLOW &&
388 SRpnt->cmd[0] != MODE_SENSE &&
389 SRpnt->cmd[0] != TEST_UNIT_READY) {
391 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
395 if (cmdstatp->fixed_format &&
396 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
397 if (STp->cln_sense_value)
398 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
399 STp->cln_sense_mask) == STp->cln_sense_value);
401 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
402 STp->cln_sense_mask) != 0);
404 if (cmdstatp->have_sense &&
405 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
406 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
408 STp->pos_unknown |= STp->device->was_reset;
410 if (cmdstatp->have_sense &&
411 scode == RECOVERED_ERROR
412 #if ST_RECOVERED_WRITE_FATAL
413 && SRpnt->cmd[0] != WRITE_6
414 && SRpnt->cmd[0] != WRITE_FILEMARKS
417 STp->recover_count++;
422 if (SRpnt->cmd[0] == READ_6)
424 else if (SRpnt->cmd[0] == WRITE_6)
428 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
432 if (cmdstatp->flags == 0)
439 /* Wakeup from interrupt */
440 static void st_sleep_done(void *data, char *sense, int result, int resid)
442 struct st_request *SRpnt = data;
443 struct scsi_tape *STp = SRpnt->stp;
445 memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
446 (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result;
447 (STp->buffer)->cmdstat.residual = resid;
448 DEB( STp->write_pending = 0; )
451 complete(SRpnt->waiting);
454 static struct st_request *st_allocate_request(struct scsi_tape *stp)
456 struct st_request *streq;
458 streq = kzalloc(sizeof(*streq), GFP_KERNEL);
462 DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n",
464 if (signal_pending(current))
465 stp->buffer->syscall_result = -EINTR;
467 stp->buffer->syscall_result = -EBUSY;
473 static void st_release_request(struct st_request *streq)
478 static void st_scsi_execute_end(struct request *req, int uptodate)
480 struct st_request *SRpnt = req->end_io_data;
481 struct scsi_tape *STp = SRpnt->stp;
483 STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
484 STp->buffer->cmdstat.residual = req->data_len;
487 complete(SRpnt->waiting);
489 blk_rq_unmap_user(SRpnt->bio);
490 __blk_put_request(req->q, req);
493 static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
494 int data_direction, void *buffer, unsigned bufflen,
495 int timeout, int retries)
498 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
500 int write = (data_direction == DMA_TO_DEVICE);
502 req = blk_get_request(SRpnt->stp->device->request_queue, write,
505 return DRIVER_ERROR << 24;
507 req->cmd_type = REQ_TYPE_BLOCK_PC;
508 req->cmd_flags |= REQ_QUIET;
510 mdata->null_mapped = 1;
512 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen, GFP_KERNEL);
514 blk_put_request(req);
515 return DRIVER_ERROR << 24;
518 SRpnt->bio = req->bio;
519 req->cmd_len = COMMAND_SIZE(cmd[0]);
520 memset(req->cmd, 0, BLK_MAX_CDB);
521 memcpy(req->cmd, cmd, req->cmd_len);
522 req->sense = SRpnt->sense;
524 req->timeout = timeout;
525 req->retries = retries;
526 req->end_io_data = SRpnt;
528 blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end);
532 /* Do the scsi command. Waits until command performed if do_wait is true.
533 Otherwise write_behind_check() is used to check that the command
535 static struct st_request *
536 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
537 int bytes, int direction, int timeout, int retries, int do_wait)
539 struct completion *waiting;
541 /* if async, make sure there's no command outstanding */
542 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
543 printk(KERN_ERR "%s: Async command already active.\n",
545 if (signal_pending(current))
546 (STp->buffer)->syscall_result = (-EINTR);
548 (STp->buffer)->syscall_result = (-EBUSY);
553 SRpnt = st_allocate_request(STp);
558 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
559 which IO is outstanding. It's nulled out when the IO completes. */
561 (STp->buffer)->last_SRpnt = SRpnt;
563 waiting = &STp->wait;
564 init_completion(waiting);
565 SRpnt->waiting = waiting;
567 if (!STp->buffer->do_dio)
568 buf_to_sg(STp->buffer, bytes);
570 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
571 STp->buffer->cmdstat.have_sense = 0;
572 STp->buffer->syscall_result = 0;
574 if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction,
575 &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
576 timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) {
577 /* could not allocate the buffer or request was too large */
578 (STp->buffer)->syscall_result = (-EBUSY);
579 (STp->buffer)->last_SRpnt = NULL;
582 wait_for_completion(waiting);
583 SRpnt->waiting = NULL;
584 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
590 static int st_scsi_kern_execute(struct st_request *streq,
591 const unsigned char *cmd, int data_direction,
592 void *buffer, unsigned bufflen, int timeout,
595 struct scsi_tape *stp = streq->stp;
598 stp->buffer->cmdstat.have_sense = 0;
599 memcpy(streq->cmd, cmd, sizeof(streq->cmd));
601 ret = scsi_execute(stp->device, cmd, data_direction, buffer, bufflen,
602 streq->sense, timeout, retries, 0, &resid);
603 if (driver_byte(ret) & DRIVER_ERROR)
606 stp->buffer->cmdstat.midlevel_result = streq->result = ret;
607 stp->buffer->cmdstat.residual = resid;
608 stp->buffer->syscall_result = st_chk_result(stp, streq);
613 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
614 write has been correct but EOM early warning reached, -EIO if write ended in
615 error or zero if write successful. Asynchronous writes are used only in
616 variable block mode. */
617 static int write_behind_check(struct scsi_tape * STp)
620 struct st_buffer *STbuffer;
621 struct st_partstat *STps;
622 struct st_cmdstatus *cmdstatp;
623 struct st_request *SRpnt;
625 STbuffer = STp->buffer;
626 if (!STbuffer->writing)
630 if (STp->write_pending)
636 wait_for_completion(&(STp->wait));
637 SRpnt = STbuffer->last_SRpnt;
638 STbuffer->last_SRpnt = NULL;
639 SRpnt->waiting = NULL;
641 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
642 st_release_request(SRpnt);
644 STbuffer->buffer_bytes -= STbuffer->writing;
645 STps = &(STp->ps[STp->partition]);
646 if (STps->drv_block >= 0) {
647 if (STp->block_size == 0)
650 STps->drv_block += STbuffer->writing / STp->block_size;
653 cmdstatp = &STbuffer->cmdstat;
654 if (STbuffer->syscall_result) {
656 if (cmdstatp->have_sense && !cmdstatp->deferred &&
657 (cmdstatp->flags & SENSE_EOM) &&
658 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
659 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
660 /* EOM at write-behind, has all data been written? */
661 if (!cmdstatp->remainder_valid ||
662 cmdstatp->uremainder64 == 0)
666 STps->drv_block = -1;
668 STbuffer->writing = 0;
670 DEB(if (debugging && retval)
671 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
672 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
678 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
679 it messes up the block number). */
680 static int cross_eof(struct scsi_tape * STp, int forward)
682 struct st_request *SRpnt;
683 unsigned char cmd[MAX_COMMAND_SIZE];
687 cmd[1] = 0x01; /* Space FileMarks */
692 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
695 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
696 tape_name(STp), forward ? "forward" : "backward"));
698 SRpnt = st_allocate_request(STp);
700 return STp->buffer->syscall_result;
702 ret = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0,
703 STp->device->request_queue->rq_timeout,
708 ret = STp->buffer->syscall_result;
710 if ((STp->buffer)->cmdstat.midlevel_result != 0)
711 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
712 tape_name(STp), forward ? "forward" : "backward");
715 st_release_request(SRpnt);
721 /* Flush the write buffer (never need to write if variable blocksize). */
722 static int st_flush_write_buffer(struct scsi_tape * STp)
726 unsigned char cmd[MAX_COMMAND_SIZE];
727 struct st_request *SRpnt;
728 struct st_partstat *STps;
730 result = write_behind_check(STp);
735 if (STp->dirty == 1) {
737 transfer = STp->buffer->buffer_bytes;
738 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
739 tape_name(STp), transfer));
741 memset(cmd, 0, MAX_COMMAND_SIZE);
744 blks = transfer / STp->block_size;
749 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
750 STp->device->request_queue->rq_timeout,
751 MAX_WRITE_RETRIES, 1);
753 return (STp->buffer)->syscall_result;
755 STps = &(STp->ps[STp->partition]);
756 if ((STp->buffer)->syscall_result != 0) {
757 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
759 if (cmdstatp->have_sense && !cmdstatp->deferred &&
760 (cmdstatp->flags & SENSE_EOM) &&
761 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
762 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
763 (!cmdstatp->remainder_valid ||
764 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
766 (STp->buffer)->buffer_bytes = 0;
767 if (STps->drv_block >= 0)
768 STps->drv_block += blks;
771 printk(KERN_ERR "%s: Error on flush.\n",
773 STps->drv_block = (-1);
777 if (STps->drv_block >= 0)
778 STps->drv_block += blks;
780 (STp->buffer)->buffer_bytes = 0;
782 st_release_request(SRpnt);
789 /* Flush the tape buffer. The tape will be positioned correctly unless
790 seek_next is true. */
791 static int flush_buffer(struct scsi_tape *STp, int seek_next)
793 int backspace, result;
794 struct st_buffer *STbuffer;
795 struct st_partstat *STps;
797 STbuffer = STp->buffer;
800 * If there was a bus reset, block further access
803 if (STp->pos_unknown)
806 if (STp->ready != ST_READY)
808 STps = &(STp->ps[STp->partition]);
809 if (STps->rw == ST_WRITING) /* Writing */
810 return st_flush_write_buffer(STp);
812 if (STp->block_size == 0)
815 backspace = ((STp->buffer)->buffer_bytes +
816 (STp->buffer)->read_pointer) / STp->block_size -
817 ((STp->buffer)->read_pointer + STp->block_size - 1) /
819 (STp->buffer)->buffer_bytes = 0;
820 (STp->buffer)->read_pointer = 0;
823 if (STps->eof == ST_FM_HIT) {
824 result = cross_eof(STp, 0); /* Back over the EOF hit */
826 STps->eof = ST_NOEOF;
828 if (STps->drv_file >= 0)
833 if (!result && backspace > 0)
834 result = st_int_ioctl(STp, MTBSR, backspace);
835 } else if (STps->eof == ST_FM_HIT) {
836 if (STps->drv_file >= 0)
839 STps->eof = ST_NOEOF;
845 /* Set the mode parameters */
846 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
850 char *name = tape_name(STp);
852 if (!STp->density_changed &&
853 STm->default_density >= 0 &&
854 STm->default_density != STp->density) {
855 arg = STm->default_density;
859 arg <<= MT_ST_DENSITY_SHIFT;
860 if (!STp->blksize_changed &&
861 STm->default_blksize >= 0 &&
862 STm->default_blksize != STp->block_size) {
863 arg |= STm->default_blksize;
866 arg |= STp->block_size;
868 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
870 "%s: Can't set default block size to %d bytes and density %x.\n",
871 name, STm->default_blksize, STm->default_density);
879 /* Lock or unlock the drive door. Don't use when st_request allocated. */
880 static int do_door_lock(struct scsi_tape * STp, int do_lock)
883 DEB(char *name = tape_name(STp);)
886 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
887 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
888 do_lock ? "L" : "Unl"));
889 retval = scsi_ioctl(STp->device, cmd, NULL);
891 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
894 STp->door_locked = ST_LOCK_FAILS;
900 /* Set the internal state after reset */
901 static void reset_state(struct scsi_tape *STp)
904 struct st_partstat *STps;
906 STp->pos_unknown = 0;
907 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
908 STps = &(STp->ps[i]);
910 STps->eof = ST_NOEOF;
912 STps->last_block_valid = 0;
913 STps->drv_block = -1;
916 if (STp->can_partitions) {
917 STp->partition = find_partition(STp);
918 if (STp->partition < 0)
920 STp->new_partition = STp->partition;
924 /* Test if the drive is ready. Returns either one of the codes below or a negative system
926 #define CHKRES_READY 0
927 #define CHKRES_NEW_SESSION 1
928 #define CHKRES_NOT_READY 2
929 #define CHKRES_NO_TAPE 3
931 #define MAX_ATTENTIONS 10
933 static int test_ready(struct scsi_tape *STp, int do_wait)
935 int attentions, waits, max_wait, scode;
936 int retval = CHKRES_READY, new_session = 0;
937 unsigned char cmd[MAX_COMMAND_SIZE];
938 struct st_request *SRpnt;
939 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
941 SRpnt = st_allocate_request(STp);
943 return STp->buffer->syscall_result;
945 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
947 for (attentions=waits=0; ; ) {
948 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
949 cmd[0] = TEST_UNIT_READY;
951 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0,
957 if (cmdstatp->have_sense) {
959 scode = cmdstatp->sense_hdr.sense_key;
961 if (scode == UNIT_ATTENTION) { /* New media? */
963 if (attentions < MAX_ATTENTIONS) {
973 if (scode == NOT_READY) {
974 if (waits < max_wait) {
975 if (msleep_interruptible(1000)) {
983 if ((STp->device)->scsi_level >= SCSI_2 &&
984 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
985 retval = CHKRES_NO_TAPE;
987 retval = CHKRES_NOT_READY;
993 retval = (STp->buffer)->syscall_result;
995 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
999 st_release_request(SRpnt);
1005 /* See if the drive is ready and gather information about the tape. Return values:
1006 < 0 negative error code from errno.h
1008 1 drive not ready (possibly no tape)
1010 static int check_tape(struct scsi_tape *STp, struct file *filp)
1012 int i, retval, new_session = 0, do_wait;
1013 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
1014 unsigned short st_flags = filp->f_flags;
1015 struct st_request *SRpnt = NULL;
1016 struct st_modedef *STm;
1017 struct st_partstat *STps;
1018 char *name = tape_name(STp);
1019 struct inode *inode = filp->f_path.dentry->d_inode;
1020 int mode = TAPE_MODE(inode);
1022 STp->ready = ST_READY;
1024 if (mode != STp->current_mode) {
1025 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
1026 name, STp->current_mode, mode));
1028 STp->current_mode = mode;
1030 STm = &(STp->modes[STp->current_mode]);
1032 saved_cleaning = STp->cleaning_req;
1033 STp->cleaning_req = 0;
1035 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
1036 retval = test_ready(STp, do_wait);
1041 if (retval == CHKRES_NEW_SESSION) {
1042 STp->pos_unknown = 0;
1043 STp->partition = STp->new_partition = 0;
1044 if (STp->can_partitions)
1045 STp->nbr_partitions = 1; /* This guess will be updated later
1047 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1048 STps = &(STp->ps[i]);
1050 STps->eof = ST_NOEOF;
1052 STps->last_block_valid = 0;
1053 STps->drv_block = 0;
1059 STp->cleaning_req |= saved_cleaning;
1061 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1062 if (retval == CHKRES_NO_TAPE)
1063 STp->ready = ST_NO_TAPE;
1065 STp->ready = ST_NOT_READY;
1067 STp->density = 0; /* Clear the erroneous "residue" */
1068 STp->write_prot = 0;
1069 STp->block_size = 0;
1070 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1071 STp->partition = STp->new_partition = 0;
1072 STp->door_locked = ST_UNLOCKED;
1073 return CHKRES_NOT_READY;
1077 SRpnt = st_allocate_request(STp);
1079 retval = STp->buffer->syscall_result;
1083 if (STp->omit_blklims)
1084 STp->min_block = STp->max_block = (-1);
1086 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1087 cmd[0] = READ_BLOCK_LIMITS;
1089 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_FROM_DEVICE,
1090 STp->buffer->b_data, 6,
1091 STp->device->request_queue->rq_timeout,
1094 st_release_request(SRpnt);
1098 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1099 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1100 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1101 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1102 (STp->buffer)->b_data[5];
1103 if ( DEB( debugging || ) !STp->inited)
1105 "%s: Block limits %d - %d bytes.\n", name,
1106 STp->min_block, STp->max_block);
1108 STp->min_block = STp->max_block = (-1);
1109 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1114 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1115 cmd[0] = MODE_SENSE;
1118 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_FROM_DEVICE,
1119 STp->buffer->b_data, 12,
1120 STp->device->request_queue->rq_timeout,
1123 st_release_request(SRpnt);
1127 if ((STp->buffer)->syscall_result != 0) {
1128 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1129 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1130 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1131 STp->drv_write_prot = 0;
1133 DEBC(printk(ST_DEB_MSG
1134 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1136 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1137 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1139 if ((STp->buffer)->b_data[3] >= 8) {
1140 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1141 STp->density = (STp->buffer)->b_data[4];
1142 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1143 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1144 DEBC(printk(ST_DEB_MSG
1145 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1146 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1147 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1150 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1152 st_release_request(SRpnt);
1156 if (STp->block_size > 0)
1157 (STp->buffer)->buffer_blocks =
1158 (STp->buffer)->buffer_size / STp->block_size;
1160 (STp->buffer)->buffer_blocks = 1;
1161 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1163 DEBC(printk(ST_DEB_MSG
1164 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1165 STp->block_size, (STp->buffer)->buffer_size,
1166 (STp->buffer)->buffer_blocks));
1168 if (STp->drv_write_prot) {
1169 STp->write_prot = 1;
1171 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1174 ((st_flags & O_ACCMODE) == O_WRONLY ||
1175 (st_flags & O_ACCMODE) == O_RDWR)) {
1181 if (STp->can_partitions && STp->nbr_partitions < 1) {
1182 /* This code is reached when the device is opened for the first time
1183 after the driver has been initialized with tape in the drive and the
1184 partition support has been enabled. */
1185 DEBC(printk(ST_DEB_MSG
1186 "%s: Updating partition number in status.\n", name));
1187 if ((STp->partition = find_partition(STp)) < 0) {
1188 retval = STp->partition;
1191 STp->new_partition = STp->partition;
1192 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1195 if (new_session) { /* Change the drive parameters for the new mode */
1196 STp->density_changed = STp->blksize_changed = 0;
1197 STp->compression_changed = 0;
1198 if (!(STm->defaults_for_writes) &&
1199 (retval = set_mode_densblk(STp, STm)) < 0)
1202 if (STp->default_drvbuffer != 0xff) {
1203 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1205 "%s: Can't set default drive buffering to %d.\n",
1206 name, STp->default_drvbuffer);
1210 return CHKRES_READY;
1217 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1219 static int st_open(struct inode *inode, struct file *filp)
1221 int i, retval = (-EIO);
1222 struct scsi_tape *STp;
1223 struct st_partstat *STps;
1224 int dev = TAPE_NR(inode);
1229 * We really want to do nonseekable_open(inode, filp); here, but some
1230 * versions of tar incorrectly call lseek on tapes and bail out if that
1231 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1233 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1235 if (!(STp = scsi_tape_get(dev))) {
1240 write_lock(&st_dev_arr_lock);
1241 filp->private_data = STp;
1242 name = tape_name(STp);
1245 write_unlock(&st_dev_arr_lock);
1248 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1253 write_unlock(&st_dev_arr_lock);
1254 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1256 if (!scsi_block_when_processing_errors(STp->device)) {
1261 /* See that we have at least a one page buffer available */
1262 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1263 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1265 retval = (-EOVERFLOW);
1269 (STp->buffer)->cleared = 0;
1270 (STp->buffer)->writing = 0;
1271 (STp->buffer)->syscall_result = 0;
1273 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1276 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1277 STps = &(STp->ps[i]);
1280 STp->try_dio_now = STp->try_dio;
1281 STp->recover_count = 0;
1282 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1283 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1285 retval = check_tape(STp, filp);
1288 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1289 retval != CHKRES_READY) {
1290 if (STp->ready == NO_TAPE)
1291 retval = (-ENOMEDIUM);
1300 normalize_buffer(STp->buffer);
1309 /* Flush the tape buffer before close */
1310 static int st_flush(struct file *filp, fl_owner_t id)
1312 int result = 0, result2;
1313 unsigned char cmd[MAX_COMMAND_SIZE];
1314 struct st_request *SRpnt;
1315 struct scsi_tape *STp = filp->private_data;
1316 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1317 struct st_partstat *STps = &(STp->ps[STp->partition]);
1318 char *name = tape_name(STp);
1320 if (file_count(filp) > 1)
1323 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1324 result = st_flush_write_buffer(STp);
1325 if (result != 0 && result != (-ENOSPC))
1329 if (STp->can_partitions &&
1330 (result2 = switch_partition(STp)) < 0) {
1331 DEBC(printk(ST_DEB_MSG
1332 "%s: switch_partition at close failed.\n", name));
1338 DEBC( if (STp->nbr_requests)
1339 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1340 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1342 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1343 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1345 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1346 name, STp->nbr_waits, STp->nbr_finished);
1349 memset(cmd, 0, MAX_COMMAND_SIZE);
1350 cmd[0] = WRITE_FILEMARKS;
1351 cmd[4] = 1 + STp->two_fm;
1353 SRpnt = st_allocate_request(STp);
1355 result = STp->buffer->syscall_result;
1359 result = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0,
1360 STp->device->request_queue->rq_timeout,
1363 st_release_request(SRpnt);
1367 if (STp->buffer->syscall_result == 0 ||
1368 (cmdstatp->have_sense && !cmdstatp->deferred &&
1369 (cmdstatp->flags & SENSE_EOM) &&
1370 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1371 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1372 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1373 /* Write successful at EOM */
1374 st_release_request(SRpnt);
1376 if (STps->drv_file >= 0)
1378 STps->drv_block = 0;
1383 else { /* Write error */
1384 st_release_request(SRpnt);
1386 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1391 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1393 } else if (!STp->rew_at_close) {
1394 STps = &(STp->ps[STp->partition]);
1395 if (!STm->sysv || STps->rw != ST_READING) {
1397 result = flush_buffer(STp, 0);
1398 else if (STps->eof == ST_FM_HIT) {
1399 result = cross_eof(STp, 0);
1401 if (STps->drv_file >= 0)
1403 STps->drv_block = 0;
1406 STps->eof = ST_NOEOF;
1408 } else if ((STps->eof == ST_NOEOF &&
1409 !(result = cross_eof(STp, 1))) ||
1410 STps->eof == ST_FM_HIT) {
1411 if (STps->drv_file >= 0)
1413 STps->drv_block = 0;
1419 if (STp->rew_at_close) {
1420 result2 = st_int_ioctl(STp, MTREW, 1);
1428 /* Close the device and release it. BKL is not needed: this is the only thread
1429 accessing this tape. */
1430 static int st_release(struct inode *inode, struct file *filp)
1433 struct scsi_tape *STp = filp->private_data;
1435 if (STp->door_locked == ST_LOCKED_AUTO)
1436 do_door_lock(STp, 0);
1438 normalize_buffer(STp->buffer);
1439 write_lock(&st_dev_arr_lock);
1441 write_unlock(&st_dev_arr_lock);
1447 /* The checks common to both reading and writing */
1448 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1453 * If we are in the middle of error recovery, don't let anyone
1454 * else try and use this device. Also, if error recovery fails, it
1455 * may try and take the device offline, in which case all further
1456 * access to the device is prohibited.
1458 if (!scsi_block_when_processing_errors(STp->device)) {
1463 if (STp->ready != ST_READY) {
1464 if (STp->ready == ST_NO_TAPE)
1465 retval = (-ENOMEDIUM);
1471 if (! STp->modes[STp->current_mode].defined) {
1478 * If there was a bus reset, block further access
1481 if (STp->pos_unknown) {
1491 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1496 if (STp->can_partitions &&
1497 (retval = switch_partition(STp)) < 0)
1500 if (STp->block_size == 0 && STp->max_block > 0 &&
1501 (count < STp->min_block || count > STp->max_block)) {
1506 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1507 !do_door_lock(STp, 1))
1508 STp->door_locked = ST_LOCKED_AUTO;
1515 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1516 size_t count, int is_read)
1518 int i, bufsize, retval = 0;
1519 struct st_buffer *STbp = STp->buffer;
1522 i = STp->try_dio_now && try_rdio;
1524 i = STp->try_dio_now && try_wdio;
1526 if (i && ((unsigned long)buf & queue_dma_alignment(
1527 STp->device->request_queue)) == 0) {
1528 i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1529 (unsigned long)buf, count, (is_read ? READ : WRITE));
1532 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1535 STbp->do_dio = 0; /* fall back to buffering with any error */
1536 STbp->sg_segs = STbp->do_dio;
1537 STbp->frp_sg_current = 0;
1541 STp->nbr_pages += STbp->do_dio;
1546 DEB( STp->nbr_requests++; )
1548 if (!STbp->do_dio) {
1549 if (STp->block_size)
1550 bufsize = STp->block_size > st_fixed_buffer_size ?
1551 STp->block_size : st_fixed_buffer_size;
1554 /* Make sure that data from previous user is not leaked even if
1555 HBA does not return correct residual */
1556 if (is_read && STp->sili && !STbp->cleared)
1560 if (bufsize > STbp->buffer_size &&
1561 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1562 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1563 tape_name(STp), bufsize);
1564 retval = (-EOVERFLOW);
1567 if (STp->block_size)
1568 STbp->buffer_blocks = bufsize / STp->block_size;
1576 /* Can be called more than once after each setup_buffer() */
1577 static void release_buffering(struct scsi_tape *STp, int is_read)
1579 struct st_buffer *STbp;
1583 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
1592 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1595 ssize_t i, do_count, blks, transfer;
1597 int undone, retry_eot = 0, scode;
1599 unsigned char cmd[MAX_COMMAND_SIZE];
1600 const char __user *b_point;
1601 struct st_request *SRpnt = NULL;
1602 struct scsi_tape *STp = filp->private_data;
1603 struct st_modedef *STm;
1604 struct st_partstat *STps;
1605 struct st_buffer *STbp;
1606 char *name = tape_name(STp);
1608 if (mutex_lock_interruptible(&STp->lock))
1609 return -ERESTARTSYS;
1611 retval = rw_checks(STp, filp, count);
1612 if (retval || count == 0)
1615 /* Write must be integral number of blocks */
1616 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1617 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1623 STm = &(STp->modes[STp->current_mode]);
1624 STps = &(STp->ps[STp->partition]);
1626 if (STp->write_prot) {
1632 if (STps->rw == ST_READING) {
1633 retval = flush_buffer(STp, 0);
1636 STps->rw = ST_WRITING;
1637 } else if (STps->rw != ST_WRITING &&
1638 STps->drv_file == 0 && STps->drv_block == 0) {
1639 if ((retval = set_mode_densblk(STp, STm)) < 0)
1641 if (STm->default_compression != ST_DONT_TOUCH &&
1642 !(STp->compression_changed)) {
1643 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1644 printk(KERN_WARNING "%s: Can't set default compression.\n",
1646 if (modes_defined) {
1655 i = write_behind_check(STp);
1658 STps->eof = ST_EOM_OK;
1660 STps->eof = ST_EOM_ERROR;
1663 if (STps->eof == ST_EOM_OK) {
1664 STps->eof = ST_EOD_1; /* allow next write */
1668 else if (STps->eof == ST_EOM_ERROR) {
1673 /* Check the buffer readability in cases where copy_user might catch
1674 the problems after some tape movement. */
1675 if (STp->block_size != 0 &&
1677 (copy_from_user(&i, buf, 1) != 0 ||
1678 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1683 retval = setup_buffering(STp, buf, count, 0);
1689 memset(cmd, 0, MAX_COMMAND_SIZE);
1691 cmd[1] = (STp->block_size != 0);
1693 STps->rw = ST_WRITING;
1696 while (count > 0 && !retry_eot) {
1702 if (STp->block_size == 0)
1705 do_count = STbp->buffer_blocks * STp->block_size -
1707 if (do_count > count)
1711 i = append_to_buffer(b_point, STbp, do_count);
1718 b_point += do_count;
1720 async_write = STp->block_size == 0 && !STbp->do_dio &&
1721 STm->do_async_writes && STps->eof < ST_EOM_OK;
1723 if (STp->block_size != 0 && STm->do_buffer_writes &&
1724 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1725 STbp->buffer_bytes < STbp->buffer_size) {
1727 /* Don't write a buffer that is not full enough. */
1728 if (!async_write && count == 0)
1733 if (STp->block_size == 0)
1734 blks = transfer = do_count;
1737 blks = STbp->buffer_bytes;
1740 blks /= STp->block_size;
1741 transfer = blks * STp->block_size;
1743 cmd[2] = blks >> 16;
1747 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1748 STp->device->request_queue->rq_timeout,
1749 MAX_WRITE_RETRIES, !async_write);
1751 retval = STbp->syscall_result;
1754 if (async_write && !STbp->syscall_result) {
1755 STbp->writing = transfer;
1756 STp->dirty = !(STbp->writing ==
1757 STbp->buffer_bytes);
1758 SRpnt = NULL; /* Prevent releasing this request! */
1759 DEB( STp->write_pending = 1; )
1763 if (STbp->syscall_result != 0) {
1764 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1766 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1767 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1768 scode = cmdstatp->sense_hdr.sense_key;
1769 if (cmdstatp->remainder_valid)
1770 undone = (int)cmdstatp->uremainder64;
1771 else if (STp->block_size == 0 &&
1772 scode == VOLUME_OVERFLOW)
1776 if (STp->block_size != 0)
1777 undone *= STp->block_size;
1778 if (undone <= do_count) {
1779 /* Only data from this write is not written */
1783 if (STp->block_size)
1784 blks = (transfer - undone) / STp->block_size;
1785 STps->eof = ST_EOM_OK;
1786 /* Continue in fixed block mode if all written
1787 in this request but still something left to write
1788 (retval left to zero)
1790 if (STp->block_size == 0 ||
1791 undone > 0 || count == 0)
1792 retval = (-ENOSPC); /* EOM within current request */
1793 DEBC(printk(ST_DEB_MSG
1794 "%s: EOM with %d bytes unwritten.\n",
1797 /* EOT within data buffered earlier (possible only
1798 in fixed block mode without direct i/o) */
1799 if (!retry_eot && !cmdstatp->deferred &&
1800 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1801 move_buffer_data(STp->buffer, transfer - undone);
1803 if (STps->drv_block >= 0) {
1804 STps->drv_block += (transfer - undone) /
1807 STps->eof = ST_EOM_OK;
1808 DEBC(printk(ST_DEB_MSG
1809 "%s: Retry write of %d bytes at EOM.\n",
1810 name, STp->buffer->buffer_bytes));
1814 /* Either error within data buffered by driver or
1817 blks = do_count = 0;
1818 STps->eof = ST_EOM_ERROR;
1819 STps->drv_block = (-1); /* Too cautious? */
1820 retval = (-EIO); /* EOM for old data */
1821 DEBC(printk(ST_DEB_MSG
1822 "%s: EOM with lost data.\n",
1828 STps->drv_block = (-1); /* Too cautious? */
1829 retval = STbp->syscall_result;
1834 if (STps->drv_block >= 0) {
1835 if (STp->block_size == 0)
1836 STps->drv_block += (do_count > 0);
1838 STps->drv_block += blks;
1841 STbp->buffer_bytes = 0;
1844 if (retval || retry_eot) {
1846 retval = total - count;
1851 if (STps->eof == ST_EOD_1)
1852 STps->eof = ST_EOM_OK;
1853 else if (STps->eof != ST_EOM_OK)
1854 STps->eof = ST_NOEOF;
1855 retval = total - count;
1859 st_release_request(SRpnt);
1860 release_buffering(STp, 0);
1861 mutex_unlock(&STp->lock);
1866 /* Read data from the tape. Returns zero in the normal case, one if the
1867 eof status has changed, and the negative error code in case of a
1868 fatal error. Otherwise updates the buffer and the eof state.
1870 Does release user buffer mapping if it is set.
1872 static long read_tape(struct scsi_tape *STp, long count,
1873 struct st_request ** aSRpnt)
1875 int transfer, blks, bytes;
1876 unsigned char cmd[MAX_COMMAND_SIZE];
1877 struct st_request *SRpnt;
1878 struct st_modedef *STm;
1879 struct st_partstat *STps;
1880 struct st_buffer *STbp;
1882 char *name = tape_name(STp);
1887 STm = &(STp->modes[STp->current_mode]);
1888 STps = &(STp->ps[STp->partition]);
1889 if (STps->eof == ST_FM_HIT)
1893 if (STp->block_size == 0)
1894 blks = bytes = count;
1896 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1897 blks = (STp->buffer)->buffer_blocks;
1898 bytes = blks * STp->block_size;
1901 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1902 bytes = (STp->buffer)->buffer_size;
1903 blks = bytes / STp->block_size;
1904 bytes = blks * STp->block_size;
1908 memset(cmd, 0, MAX_COMMAND_SIZE);
1910 cmd[1] = (STp->block_size != 0);
1911 if (!cmd[1] && STp->sili)
1913 cmd[2] = blks >> 16;
1918 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1919 STp->device->request_queue->rq_timeout,
1921 release_buffering(STp, 1);
1924 return STbp->syscall_result;
1926 STbp->read_pointer = 0;
1929 /* Something to check */
1930 if (STbp->syscall_result) {
1931 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1934 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1936 SRpnt->sense[0], SRpnt->sense[1],
1937 SRpnt->sense[2], SRpnt->sense[3],
1938 SRpnt->sense[4], SRpnt->sense[5],
1939 SRpnt->sense[6], SRpnt->sense[7]));
1940 if (cmdstatp->have_sense) {
1942 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1943 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1945 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1946 /* Compute the residual count */
1947 if (cmdstatp->remainder_valid)
1948 transfer = (int)cmdstatp->uremainder64;
1951 if (STp->block_size == 0 &&
1952 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1955 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1956 if (STp->block_size == 0) {
1957 if (transfer <= 0) {
1960 "%s: Failed to read %d byte block with %d byte transfer.\n",
1961 name, bytes - transfer, bytes);
1962 if (STps->drv_block >= 0)
1963 STps->drv_block += 1;
1964 STbp->buffer_bytes = 0;
1967 STbp->buffer_bytes = bytes - transfer;
1969 st_release_request(SRpnt);
1970 SRpnt = *aSRpnt = NULL;
1971 if (transfer == blks) { /* We did not get anything, error */
1972 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1973 if (STps->drv_block >= 0)
1974 STps->drv_block += blks - transfer + 1;
1975 st_int_ioctl(STp, MTBSR, 1);
1978 /* We have some data, deliver it */
1979 STbp->buffer_bytes = (blks - transfer) *
1981 DEBC(printk(ST_DEB_MSG
1982 "%s: ILI but enough data received %ld %d.\n",
1983 name, count, STbp->buffer_bytes));
1984 if (STps->drv_block >= 0)
1985 STps->drv_block += 1;
1986 if (st_int_ioctl(STp, MTBSR, 1))
1989 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1990 if (STps->eof != ST_FM_HIT)
1991 STps->eof = ST_FM_HIT;
1993 STps->eof = ST_EOD_2;
1994 if (STp->block_size == 0)
1995 STbp->buffer_bytes = 0;
1997 STbp->buffer_bytes =
1998 bytes - transfer * STp->block_size;
1999 DEBC(printk(ST_DEB_MSG
2000 "%s: EOF detected (%d bytes read).\n",
2001 name, STbp->buffer_bytes));
2002 } else if (cmdstatp->flags & SENSE_EOM) {
2003 if (STps->eof == ST_FM)
2004 STps->eof = ST_EOD_1;
2006 STps->eof = ST_EOM_OK;
2007 if (STp->block_size == 0)
2008 STbp->buffer_bytes = bytes - transfer;
2010 STbp->buffer_bytes =
2011 bytes - transfer * STp->block_size;
2013 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
2014 name, STbp->buffer_bytes));
2017 /* end of EOF, EOM, ILI test */
2018 else { /* nonzero sense key */
2019 DEBC(printk(ST_DEB_MSG
2020 "%s: Tape error while reading.\n", name));
2021 STps->drv_block = (-1);
2022 if (STps->eof == ST_FM &&
2023 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
2024 DEBC(printk(ST_DEB_MSG
2025 "%s: Zero returned for first BLANK CHECK after EOF.\n",
2027 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
2028 } else /* Some other extended sense code */
2032 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
2033 STbp->buffer_bytes = 0;
2035 /* End of extended sense test */
2036 else { /* Non-extended sense */
2037 retval = STbp->syscall_result;
2041 /* End of error handling */
2042 else { /* Read successful */
2043 STbp->buffer_bytes = bytes;
2044 if (STp->sili) /* In fixed block mode residual is always zero here */
2045 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2048 if (STps->drv_block >= 0) {
2049 if (STp->block_size == 0)
2052 STps->drv_block += STbp->buffer_bytes / STp->block_size;
2060 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2064 ssize_t i, transfer;
2065 int special, do_dio = 0;
2066 struct st_request *SRpnt = NULL;
2067 struct scsi_tape *STp = filp->private_data;
2068 struct st_modedef *STm;
2069 struct st_partstat *STps;
2070 struct st_buffer *STbp = STp->buffer;
2071 DEB( char *name = tape_name(STp); )
2073 if (mutex_lock_interruptible(&STp->lock))
2074 return -ERESTARTSYS;
2076 retval = rw_checks(STp, filp, count);
2077 if (retval || count == 0)
2080 STm = &(STp->modes[STp->current_mode]);
2081 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2082 if (!STm->do_read_ahead) {
2083 retval = (-EINVAL); /* Read must be integral number of blocks */
2086 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
2089 STps = &(STp->ps[STp->partition]);
2090 if (STps->rw == ST_WRITING) {
2091 retval = flush_buffer(STp, 0);
2094 STps->rw = ST_READING;
2097 if (debugging && STps->eof != ST_NOEOF)
2098 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2099 STps->eof, STbp->buffer_bytes);
2102 retval = setup_buffering(STp, buf, count, 1);
2105 do_dio = STbp->do_dio;
2107 if (STbp->buffer_bytes == 0 &&
2108 STps->eof >= ST_EOD_1) {
2109 if (STps->eof < ST_EOD) {
2114 retval = (-EIO); /* EOM or Blank Check */
2119 /* Check the buffer writability before any tape movement. Don't alter
2121 if (copy_from_user(&i, buf, 1) != 0 ||
2122 copy_to_user(buf, &i, 1) != 0 ||
2123 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2124 copy_to_user(buf + count - 1, &i, 1) != 0) {
2130 STps->rw = ST_READING;
2133 /* Loop until enough data in buffer or a special condition found */
2134 for (total = 0, special = 0; total < count && !special;) {
2136 /* Get new data if the buffer is empty */
2137 if (STbp->buffer_bytes == 0) {
2138 special = read_tape(STp, count - total, &SRpnt);
2139 if (special < 0) { /* No need to continue read */
2145 /* Move the data from driver buffer to user buffer */
2146 if (STbp->buffer_bytes > 0) {
2148 if (debugging && STps->eof != ST_NOEOF)
2150 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2151 STps->eof, STbp->buffer_bytes,
2152 (int)(count - total));
2154 transfer = STbp->buffer_bytes < count - total ?
2155 STbp->buffer_bytes : count - total;
2157 i = from_buffer(STbp, buf, transfer);
2167 if (STp->block_size == 0)
2168 break; /* Read only one variable length block */
2170 } /* for (total = 0, special = 0;
2171 total < count && !special; ) */
2173 /* Change the eof state if no data from tape or buffer */
2175 if (STps->eof == ST_FM_HIT) {
2177 STps->drv_block = 0;
2178 if (STps->drv_file >= 0)
2180 } else if (STps->eof == ST_EOD_1) {
2181 STps->eof = ST_EOD_2;
2182 STps->drv_block = 0;
2183 if (STps->drv_file >= 0)
2185 } else if (STps->eof == ST_EOD_2)
2187 } else if (STps->eof == ST_FM)
2188 STps->eof = ST_NOEOF;
2192 if (SRpnt != NULL) {
2193 st_release_request(SRpnt);
2197 release_buffering(STp, 1);
2198 STbp->buffer_bytes = 0;
2200 mutex_unlock(&STp->lock);
2208 /* Set the driver options */
2209 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2213 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2214 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2215 STm->do_read_ahead);
2217 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2218 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2220 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2221 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2222 STp->scsi2_logical);
2224 "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate,
2226 printk(KERN_INFO "%s: debugging: %d\n",
2233 static int st_set_options(struct scsi_tape *STp, long options)
2237 struct st_modedef *STm;
2238 char *name = tape_name(STp);
2239 struct cdev *cd0, *cd1;
2241 STm = &(STp->modes[STp->current_mode]);
2242 if (!STm->defined) {
2243 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2244 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2245 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2247 DEBC(printk(ST_DEB_MSG
2248 "%s: Initialized mode %d definition from mode 0\n",
2249 name, STp->current_mode));
2252 code = options & MT_ST_OPTIONS;
2253 if (code == MT_ST_BOOLEANS) {
2254 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2255 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2256 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2257 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2258 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2259 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2260 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2261 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2262 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2263 if ((STp->device)->scsi_level >= SCSI_2)
2264 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2265 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2266 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2267 STm->sysv = (options & MT_ST_SYSV) != 0;
2268 STp->sili = (options & MT_ST_SILI) != 0;
2269 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2270 st_log_options(STp, STm, name); )
2271 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2272 value = (code == MT_ST_SETBOOLEANS);
2273 if ((options & MT_ST_BUFFER_WRITES) != 0)
2274 STm->do_buffer_writes = value;
2275 if ((options & MT_ST_ASYNC_WRITES) != 0)
2276 STm->do_async_writes = value;
2277 if ((options & MT_ST_DEF_WRITES) != 0)
2278 STm->defaults_for_writes = value;
2279 if ((options & MT_ST_READ_AHEAD) != 0)
2280 STm->do_read_ahead = value;
2281 if ((options & MT_ST_TWO_FM) != 0)
2282 STp->two_fm = value;
2283 if ((options & MT_ST_FAST_MTEOM) != 0)
2284 STp->fast_mteom = value;
2285 if ((options & MT_ST_AUTO_LOCK) != 0)
2286 STp->do_auto_lock = value;
2287 if ((options & MT_ST_CAN_BSR) != 0)
2288 STp->can_bsr = value;
2289 if ((options & MT_ST_NO_BLKLIMS) != 0)
2290 STp->omit_blklims = value;
2291 if ((STp->device)->scsi_level >= SCSI_2 &&
2292 (options & MT_ST_CAN_PARTITIONS) != 0)
2293 STp->can_partitions = value;
2294 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2295 STp->scsi2_logical = value;
2296 if ((options & MT_ST_NOWAIT) != 0)
2297 STp->immediate = value;
2298 if ((options & MT_ST_SYSV) != 0)
2300 if ((options & MT_ST_SILI) != 0)
2303 if ((options & MT_ST_DEBUGGING) != 0)
2305 st_log_options(STp, STm, name); )
2306 } else if (code == MT_ST_WRITE_THRESHOLD) {
2307 /* Retained for compatibility */
2308 } else if (code == MT_ST_DEF_BLKSIZE) {
2309 value = (options & ~MT_ST_OPTIONS);
2310 if (value == ~MT_ST_OPTIONS) {
2311 STm->default_blksize = (-1);
2312 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2314 STm->default_blksize = value;
2315 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2316 name, STm->default_blksize));
2317 if (STp->ready == ST_READY) {
2318 STp->blksize_changed = 0;
2319 set_mode_densblk(STp, STm);
2322 } else if (code == MT_ST_TIMEOUTS) {
2323 value = (options & ~MT_ST_OPTIONS);
2324 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2325 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2326 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2327 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2329 blk_queue_rq_timeout(STp->device->request_queue,
2331 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2334 } else if (code == MT_ST_SET_CLN) {
2335 value = (options & ~MT_ST_OPTIONS) & 0xff;
2337 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2339 STp->cln_mode = value;
2340 STp->cln_sense_mask = (options >> 8) & 0xff;
2341 STp->cln_sense_value = (options >> 16) & 0xff;
2343 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2344 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2345 } else if (code == MT_ST_DEF_OPTIONS) {
2346 code = (options & ~MT_ST_CLEAR_DEFAULT);
2347 value = (options & MT_ST_CLEAR_DEFAULT);
2348 if (code == MT_ST_DEF_DENSITY) {
2349 if (value == MT_ST_CLEAR_DEFAULT) {
2350 STm->default_density = (-1);
2351 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2354 STm->default_density = value & 0xff;
2355 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2356 name, STm->default_density));
2357 if (STp->ready == ST_READY) {
2358 STp->density_changed = 0;
2359 set_mode_densblk(STp, STm);
2362 } else if (code == MT_ST_DEF_DRVBUFFER) {
2363 if (value == MT_ST_CLEAR_DEFAULT) {
2364 STp->default_drvbuffer = 0xff;
2365 DEBC( printk(KERN_INFO
2366 "%s: Drive buffer default disabled.\n", name));
2368 STp->default_drvbuffer = value & 7;
2369 DEBC( printk(KERN_INFO
2370 "%s: Drive buffer default set to %x\n",
2371 name, STp->default_drvbuffer));
2372 if (STp->ready == ST_READY)
2373 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2375 } else if (code == MT_ST_DEF_COMPRESSION) {
2376 if (value == MT_ST_CLEAR_DEFAULT) {
2377 STm->default_compression = ST_DONT_TOUCH;
2378 DEBC( printk(KERN_INFO
2379 "%s: Compression default disabled.\n", name));
2381 if ((value & 0xff00) != 0) {
2382 STp->c_algo = (value & 0xff00) >> 8;
2383 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2384 name, STp->c_algo));
2386 if ((value & 0xff) != 0xff) {
2387 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2388 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2389 name, (value & 1)));
2390 if (STp->ready == ST_READY) {
2391 STp->compression_changed = 0;
2392 st_compression(STp, (STm->default_compression == ST_YES));
2403 #define MODE_HEADER_LENGTH 4
2405 /* Mode header and page byte offsets */
2406 #define MH_OFF_DATA_LENGTH 0
2407 #define MH_OFF_MEDIUM_TYPE 1
2408 #define MH_OFF_DEV_SPECIFIC 2
2409 #define MH_OFF_BDESCS_LENGTH 3
2410 #define MP_OFF_PAGE_NBR 0
2411 #define MP_OFF_PAGE_LENGTH 1
2413 /* Mode header and page bit masks */
2414 #define MH_BIT_WP 0x80
2415 #define MP_MSK_PAGE_NBR 0x3f
2417 /* Don't return block descriptors */
2418 #define MODE_SENSE_OMIT_BDESCS 0x08
2420 #define MODE_SELECT_PAGE_FORMAT 0x10
2422 /* Read a mode page into the tape buffer. The block descriptors are included
2423 if incl_block_descs is true. The page control is ored to the page number
2424 parameter, if necessary. */
2425 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2427 unsigned char cmd[MAX_COMMAND_SIZE];
2428 struct st_request *SRpnt;
2431 memset(cmd, 0, MAX_COMMAND_SIZE);
2432 cmd[0] = MODE_SENSE;
2433 if (omit_block_descs)
2434 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2438 SRpnt = st_allocate_request(STp);
2440 return STp->buffer->syscall_result;
2442 ret = st_scsi_kern_execute(SRpnt, cmd, DMA_FROM_DEVICE,
2443 STp->buffer->b_data, cmd[4],
2444 STp->device->request_queue->rq_timeout,
2446 st_release_request(SRpnt);
2448 return ret ? : STp->buffer->syscall_result;
2452 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2453 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2454 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2456 int pgo, timeout, ret = 0;
2457 unsigned char cmd[MAX_COMMAND_SIZE];
2458 struct st_request *SRpnt;
2460 memset(cmd, 0, MAX_COMMAND_SIZE);
2461 cmd[0] = MODE_SELECT;
2462 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2463 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2464 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2466 /* Clear reserved fields */
2467 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2468 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2469 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2470 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2472 SRpnt = st_allocate_request(STp);
2476 timeout = slow ? STp->long_timeout :
2477 STp->device->request_queue->rq_timeout;
2479 ret = st_scsi_kern_execute(SRpnt, cmd, DMA_TO_DEVICE,
2480 STp->buffer->b_data, cmd[4], timeout, 0);
2482 ret = STp->buffer->syscall_result;
2484 st_release_request(SRpnt);
2490 #define COMPRESSION_PAGE 0x0f
2491 #define COMPRESSION_PAGE_LENGTH 16
2493 #define CP_OFF_DCE_DCC 2
2494 #define CP_OFF_C_ALGO 7
2496 #define DCE_MASK 0x80
2497 #define DCC_MASK 0x40
2498 #define RED_MASK 0x60
2501 /* Control the compression with mode page 15. Algorithm not changed if zero.
2503 The block descriptors are read and written because Sony SDT-7000 does not
2504 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2505 Including block descriptors should not cause any harm to other drives. */
2507 static int st_compression(struct scsi_tape * STp, int state)
2510 int mpoffs; /* Offset to mode page start */
2511 unsigned char *b_data = (STp->buffer)->b_data;
2512 DEB( char *name = tape_name(STp); )
2514 if (STp->ready != ST_READY)
2517 /* Read the current page contents */
2518 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2520 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2525 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2526 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2527 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2529 /* Check if compression can be changed */
2530 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2531 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2537 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2538 if (STp->c_algo != 0)
2539 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2542 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2543 if (STp->c_algo != 0)
2544 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2547 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2549 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2552 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2555 STp->compression_changed = 1;
2560 /* Process the load and unload commands (does unload if the load code is zero) */
2561 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2563 int retval = (-EIO), timeout;
2564 DEB( char *name = tape_name(STp); )
2565 unsigned char cmd[MAX_COMMAND_SIZE];
2566 struct st_partstat *STps;
2567 struct st_request *SRpnt;
2569 if (STp->ready != ST_READY && !load_code) {
2570 if (STp->ready == ST_NO_TAPE)
2571 return (-ENOMEDIUM);
2576 memset(cmd, 0, MAX_COMMAND_SIZE);
2577 cmd[0] = START_STOP;
2581 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2583 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2584 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2585 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2586 name, (cmd[4]) ? "" : "un",
2587 load_code - MT_ST_HPLOADER_OFFSET));
2588 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2590 if (STp->immediate) {
2591 cmd[1] = 1; /* Don't wait for completion */
2592 timeout = STp->device->request_queue->rq_timeout;
2595 timeout = STp->long_timeout;
2599 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2601 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2604 SRpnt = st_allocate_request(STp);
2606 return STp->buffer->syscall_result;
2608 retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0, timeout,
2613 retval = (STp->buffer)->syscall_result;
2615 if (!retval) { /* SCSI command successful */
2618 STp->rew_at_close = 0;
2619 STp->ready = ST_NO_TAPE;
2622 STp->rew_at_close = STp->autorew_dev;
2623 retval = check_tape(STp, filp);
2629 STps = &(STp->ps[STp->partition]);
2630 STps->drv_file = STps->drv_block = (-1);
2633 st_release_request(SRpnt);
2639 #define ST_DEB_FORWARD 0
2640 #define ST_DEB_BACKWARD 1
2641 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2645 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2646 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2649 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2650 direction ? "backward" : "forward", sc, units);
2655 /* Internal ioctl function */
2656 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2662 unsigned char cmd[MAX_COMMAND_SIZE];
2663 struct st_request *SRpnt;
2664 struct st_partstat *STps;
2665 int fileno, blkno, at_sm, undone;
2666 int datalen = 0, direction = DMA_NONE;
2667 char *name = tape_name(STp);
2669 WARN_ON(STp->buffer->do_dio != 0);
2670 if (STp->ready != ST_READY) {
2671 if (STp->ready == ST_NO_TAPE)
2672 return (-ENOMEDIUM);
2676 timeout = STp->long_timeout;
2677 STps = &(STp->ps[STp->partition]);
2678 fileno = STps->drv_file;
2679 blkno = STps->drv_block;
2680 at_sm = STps->at_sm;
2682 memset(cmd, 0, MAX_COMMAND_SIZE);
2685 chg_eof = 0; /* Changed from the FSF after this */
2688 cmd[1] = 0x01; /* Space FileMarks */
2689 cmd[2] = (arg >> 16);
2690 cmd[3] = (arg >> 8);
2692 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2696 at_sm &= (arg == 0);
2699 chg_eof = 0; /* Changed from the FSF after this */
2702 cmd[1] = 0x01; /* Space FileMarks */
2704 cmd[2] = (ltmp >> 16);
2705 cmd[3] = (ltmp >> 8);
2707 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2710 blkno = (-1); /* We can't know the block number */
2711 at_sm &= (arg == 0);
2715 cmd[1] = 0x00; /* Space Blocks */
2716 cmd[2] = (arg >> 16);
2717 cmd[3] = (arg >> 8);
2719 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2722 at_sm &= (arg == 0);
2726 cmd[1] = 0x00; /* Space Blocks */
2728 cmd[2] = (ltmp >> 16);
2729 cmd[3] = (ltmp >> 8);
2731 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2734 at_sm &= (arg == 0);
2738 cmd[1] = 0x04; /* Space Setmarks */
2739 cmd[2] = (arg >> 16);
2740 cmd[3] = (arg >> 8);
2742 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2744 blkno = fileno = (-1);
2750 cmd[1] = 0x04; /* Space Setmarks */
2752 cmd[2] = (ltmp >> 16);
2753 cmd[3] = (ltmp >> 8);
2755 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2757 blkno = fileno = (-1);
2763 if (STp->write_prot)
2765 cmd[0] = WRITE_FILEMARKS;
2766 if (cmd_in == MTWSM)
2768 cmd[2] = (arg >> 16);
2769 cmd[3] = (arg >> 8);
2771 timeout = STp->device->request_queue->rq_timeout;
2773 if (cmd_in == MTWEOF)
2774 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2775 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2777 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2778 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2783 at_sm = (cmd_in == MTWSM);
2786 cmd[0] = REZERO_UNIT;
2787 if (STp->immediate) {
2788 cmd[1] = 1; /* Don't wait for completion */
2789 timeout = STp->device->request_queue->rq_timeout;
2791 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2792 fileno = blkno = at_sm = 0;
2795 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2796 return 0; /* Should do something ? */
2799 cmd[0] = START_STOP;
2800 if (STp->immediate) {
2801 cmd[1] = 1; /* Don't wait for completion */
2802 timeout = STp->device->request_queue->rq_timeout;
2805 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2806 fileno = blkno = at_sm = 0;
2809 if (!STp->fast_mteom) {
2810 /* space to the end of tape */
2811 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2812 fileno = STps->drv_file;
2813 if (STps->eof >= ST_EOD_1)
2815 /* The next lines would hide the number of spaced FileMarks
2816 That's why I inserted the previous lines. I had no luck
2817 with detecting EOM with FSF, so we go now to EOM.
2823 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2829 if (STp->write_prot)
2832 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2833 if (STp->immediate) {
2834 cmd[1] |= 2; /* Don't wait for completion */
2835 timeout = STp->device->request_queue->rq_timeout;
2838 timeout = STp->long_timeout * 8;
2840 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2841 fileno = blkno = at_sm = 0;
2843 case MTSETBLK: /* Set block length */
2844 case MTSETDENSITY: /* Set tape density */
2845 case MTSETDRVBUFFER: /* Set drive buffering */
2846 case SET_DENS_AND_BLK: /* Set density and block size */
2848 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2849 return (-EIO); /* Not allowed if data in buffer */
2850 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2851 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2852 STp->max_block > 0 &&
2853 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2854 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2855 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2858 cmd[0] = MODE_SELECT;
2859 if ((STp->use_pf & USE_PF))
2860 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2861 cmd[4] = datalen = 12;
2862 direction = DMA_TO_DEVICE;
2864 memset((STp->buffer)->b_data, 0, 12);
2865 if (cmd_in == MTSETDRVBUFFER)
2866 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2868 (STp->buffer)->b_data[2] =
2869 STp->drv_buffer << 4;
2870 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2871 if (cmd_in == MTSETDENSITY) {
2872 (STp->buffer)->b_data[4] = arg;
2873 STp->density_changed = 1; /* At least we tried ;-) */
2874 } else if (cmd_in == SET_DENS_AND_BLK)
2875 (STp->buffer)->b_data[4] = arg >> 24;
2877 (STp->buffer)->b_data[4] = STp->density;
2878 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2879 ltmp = arg & MT_ST_BLKSIZE_MASK;
2880 if (cmd_in == MTSETBLK)
2881 STp->blksize_changed = 1; /* At least we tried ;-) */
2883 ltmp = STp->block_size;
2884 (STp->buffer)->b_data[9] = (ltmp >> 16);
2885 (STp->buffer)->b_data[10] = (ltmp >> 8);
2886 (STp->buffer)->b_data[11] = ltmp;
2887 timeout = STp->device->request_queue->rq_timeout;
2889 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2891 "%s: Setting block size to %d bytes.\n", name,
2892 (STp->buffer)->b_data[9] * 65536 +
2893 (STp->buffer)->b_data[10] * 256 +
2894 (STp->buffer)->b_data[11]);
2895 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2897 "%s: Setting density code to %x.\n", name,
2898 (STp->buffer)->b_data[4]);
2899 if (cmd_in == MTSETDRVBUFFER)
2901 "%s: Setting drive buffer code to %d.\n", name,
2902 ((STp->buffer)->b_data[2] >> 4) & 7);
2909 SRpnt = st_allocate_request(STp);
2911 return (STp->buffer)->syscall_result;
2913 ioctl_result = st_scsi_kern_execute(SRpnt, cmd, direction,
2914 STp->buffer->b_data, datalen,
2915 timeout, MAX_RETRIES);
2917 ioctl_result = (STp->buffer)->syscall_result;
2919 if (!ioctl_result) { /* SCSI command successful */
2920 st_release_request(SRpnt);
2922 STps->drv_block = blkno;
2923 STps->drv_file = fileno;
2924 STps->at_sm = at_sm;
2926 if (cmd_in == MTBSFM)
2927 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2928 else if (cmd_in == MTFSFM)
2929 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2931 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2932 int old_block_size = STp->block_size;
2933 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2934 if (STp->block_size != 0) {
2935 if (old_block_size == 0)
2936 normalize_buffer(STp->buffer);
2937 (STp->buffer)->buffer_blocks =
2938 (STp->buffer)->buffer_size / STp->block_size;
2940 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2941 if (cmd_in == SET_DENS_AND_BLK)
2942 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2943 } else if (cmd_in == MTSETDRVBUFFER)
2944 STp->drv_buffer = (arg & 7);
2945 else if (cmd_in == MTSETDENSITY)
2948 if (cmd_in == MTEOM)
2950 else if (cmd_in == MTFSF)
2953 STps->eof = ST_NOEOF;
2955 if (cmd_in == MTWEOF)
2957 } else { /* SCSI command was not completely successful. Don't return
2958 from this block without releasing the SCSI command block! */
2959 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2961 if (cmdstatp->flags & SENSE_EOM) {
2962 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2963 cmd_in != MTBSR && cmd_in != MTBSS)
2964 STps->eof = ST_EOM_OK;
2965 STps->drv_block = 0;
2968 if (cmdstatp->remainder_valid)
2969 undone = (int)cmdstatp->uremainder64;
2973 if (cmd_in == MTWEOF &&
2974 cmdstatp->have_sense &&
2975 (cmdstatp->flags & SENSE_EOM)) {
2976 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2977 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2978 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2979 STps->eof = ST_NOEOF;
2980 } else { /* Writing EOF(s) failed */
2984 STps->eof = ST_NOEOF;
2986 STps->drv_file = fileno;
2987 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2989 STps->drv_file = fileno - undone;
2991 STps->drv_file = fileno;
2992 STps->drv_block = -1;
2993 STps->eof = ST_NOEOF;
2994 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2995 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2997 if (STps->drv_file >= 0)
2998 STps->drv_file = fileno + undone;
2999 STps->drv_block = 0;
3000 STps->eof = ST_NOEOF;
3001 } else if (cmd_in == MTFSR) {
3002 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
3003 if (STps->drv_file >= 0)
3005 STps->drv_block = 0;
3008 if (blkno >= undone)
3009 STps->drv_block = blkno - undone;
3011 STps->drv_block = (-1);
3012 STps->eof = ST_NOEOF;
3014 } else if (cmd_in == MTBSR) {
3015 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
3017 STps->drv_block = (-1);
3019 if (arg > 0 && undone < 0) /* Some drives get this wrong */
3021 if (STps->drv_block >= 0)
3022 STps->drv_block = blkno + undone;
3024 STps->eof = ST_NOEOF;
3025 } else if (cmd_in == MTEOM) {
3026 STps->drv_file = (-1);
3027 STps->drv_block = (-1);
3029 } else if (cmd_in == MTSETBLK ||
3030 cmd_in == MTSETDENSITY ||
3031 cmd_in == MTSETDRVBUFFER ||
3032 cmd_in == SET_DENS_AND_BLK) {
3033 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
3034 !(STp->use_pf & PF_TESTED)) {
3035 /* Try the other possible state of Page Format if not
3037 STp->use_pf = !STp->use_pf | PF_TESTED;
3038 st_release_request(SRpnt);
3040 return st_int_ioctl(STp, cmd_in, arg);
3043 STps->eof = ST_NOEOF;
3045 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
3048 st_release_request(SRpnt);
3052 return ioctl_result;
3056 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3059 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3063 unsigned char scmd[MAX_COMMAND_SIZE];
3064 struct st_request *SRpnt;
3065 DEB( char *name = tape_name(STp); )
3067 if (STp->ready != ST_READY)
3070 memset(scmd, 0, MAX_COMMAND_SIZE);
3071 if ((STp->device)->scsi_level < SCSI_2) {
3072 scmd[0] = QFA_REQUEST_BLOCK;
3075 scmd[0] = READ_POSITION;
3076 if (!logical && !STp->scsi2_logical)
3080 SRpnt = st_allocate_request(STp);
3082 return STp->buffer->syscall_result;
3084 result = st_scsi_kern_execute(SRpnt, scmd, DMA_FROM_DEVICE,
3085 STp->buffer->b_data, 20,
3086 STp->device->request_queue->rq_timeout,
3091 if ((STp->buffer)->syscall_result != 0 ||
3092 (STp->device->scsi_level >= SCSI_2 &&
3093 ((STp->buffer)->b_data[0] & 4) != 0)) {
3094 *block = *partition = 0;
3095 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3099 if ((STp->device)->scsi_level < SCSI_2) {
3100 *block = ((STp->buffer)->b_data[0] << 16)
3101 + ((STp->buffer)->b_data[1] << 8)
3102 + (STp->buffer)->b_data[2];
3105 *block = ((STp->buffer)->b_data[4] << 24)
3106 + ((STp->buffer)->b_data[5] << 16)
3107 + ((STp->buffer)->b_data[6] << 8)
3108 + (STp->buffer)->b_data[7];
3109 *partition = (STp->buffer)->b_data[1];
3110 if (((STp->buffer)->b_data[0] & 0x80) &&
3111 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
3112 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3114 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3115 *block, *partition));
3118 st_release_request(SRpnt);
3125 /* Set the tape block and partition. Negative partition means that only the
3126 block should be set in vendor specific way. */
3127 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3130 struct st_partstat *STps;
3134 unsigned char scmd[MAX_COMMAND_SIZE];
3135 struct st_request *SRpnt;
3136 DEB( char *name = tape_name(STp); )
3138 if (STp->ready != ST_READY)
3140 timeout = STp->long_timeout;
3141 STps = &(STp->ps[STp->partition]);
3143 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3144 name, block, partition));
3145 DEB(if (partition < 0)
3148 /* Update the location at the partition we are leaving */
3149 if ((!STp->can_partitions && partition != 0) ||
3150 partition >= ST_NBR_PARTITIONS)
3152 if (partition != STp->partition) {
3153 if (get_location(STp, &blk, &p, 1))
3154 STps->last_block_valid = 0;
3156 STps->last_block_valid = 1;
3157 STps->last_block_visited = blk;
3158 DEBC(printk(ST_DEB_MSG
3159 "%s: Visited block %d for partition %d saved.\n",
3160 name, blk, STp->partition));
3164 memset(scmd, 0, MAX_COMMAND_SIZE);
3165 if ((STp->device)->scsi_level < SCSI_2) {
3166 scmd[0] = QFA_SEEK_BLOCK;
3167 scmd[2] = (block >> 16);
3168 scmd[3] = (block >> 8);
3173 scmd[3] = (block >> 24);
3174 scmd[4] = (block >> 16);
3175 scmd[5] = (block >> 8);
3177 if (!logical && !STp->scsi2_logical)
3179 if (STp->partition != partition) {
3181 scmd[8] = partition;
3182 DEBC(printk(ST_DEB_MSG
3183 "%s: Trying to change partition from %d to %d\n",
3184 name, STp->partition, partition));
3187 if (STp->immediate) {
3188 scmd[1] |= 1; /* Don't wait for completion */
3189 timeout = STp->device->request_queue->rq_timeout;
3192 SRpnt = st_allocate_request(STp);
3194 return STp->buffer->syscall_result;
3196 result = st_scsi_kern_execute(SRpnt, scmd, DMA_NONE, NULL, 0,
3197 timeout, MAX_READY_RETRIES);
3201 STps->drv_block = STps->drv_file = (-1);
3202 STps->eof = ST_NOEOF;
3203 if ((STp->buffer)->syscall_result != 0) {
3205 if (STp->can_partitions &&
3206 (STp->device)->scsi_level >= SCSI_2 &&
3207 (p = find_partition(STp)) >= 0)
3210 if (STp->can_partitions) {
3211 STp->partition = partition;
3212 STps = &(STp->ps[partition]);
3213 if (!STps->last_block_valid ||
3214 STps->last_block_visited != block) {
3221 STps->drv_block = STps->drv_file = 0;
3225 st_release_request(SRpnt);
3232 /* Find the current partition number for the drive status. Called from open and
3233 returns either partition number of negative error code. */
3234 static int find_partition(struct scsi_tape *STp)
3239 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3241 if (partition >= ST_NBR_PARTITIONS)
3247 /* Change the partition if necessary */
3248 static int switch_partition(struct scsi_tape *STp)
3250 struct st_partstat *STps;
3252 if (STp->partition == STp->new_partition)
3254 STps = &(STp->ps[STp->new_partition]);
3255 if (!STps->last_block_valid)
3256 STps->last_block_visited = 0;
3257 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3260 /* Functions for reading and writing the medium partition mode page. */
3262 #define PART_PAGE 0x11
3263 #define PART_PAGE_FIXED_LENGTH 8
3265 #define PP_OFF_MAX_ADD_PARTS 2
3266 #define PP_OFF_NBR_ADD_PARTS 3
3267 #define PP_OFF_FLAGS 4
3268 #define PP_OFF_PART_UNITS 6
3269 #define PP_OFF_RESERVED 7
3271 #define PP_BIT_IDP 0x20
3272 #define PP_MSK_PSUM_MB 0x10
3274 /* Get the number of partitions on the tape. As a side effect reads the
3275 mode page into the tape buffer. */
3276 static int nbr_partitions(struct scsi_tape *STp)
3279 DEB( char *name = tape_name(STp); )
3281 if (STp->ready != ST_READY)
3284 result = read_mode_page(STp, PART_PAGE, 1);
3287 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3291 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3292 PP_OFF_NBR_ADD_PARTS] + 1;
3293 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3300 /* Partition the tape into two partitions if size > 0 or one partition if
3303 The block descriptors are read and written because Sony SDT-7000 does not
3304 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3306 My HP C1533A drive returns only one partition size field. This is used to
3307 set the size of partition 1. There is no size field for the default partition.
3308 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3309 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3310 The following algorithm is used to accommodate both drives: if the number of
3311 partition size fields is greater than the maximum number of additional partitions
3312 in the mode page, the second field is used. Otherwise the first field is used.
3314 For Seagate DDS drives the page length must be 8 when no partitions is defined
3315 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3316 is acceptable also to some other old drives and enforced if the first partition
3317 size field is used for the first additional partition size.
3319 static int partition_tape(struct scsi_tape *STp, int size)
3321 char *name = tape_name(STp);
3323 int pgo, psd_cnt, psdo;
3326 result = read_mode_page(STp, PART_PAGE, 0);
3328 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3331 /* The mode page is in the buffer. Let's modify it and write it. */
3332 bp = (STp->buffer)->b_data;
3333 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3334 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3335 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3337 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3338 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3339 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3340 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3343 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3345 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3346 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3347 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3350 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3351 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3352 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3353 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3356 bp[psdo] = (size >> 8) & 0xff;
3357 bp[psdo + 1] = size & 0xff;
3359 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3360 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3361 DEBC(printk(ST_DEB_MSG
3362 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3365 bp[pgo + PP_OFF_PART_UNITS] = 0;
3366 bp[pgo + PP_OFF_RESERVED] = 0;
3367 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3369 result = write_mode_page(STp, PART_PAGE, 1);
3371 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3380 /* The ioctl command */
3381 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3383 int i, cmd_nr, cmd_type, bt;
3386 struct scsi_tape *STp = file->private_data;
3387 struct st_modedef *STm;
3388 struct st_partstat *STps;
3389 char *name = tape_name(STp);
3390 void __user *p = (void __user *)arg;
3392 if (mutex_lock_interruptible(&STp->lock))
3393 return -ERESTARTSYS;
3396 if (debugging && !STp->in_use) {
3397 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3402 STm = &(STp->modes[STp->current_mode]);
3403 STps = &(STp->ps[STp->partition]);
3406 * If we are in the middle of error recovery, don't let anyone
3407 * else try and use this device. Also, if error recovery fails, it
3408 * may try and take the device offline, in which case all further
3409 * access to the device is prohibited.
3411 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3412 file->f_flags & O_NDELAY);
3413 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3417 cmd_type = _IOC_TYPE(cmd_in);
3418 cmd_nr = _IOC_NR(cmd_in);
3420 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3423 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3428 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3434 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3436 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3440 if (!STm->defined &&
3441 (mtc.mt_op != MTSETDRVBUFFER &&
3442 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3447 if (!STp->pos_unknown) {
3449 if (STps->eof == ST_FM_HIT) {
3450 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3451 mtc.mt_op == MTEOM) {
3453 if (STps->drv_file >= 0)
3454 STps->drv_file += 1;
3455 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3457 if (STps->drv_file >= 0)
3458 STps->drv_file += 1;
3462 if (mtc.mt_op == MTSEEK) {
3463 /* Old position must be restored if partition will be
3465 i = !STp->can_partitions ||
3466 (STp->new_partition != STp->partition);
3468 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3469 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3470 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3471 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3472 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3473 mtc.mt_op == MTCOMPRESSION;
3475 i = flush_buffer(STp, i);
3480 if (STps->rw == ST_WRITING &&
3481 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3482 mtc.mt_op == MTSEEK ||
3483 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3484 i = st_int_ioctl(STp, MTWEOF, 1);
3489 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3496 * If there was a bus reset, block further access
3497 * to this device. If the user wants to rewind the tape,
3498 * then reset the flag and allow access again.
3500 if (mtc.mt_op != MTREW &&
3501 mtc.mt_op != MTOFFL &&
3502 mtc.mt_op != MTRETEN &&
3503 mtc.mt_op != MTERASE &&
3504 mtc.mt_op != MTSEEK &&
3505 mtc.mt_op != MTEOM) {
3510 /* remove this when the midlevel properly clears was_reset */
3511 STp->device->was_reset = 0;
3514 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3515 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3516 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3517 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3519 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3520 do_door_lock(STp, 0); /* Ignore result! */
3522 if (mtc.mt_op == MTSETDRVBUFFER &&
3523 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3524 retval = st_set_options(STp, mtc.mt_count);
3528 if (mtc.mt_op == MTSETPART) {
3529 if (!STp->can_partitions ||
3530 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3534 if (mtc.mt_count >= STp->nbr_partitions &&
3535 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3539 if (mtc.mt_count >= STp->nbr_partitions) {
3543 STp->new_partition = mtc.mt_count;
3548 if (mtc.mt_op == MTMKPART) {
3549 if (!STp->can_partitions) {
3553 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3554 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3558 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3559 STp->ps[i].rw = ST_IDLE;
3560 STp->ps[i].at_sm = 0;
3561 STp->ps[i].last_block_valid = 0;
3563 STp->partition = STp->new_partition = 0;
3564 STp->nbr_partitions = 1; /* Bad guess ?-) */
3565 STps->drv_block = STps->drv_file = 0;
3570 if (mtc.mt_op == MTSEEK) {
3571 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3572 if (!STp->can_partitions)
3573 STp->ps[0].rw = ST_IDLE;
3578 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3579 retval = do_load_unload(STp, file, 0);
3583 if (mtc.mt_op == MTLOAD) {
3584 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3588 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3589 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3593 if (STp->can_partitions && STp->ready == ST_READY &&
3594 (i = switch_partition(STp)) < 0) {
3599 if (mtc.mt_op == MTCOMPRESSION)
3600 retval = st_compression(STp, (mtc.mt_count & 1));
3602 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3605 if (!STm->defined) {
3610 if ((i = flush_buffer(STp, 0)) < 0) {
3614 if (STp->can_partitions &&
3615 (i = switch_partition(STp)) < 0) {
3620 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3621 struct mtget mt_status;
3623 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3628 mt_status.mt_type = STp->tape_type;
3629 mt_status.mt_dsreg =
3630 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3631 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3632 mt_status.mt_blkno = STps->drv_block;
3633 mt_status.mt_fileno = STps->drv_file;
3634 if (STp->block_size != 0) {
3635 if (STps->rw == ST_WRITING)
3636 mt_status.mt_blkno +=
3637 (STp->buffer)->buffer_bytes / STp->block_size;
3638 else if (STps->rw == ST_READING)
3639 mt_status.mt_blkno -=
3640 ((STp->buffer)->buffer_bytes +
3641 STp->block_size - 1) / STp->block_size;
3644 mt_status.mt_gstat = 0;
3645 if (STp->drv_write_prot)
3646 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3647 if (mt_status.mt_blkno == 0) {
3648 if (mt_status.mt_fileno == 0)
3649 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3651 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3653 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3654 mt_status.mt_resid = STp->partition;
3655 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3656 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3657 else if (STps->eof >= ST_EOM_OK)
3658 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3659 if (STp->density == 1)
3660 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3661 else if (STp->density == 2)
3662 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3663 else if (STp->density == 3)
3664 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3665 if (STp->ready == ST_READY)
3666 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3667 if (STp->ready == ST_NO_TAPE)
3668 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3670 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3671 if (STm->do_async_writes ||
3672 (STm->do_buffer_writes && STp->block_size != 0) ||
3673 STp->drv_buffer != 0)
3674 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3675 if (STp->cleaning_req)
3676 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3678 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3684 STp->recover_reg = 0; /* Clear after read */
3687 } /* End of MTIOCGET */
3688 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3689 struct mtpos mt_pos;
3690 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3694 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3698 mt_pos.mt_blkno = blk;
3699 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3704 mutex_unlock(&STp->lock);
3706 case SCSI_IOCTL_GET_IDLUN:
3707 case SCSI_IOCTL_GET_BUS_NUMBER:
3710 if ((cmd_in == SG_IO ||
3711 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3712 cmd_in == CDROM_SEND_PACKET) &&
3713 !capable(CAP_SYS_RAWIO))
3716 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3717 file->f_mode, cmd_in, p);
3722 retval = scsi_ioctl(STp->device, cmd_in, p);
3723 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3724 STp->rew_at_close = 0;
3725 STp->ready = ST_NO_TAPE;
3730 mutex_unlock(&STp->lock);
3734 #ifdef CONFIG_COMPAT
3735 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3737 struct scsi_tape *STp = file->private_data;
3738 struct scsi_device *sdev = STp->device;
3739 int ret = -ENOIOCTLCMD;
3740 if (sdev->host->hostt->compat_ioctl) {
3742 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3751 /* Try to allocate a new tape buffer. Calling function must not hold
3753 static struct st_buffer *
3754 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3758 struct st_buffer *tb;
3760 if (from_initialization)
3761 priority = GFP_ATOMIC;
3763 priority = GFP_KERNEL;
3765 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3766 max_sg * sizeof(struct st_buf_fragment);
3767 tb = kzalloc(i, priority);
3769 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3772 tb->frp_segs = tb->orig_frp_segs = 0;
3773 tb->use_sg = max_sg;
3774 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3777 tb->buffer_size = got;
3778 sg_init_table(tb->sg, max_sg);
3780 tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *), priority);
3781 if (!tb->reserved_pages) {
3790 /* Try to allocate enough space in the tape buffer */
3791 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3793 int segs, nbr, max_segs, b_size, order, got;
3796 if (new_size <= STbuffer->buffer_size)
3799 if (STbuffer->buffer_size <= PAGE_SIZE)
3800 normalize_buffer(STbuffer); /* Avoid extra segment */
3802 max_segs = STbuffer->use_sg;
3803 nbr = max_segs - STbuffer->frp_segs;
3807 priority = GFP_KERNEL | __GFP_NOWARN;
3809 priority |= GFP_DMA;
3811 if (STbuffer->frp_segs) {
3812 b_size = STbuffer->frp[0].length;
3813 order = get_order(b_size);
3815 for (b_size = PAGE_SIZE, order = 0;
3816 order <= 6 && b_size < new_size; order++, b_size *= 2)
3820 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3821 segs < max_segs && got < new_size;) {
3822 STbuffer->frp[segs].page = alloc_pages(priority, order);
3823 if (STbuffer->frp[segs].page == NULL) {
3824 DEB(STbuffer->buffer_size = got);
3825 normalize_buffer(STbuffer);
3828 STbuffer->frp[segs].length = b_size;
3829 STbuffer->frp_segs += 1;
3831 STbuffer->buffer_size = got;
3832 if (STbuffer->cleared)
3833 memset(page_address(STbuffer->frp[segs].page), 0, b_size);
3834 STbuffer->reserved_pages[segs] = STbuffer->frp[segs].page;
3837 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3838 STbuffer->map_data.page_order = order;
3844 /* Make sure that no data from previous user is in the internal buffer */
3845 static void clear_buffer(struct st_buffer * st_bp)
3849 for (i=0; i < st_bp->frp_segs; i++)
3850 memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length);
3855 /* Release the extra buffer */
3856 static void normalize_buffer(struct st_buffer * STbuffer)
3860 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3861 order = get_order(STbuffer->frp[i].length);
3862 __free_pages(STbuffer->frp[i].page, order);
3863 STbuffer->buffer_size -= STbuffer->frp[i].length;
3865 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3866 STbuffer->frp_sg_current = 0;
3867 STbuffer->sg_segs = 0;
3868 STbuffer->map_data.page_order = 0;
3869 STbuffer->map_data.offset = 0;
3873 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3874 negative error code. */
3875 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3877 int i, cnt, res, offset;
3879 for (i = 0, offset = st_bp->buffer_bytes;
3880 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3881 offset -= st_bp->frp[i].length;
3882 if (i == st_bp->frp_segs) { /* Should never happen */
3883 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3886 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3887 cnt = st_bp->frp[i].length - offset < do_count ?
3888 st_bp->frp[i].length - offset : do_count;
3889 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3893 st_bp->buffer_bytes += cnt;
3897 if (do_count) /* Should never happen */
3904 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3905 negative error code. */
3906 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3908 int i, cnt, res, offset;
3910 for (i = 0, offset = st_bp->read_pointer;
3911 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3912 offset -= st_bp->frp[i].length;
3913 if (i == st_bp->frp_segs) { /* Should never happen */
3914 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3917 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3918 cnt = st_bp->frp[i].length - offset < do_count ?
3919 st_bp->frp[i].length - offset : do_count;
3920 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3924 st_bp->buffer_bytes -= cnt;
3925 st_bp->read_pointer += cnt;
3929 if (do_count) /* Should never happen */
3936 /* Move data towards start of buffer */
3937 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3939 int src_seg, dst_seg, src_offset = 0, dst_offset;
3945 total=st_bp->buffer_bytes - offset;
3946 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3947 src_offset = offset;
3948 if (src_offset < st_bp->frp[src_seg].length)
3950 offset -= st_bp->frp[src_seg].length;
3953 st_bp->buffer_bytes = st_bp->read_pointer = total;
3954 for (dst_seg=dst_offset=0; total > 0; ) {
3955 count = min(st_bp->frp[dst_seg].length - dst_offset,
3956 st_bp->frp[src_seg].length - src_offset);
3957 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3958 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3959 src_offset += count;
3960 if (src_offset >= st_bp->frp[src_seg].length) {
3964 dst_offset += count;
3965 if (dst_offset >= st_bp->frp[dst_seg].length) {
3974 /* Fill the s/g list up to the length required for this transfer */
3975 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3979 struct scatterlist *sg;
3980 struct st_buf_fragment *frp;
3982 if (length == STbp->frp_sg_current)
3983 return; /* work already done */
3985 sg = &(STbp->sg[0]);
3987 for (i=count=0; count < length; i++) {
3988 if (length - count > frp[i].length)
3989 sg_set_page(&sg[i], frp[i].page, frp[i].length, 0);
3991 sg_set_page(&sg[i], frp[i].page, length - count, 0);
3992 count += sg[i].length;
3995 STbp->frp_sg_current = length;
3999 /* Validate the options from command line or module parameters */
4000 static void validate_options(void)
4003 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
4004 if (max_sg_segs >= ST_FIRST_SG)
4005 st_max_sg_segs = max_sg_segs;
4009 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
4011 static int __init st_setup(char *str)
4013 int i, len, ints[5];
4016 stp = get_options(str, ARRAY_SIZE(ints), ints);
4019 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
4021 *parms[i].val = ints[i + 1];
4023 while (stp != NULL) {
4024 for (i = 0; i < ARRAY_SIZE(parms); i++) {
4025 len = strlen(parms[i].name);
4026 if (!strncmp(stp, parms[i].name, len) &&
4027 (*(stp + len) == ':' || *(stp + len) == '=')) {
4030 simple_strtoul(stp + len + 1, NULL, 0);
4032 printk(KERN_WARNING "st: Obsolete parameter %s\n",
4037 if (i >= ARRAY_SIZE(parms))
4038 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
4040 stp = strchr(stp, ',');
4051 __setup("st=", st_setup);
4055 static const struct file_operations st_fops =
4057 .owner = THIS_MODULE,
4060 .unlocked_ioctl = st_ioctl,
4061 #ifdef CONFIG_COMPAT
4062 .compat_ioctl = st_compat_ioctl,
4066 .release = st_release,
4069 static int st_probe(struct device *dev)
4071 struct scsi_device *SDp = to_scsi_device(dev);
4072 struct gendisk *disk = NULL;
4073 struct cdev *cdev = NULL;
4074 struct scsi_tape *tpnt = NULL;
4075 struct st_modedef *STm;
4076 struct st_partstat *STps;
4077 struct st_buffer *buffer;
4078 int i, j, mode, dev_num, error;
4081 if (SDp->type != TYPE_TAPE)
4083 if ((stp = st_incompatible(SDp))) {
4084 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
4085 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
4089 i = min(SDp->request_queue->max_hw_segments,
4090 SDp->request_queue->max_phys_segments);
4091 if (st_max_sg_segs < i)
4093 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
4094 if (buffer == NULL) {
4096 "st: Can't allocate new tape buffer. Device not attached.\n");
4100 disk = alloc_disk(1);
4102 printk(KERN_ERR "st: out of memory. Device not attached.\n");
4103 goto out_buffer_free;
4106 write_lock(&st_dev_arr_lock);
4107 if (st_nr_dev >= st_dev_max) {
4108 struct scsi_tape **tmp_da;
4111 tmp_dev_max = max(st_nr_dev * 2, 8);
4112 if (tmp_dev_max > ST_MAX_TAPES)
4113 tmp_dev_max = ST_MAX_TAPES;
4114 if (tmp_dev_max <= st_nr_dev) {
4115 write_unlock(&st_dev_arr_lock);
4116 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4121 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
4122 if (tmp_da == NULL) {
4123 write_unlock(&st_dev_arr_lock);
4124 printk(KERN_ERR "st: Can't extend device array.\n");
4128 if (scsi_tapes != NULL) {
4129 memcpy(tmp_da, scsi_tapes,
4130 st_dev_max * sizeof(struct scsi_tape *));
4133 scsi_tapes = tmp_da;
4135 st_dev_max = tmp_dev_max;
4138 for (i = 0; i < st_dev_max; i++)
4139 if (scsi_tapes[i] == NULL)
4141 if (i >= st_dev_max)
4142 panic("scsi_devices corrupt (st)");
4144 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4146 write_unlock(&st_dev_arr_lock);
4147 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4150 kref_init(&tpnt->kref);
4152 sprintf(disk->disk_name, "st%d", i);
4153 disk->private_data = &tpnt->driver;
4154 disk->queue = SDp->request_queue;
4155 tpnt->driver = &st_template;
4156 scsi_tapes[i] = tpnt;
4160 if (SDp->scsi_level <= 2)
4161 tpnt->tape_type = MT_ISSCSI1;
4163 tpnt->tape_type = MT_ISSCSI2;
4165 tpnt->buffer = buffer;
4166 tpnt->buffer->last_SRpnt = NULL;
4171 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4172 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4173 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4175 tpnt->do_auto_lock = ST_AUTO_LOCK;
4176 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4177 tpnt->can_partitions = 0;
4178 tpnt->two_fm = ST_TWO_FM;
4179 tpnt->fast_mteom = ST_FAST_MTEOM;
4180 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4181 tpnt->sili = ST_SILI;
4182 tpnt->immediate = ST_NOWAIT;
4183 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4184 tpnt->partition = 0;
4185 tpnt->new_partition = 0;
4186 tpnt->nbr_partitions = 0;
4187 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4188 tpnt->long_timeout = ST_LONG_TIMEOUT;
4189 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4191 for (i = 0; i < ST_NBR_MODES; i++) {
4192 STm = &(tpnt->modes[i]);
4194 STm->sysv = ST_SYSV;
4195 STm->defaults_for_writes = 0;
4196 STm->do_async_writes = ST_ASYNC_WRITES;
4197 STm->do_buffer_writes = ST_BUFFER_WRITES;
4198 STm->do_read_ahead = ST_READ_AHEAD;
4199 STm->default_compression = ST_DONT_TOUCH;
4200 STm->default_blksize = (-1); /* No forced size */
4201 STm->default_density = (-1); /* No forced density */
4204 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4205 STps = &(tpnt->ps[i]);
4207 STps->eof = ST_NOEOF;
4209 STps->last_block_valid = 0;
4210 STps->drv_block = (-1);
4211 STps->drv_file = (-1);
4214 tpnt->current_mode = 0;
4215 tpnt->modes[0].defined = 1;
4217 tpnt->density_changed = tpnt->compression_changed =
4218 tpnt->blksize_changed = 0;
4219 mutex_init(&tpnt->lock);
4222 write_unlock(&st_dev_arr_lock);
4224 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4225 STm = &(tpnt->modes[mode]);
4226 for (j=0; j < 2; j++) {
4227 cdev = cdev_alloc();
4230 "st%d: out of memory. Device not attached.\n",
4234 cdev->owner = THIS_MODULE;
4235 cdev->ops = &st_fops;
4237 error = cdev_add(cdev,
4238 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4241 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4242 dev_num, j ? "non" : "auto", mode);
4243 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4246 STm->cdevs[j] = cdev;
4249 error = do_create_class_files(tpnt, dev_num, mode);
4254 sdev_printk(KERN_NOTICE, SDp,
4255 "Attached scsi tape %s\n", tape_name(tpnt));
4256 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4257 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4258 queue_dma_alignment(SDp->request_queue) + 1);
4263 for (mode=0; mode < ST_NBR_MODES; mode++) {
4264 STm = &(tpnt->modes[mode]);
4265 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4267 for (j=0; j < 2; j++) {
4268 if (STm->cdevs[j]) {
4269 if (cdev == STm->cdevs[j])
4271 device_destroy(st_sysfs_class,
4272 MKDEV(SCSI_TAPE_MAJOR,
4273 TAPE_MINOR(i, mode, j)));
4274 cdev_del(STm->cdevs[j]);
4280 write_lock(&st_dev_arr_lock);
4281 scsi_tapes[dev_num] = NULL;
4283 write_unlock(&st_dev_arr_lock);
4294 static int st_remove(struct device *dev)
4296 struct scsi_device *SDp = to_scsi_device(dev);
4297 struct scsi_tape *tpnt;
4300 write_lock(&st_dev_arr_lock);
4301 for (i = 0; i < st_dev_max; i++) {
4302 tpnt = scsi_tapes[i];
4303 if (tpnt != NULL && tpnt->device == SDp) {
4304 scsi_tapes[i] = NULL;
4306 write_unlock(&st_dev_arr_lock);
4307 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4309 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4310 for (j=0; j < 2; j++) {
4311 device_destroy(st_sysfs_class,
4312 MKDEV(SCSI_TAPE_MAJOR,
4313 TAPE_MINOR(i, mode, j)));
4314 cdev_del(tpnt->modes[mode].cdevs[j]);
4315 tpnt->modes[mode].cdevs[j] = NULL;
4319 mutex_lock(&st_ref_mutex);
4320 kref_put(&tpnt->kref, scsi_tape_release);
4321 mutex_unlock(&st_ref_mutex);
4326 write_unlock(&st_dev_arr_lock);
4331 * scsi_tape_release - Called to free the Scsi_Tape structure
4332 * @kref: pointer to embedded kref
4334 * st_ref_mutex must be held entering this routine. Because it is
4335 * called on last put, you should always use the scsi_tape_get()
4336 * scsi_tape_put() helpers which manipulate the semaphore directly
4337 * and never do a direct kref_put().
4339 static void scsi_tape_release(struct kref *kref)
4341 struct scsi_tape *tpnt = to_scsi_tape(kref);
4342 struct gendisk *disk = tpnt->disk;
4344 tpnt->device = NULL;
4347 tpnt->buffer->orig_frp_segs = 0;
4348 normalize_buffer(tpnt->buffer);
4349 kfree(tpnt->buffer->reserved_pages);
4350 kfree(tpnt->buffer);
4353 disk->private_data = NULL;
4359 static int __init init_st(void)
4365 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4366 verstr, st_fixed_buffer_size, st_max_sg_segs);
4368 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4369 if (IS_ERR(st_sysfs_class)) {
4370 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4371 return PTR_ERR(st_sysfs_class);
4374 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4375 ST_MAX_TAPE_ENTRIES, "st");
4377 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4382 err = scsi_register_driver(&st_template.gendrv);
4386 err = do_create_sysfs_files();
4393 scsi_unregister_driver(&st_template.gendrv);
4395 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4396 ST_MAX_TAPE_ENTRIES);
4398 class_destroy(st_sysfs_class);
4402 static void __exit exit_st(void)
4404 do_remove_sysfs_files();
4405 scsi_unregister_driver(&st_template.gendrv);
4406 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4407 ST_MAX_TAPE_ENTRIES);
4408 class_destroy(st_sysfs_class);
4410 printk(KERN_INFO "st: Unloaded.\n");
4413 module_init(init_st);
4414 module_exit(exit_st);
4417 /* The sysfs driver interface. Read-only at the moment */
4418 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4420 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4422 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4424 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4426 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4428 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4430 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4432 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4434 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4436 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4438 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4440 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4442 static int do_create_sysfs_files(void)
4444 struct device_driver *sysfs = &st_template.gendrv;
4447 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4450 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4452 goto err_try_direct_io;
4453 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4455 goto err_attr_fixed_buf;
4456 err = driver_create_file(sysfs, &driver_attr_version);
4458 goto err_attr_max_sg;
4463 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4465 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4467 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4471 static void do_remove_sysfs_files(void)
4473 struct device_driver *sysfs = &st_template.gendrv;
4475 driver_remove_file(sysfs, &driver_attr_version);
4476 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4477 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4478 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4482 /* The sysfs simple class interface */
4484 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4486 struct st_modedef *STm = dev_get_drvdata(dev);
4489 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4493 DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4496 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
4498 struct st_modedef *STm = dev_get_drvdata(dev);
4501 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4505 DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4508 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
4510 struct st_modedef *STm = dev_get_drvdata(dev);
4514 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4515 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4519 DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4522 st_defcompression_show(struct device *dev, struct device_attribute *attr,
4525 struct st_modedef *STm = dev_get_drvdata(dev);
4528 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4532 DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4535 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
4537 struct st_modedef *STm = dev_get_drvdata(dev);
4538 struct scsi_tape *STp;
4542 for (i=0; i < st_dev_max; i++) {
4543 for (j=0; j < ST_NBR_MODES; j++)
4544 if (&scsi_tapes[i]->modes[j] == STm)
4546 if (j < ST_NBR_MODES)
4549 if (i == st_dev_max)
4550 return 0; /* should never happen */
4552 STp = scsi_tapes[i];
4554 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4555 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4556 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4557 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4558 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4559 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4560 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4561 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4562 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4563 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4564 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4565 options |= STm->sysv ? MT_ST_SYSV : 0;
4566 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4567 options |= STp->sili ? MT_ST_SILI : 0;
4569 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4573 DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
4575 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4579 struct device *st_class_member;
4581 for (rew=0; rew < 2; rew++) {
4582 /* Make sure that the minor numbers corresponding to the four
4583 first modes always get the same names */
4584 i = mode << (4 - ST_NBR_MODE_BITS);
4585 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4586 STp->disk->disk_name, st_formats[i]);
4588 device_create(st_sysfs_class, &STp->device->sdev_gendev,
4589 MKDEV(SCSI_TAPE_MAJOR,
4590 TAPE_MINOR(dev_num, mode, rew)),
4591 &STp->modes[mode], "%s", name);
4592 if (IS_ERR(st_class_member)) {
4593 printk(KERN_WARNING "st%d: device_create failed\n",
4595 error = PTR_ERR(st_class_member);
4599 error = device_create_file(st_class_member,
4601 if (error) goto out;
4602 error = device_create_file(st_class_member,
4603 &dev_attr_default_blksize);
4604 if (error) goto out;
4605 error = device_create_file(st_class_member,
4606 &dev_attr_default_density);
4607 if (error) goto out;
4608 error = device_create_file(st_class_member,
4609 &dev_attr_default_compression);
4610 if (error) goto out;
4611 error = device_create_file(st_class_member,
4613 if (error) goto out;
4615 if (mode == 0 && rew == 0) {
4616 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4617 &st_class_member->kobj,
4621 "st%d: Can't create sysfs link from SCSI device.\n",
4634 /* The following functions may be useful for a larger audience. */
4635 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4636 unsigned long uaddr, size_t count, int rw)
4638 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4639 unsigned long start = uaddr >> PAGE_SHIFT;
4640 const int nr_pages = end - start;
4642 struct page **pages;
4644 /* User attempted Overflow! */
4645 if ((uaddr + count) < uaddr)
4649 if (nr_pages > max_pages)
4656 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4659 /* Try to fault in all of the necessary pages */
4660 down_read(¤t->mm->mmap_sem);
4661 /* rw==READ means read from drive, write into memory area */
4662 res = get_user_pages(
4668 0, /* don't force */
4671 up_read(¤t->mm->mmap_sem);
4673 /* Errors and no page mapped should return here */
4677 for (i=0; i < nr_pages; i++) {
4678 /* FIXME: flush superflous for rw==READ,
4679 * probably wrong function for rw==WRITE
4681 flush_dcache_page(pages[i]);
4684 /* Populate the scatter/gather list */
4685 sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK);
4687 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4688 count -= sgl[0].length;
4689 for (i=1; i < nr_pages ; i++) {
4690 sg_set_page(&sgl[i], pages[i],
4691 count < PAGE_SIZE ? count : PAGE_SIZE, 0);;
4696 sgl[0].length = count;
4704 for (j=0; j < res; j++)
4705 page_cache_release(pages[j]);
4713 /* And unmap them... */
4714 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4719 for (i=0; i < nr_pages; i++) {
4720 struct page *page = sg_page(&sgl[i]);
4724 /* FIXME: cache flush missing for rw==READ
4725 * FIXME: call the correct reference counting function
4727 page_cache_release(page);